@@ -20,6 +20,7 @@ import { type SessionSummary, type StoredMessage } from '@maka/core/session';
 import { type ThinkingLevel } from '@maka/core/model-thinking';
 import { type UserQuestionResponse } from '@maka/core/user-question';
 import type { SkillInvocationResult } from '@maka/core/skill-invocation';
+import type { AgentGraphClientSnapshot } from '@maka/runtime-host/protocol';
 import { SessionActivityRegistry } from '@maka/runtime/goal-turn-lifecycle';
 import { type ContextDiagnostics } from '@maka/runtime/context-diagnostics';
 import type {
@@ -116,6 +117,40 @@ function deferred<T>() {
   return { promise, resolve };
 }
 
+function historicalGraphSnapshot(graphId: string): AgentGraphClientSnapshot {
+  return {
+    schemaVersion: 1,
+    rootSessionId: 'session-1',
+    graphId,
+    orchestrationMode: 'graph',
+    snapshotVersion: `sha256:${'1'.repeat(64)}`,
+    status: 'completed',
+    scheduleRevision: 2,
+    topologyFingerprint: `sha256:${'2'.repeat(64)}`,
+    closed: true,
+    operators: [],
+    edges: [],
+    work: [],
+    reconciliationFailures: [],
+    stoppedTargets: [],
+    finish: { resultIds: ['result-1'], reason: 'done', revision: 2, committedAt: 2 },
+    claims: [],
+    recentControlDecisions: [],
+    recentActivity: [],
+    terminalHistory: { records: [] },
+    omitted: {
+      operators: 0,
+      edges: 0,
+      work: 0,
+      reconciliationFailures: 0,
+      stoppedTargets: 0,
+      claims: 0,
+      controlDecisions: 0,
+      recentActivity: 0,
+    },
+  };
+}
+
 /** Catalog API-key providers as wizard entries with no existing connection —
  *  the default `/setup` provider list for tests that don't need 已设置 state. */
 function defaultOnboardingProviders(): OnboardingProviderEntry[] {
@@ -2436,6 +2471,47 @@ describe('Maka Pi TUI runner', () => {
     await run;
   });
 
+  test('inspects a historical Agent Graph run without starting a turn', async () => {
+    const terminal = new FakeTerminal();
+    const driver = new SlashCommandDriver();
+    const requestedGraphIds: string[] = [];
+    const run = runMakaPiTui({
+      title: 'Maka',
+      driver,
+      cwd: '/repo',
+      model: 'deepseek-v4-flash',
+      connectionSlug: 'deepseek',
+      permissionMode: 'ask',
+      terminal,
+      agentGraphHistory: {
+        listEpochs: async () => [
+          { epoch: 2, graphId: 'graph-2', createdAt: 2, current: true },
+          { epoch: 1, graphId: 'graph-1', createdAt: 1, current: false },
+        ],
+        getSnapshot: async (_rootSessionId, graphId) => {
+          requestedGraphIds.push(graphId);
+          return historicalGraphSnapshot(graphId);
+        },
+      },
+    });
+
+    terminal.input('/graph history');
+    terminal.input('\r');
+    await waitFor(() =>
+      plainTerminalOutput(terminal.screenOutput()).includes('Agent Graph History'),
+    );
+    terminal.input('\x1b[B');
+    terminal.input('\r');
+    await waitFor(() =>
+      plainTerminalOutput(terminal.output()).includes('Agent Graph run #1 · History (read-only)'),
+    );
+
+    assert.deepEqual(requestedGraphIds, ['graph-1']);
+    assert.deepEqual(driver.prompts, []);
+    exitMaka(terminal);
+    await run;
+  });
+
   test('rejects unsupported /thinking levels with usage instead of sending an update', async () => {
     const terminal = new FakeTerminal();
     const driver = new SlashCommandDriver();
 
@@ -53,6 +53,7 @@ import type {
 } from './pi-tui-contracts.js';
 import { AUTO_RECAP_DISPLAY_LIMIT_BYTES, shouldAutoRecap } from './session-recap.js';
 import type { InvocableSkillEntry } from '@maka/runtime/skill-invocation';
+import type { AgentGraphClientSnapshot, AgentGraphEpochSummary } from '@maka/runtime-host/protocol';
 import { MakaSkillHighlightEditor } from './skill-highlight-editor.js';
 import { parseGraphCommand, type ParsedGraphCommand } from '@maka/core/graph-command';
 import { parseSwarmCommand, type ParsedSwarmCommand } from '@maka/core/swarm-command';
@@ -166,6 +167,11 @@ export interface MakaPiTuiInput {
   listShellRunUpdates?: (sessionId: string) => Promise<ShellRunUpdate[]>;
   /** Host-owned invocable Skill catalog used for picker, completion, and token highlighting. */
   listSkills?: (cwd: string) => Promise<readonly InvocableSkillEntry[]>;
+  /** Read-only Runtime Host projection for inspecting current and historical Graph epochs. */
+  agentGraphHistory?: {
+    listEpochs(rootSessionId: string): Promise<readonly AgentGraphEpochSummary[]>;
+    getSnapshot(rootSessionId: string, graphId: string): Promise<AgentGraphClientSnapshot>;
+  };
   /** Serializes TUI turn and control activity for the attached Session. */
   turnActivity: MakaPiTuiTurnActivitySurface;
   /** API-key onboarding surface (#1098). When present, /setup runs the wizard,
@@ -2264,6 +2270,56 @@ export async function runMakaPiTui(input: MakaPiTuiInput): Promise<void> {
     requestRender();
   };
 
+  const showGraphHistory = async (): Promise<void> => {
+    const rootSessionId = input.driver.getSessionId();
+    if (!rootSessionId || !input.agentGraphHistory) {
+      throw new Error('Agent Graph history is unavailable on this session driver.');
+    }
+    const epochs = await input.agentGraphHistory.listEpochs(rootSessionId);
+    const items: SelectItem[] = epochs.map((entry) => ({
+      value: entry.graphId,
+      label: `Run #${entry.epoch}${entry.current ? ' · Current' : ''}`,
+      description: entry.current ? 'Current graph' : 'History · read-only',
+    }));
+    if (items.length === 0) {
+      state.entries.push({
+        kind: 'notice',
+        level: 'info',
+        text: 'This session has no Agent Graph runs.',
+      });
+      requestRender();
+      return;
+    }
+    const epochsByGraphId = new Map(epochs.map((entry) => [entry.graphId, entry]));
+    showSelectPicker(
+      'Agent Graph History',
+      `${items.length} run${items.length === 1 ? '' : 's'}`,
+      items,
+      (item) => {
+        const epoch = epochsByGraphId.get(item.value);
+        if (!epoch) return;
+        void runControl(async () => {
+          const graph = await input.agentGraphHistory!.getSnapshot(rootSessionId, epoch.graphId);
+          state.entries.push({
+            kind: 'notice',
+            level: 'info',
+            text: formatAgentGraphHistory(graph, epoch),
+          });
+          requestRender();
+        });
+      },
+      {
+        minPrimaryColumnWidth: 16,
+        maxPrimaryColumnWidth: 28,
+        selectedIndex: Math.max(
+          0,
+          epochs.findIndex((entry) => entry.current),
+        ),
+        hint: '↑↓ move · Enter inspect · Esc close',
+      },
+    );
+  };
+
   const setGraphMode = async (mode: OrchestrationMode) => {
     if (!input.driver.setOrchestrationMode) {
       throw new Error('Graph Mode is unavailable on this session driver.');
@@ -2283,6 +2339,10 @@ export async function runMakaPiTui(input: MakaPiTuiInput): Promise<void> {
       showGraphStatus();
       return;
     }
+    if (command.kind === 'history') {
+      void runControl(showGraphHistory);
+      return;
+    }
     if (command.kind === 'set_mode') {
       void runControl(() => setGraphMode(command.mode));
       return;
@@ -3025,6 +3085,41 @@ function formatContextCount(value: number): string {
   return value.toLocaleString('en-US');
 }
 
+function formatAgentGraphHistory(
+  graph: AgentGraphClientSnapshot,
+  epoch: AgentGraphEpochSummary,
+): string {
+  const settled = graph.operators.filter((operator) =>
+    ['completed', 'failed', 'aborted', 'cancelled'].includes(operator.status),
+  ).length;
+  const lines = [
+    `Agent Graph run #${epoch.epoch}${epoch.current ? ' · Current' : ' · History (read-only)'}`,
+    `  ${formatAgentGraphStatus(graph.status)} · ${settled}/${graph.operators.length} operators settled`,
+  ];
+  for (const operator of graph.operators) {
+    lines.push(`  ${operator.agentId}: ${operator.status.replaceAll('_', ' ')}`);
+  }
+  if (graph.finish) {
+    lines.push(`  Selected results: ${graph.finish.resultIds.join(', ') || 'none'}`);
+  }
+  if (graph.omitted.operators > 0) {
+    lines.push(`  ${graph.omitted.operators} more operators omitted`);
+  }
+  return lines.join('\n');
+}
+
+function formatAgentGraphStatus(status: AgentGraphClientSnapshot['status']): string {
+  return {
+    empty: 'Awaiting schedule',
+    active: 'Running',
+    closing: 'Finishing',
+    waiting: 'Waiting',
+    stopped: 'Stopped',
+    failed: 'Failed',
+    completed: 'Completed',
+  }[status];
+}
+
 function flattenLinkedSessionTree(
   roots: readonly SessionSummary[],
   childrenByParentId: ReadonlyMap<string, readonly SessionSummary[]>,
 
@@ -64,6 +64,7 @@ export async function runRuntimeHostTui(input: RunRuntimeHostTuiInput): Promise<
       permissionMode: 'ask',
       turnActivity: context.turnActivity,
       listSkills: context.listSkills,
+      agentGraphHistory: context.agentGraphHistory,
       onboarding: context.onboarding,
       recap: context.recap,
       ...(context.profile.kind === 'local'
 
@@ -5,12 +5,17 @@ import type { ConnectionCatalogEntry, ConnectionCatalogSnapshot } from '@maka/co
 import { SessionActivityRegistry } from '@maka/runtime/goal-turn-lifecycle';
 import { type InvocableSkillEntry } from '@maka/runtime/skill-invocation';
 import {
+  readRuntimeHostAgentGraphEpochs,
   readRuntimeHostInvocableSkills,
   readRuntimeHostProjects,
   type RuntimeHostConnection,
   type RuntimeHostProfile,
 } from '@maka/runtime-host/client';
-import type { WorkspaceTarget } from '@maka/runtime-host/protocol';
+import type {
+  AgentGraphClientSnapshot,
+  AgentGraphEpochSummary,
+  WorkspaceTarget,
+} from '@maka/runtime-host/protocol';
 import { connectRuntimeHostCli, resolveRuntimeHostCliTarget } from './runtime-host-cli-context.js';
 import type {
   MakaPiTuiTurnActivitySurface,
@@ -38,6 +43,10 @@ export interface RuntimeHostTuiContext {
   readonly modelChoices: readonly ModelChoice[];
   readonly turnActivity: MakaPiTuiTurnActivitySurface;
   readonly listSkills: (cwd: string) => Promise<readonly InvocableSkillEntry[]>;
+  readonly agentGraphHistory: {
+    listEpochs(rootSessionId: string): Promise<readonly AgentGraphEpochSummary[]>;
+    getSnapshot(rootSessionId: string, graphId: string): Promise<AgentGraphClientSnapshot>;
+  };
   readonly recap: SessionRecapGenerator;
   readonly onboarding: ReturnType<typeof createRuntimeHostOnboardingSurface>;
   readonly profile: RuntimeHostProfile;
@@ -101,6 +110,7 @@ export async function createRuntimeHostTuiContext(
             (connected.profile.kind === 'local' ? { kind: 'host_path', path: cwd } : undefined),
           driver.getPermissionMode?.() ?? 'ask',
         ),
+      agentGraphHistory: createRuntimeHostAgentGraphHistory(connection),
       recap: createRuntimeHostRecapGenerator(connection),
       onboarding: createRuntimeHostOnboardingSurface(connection),
       profile: connected.profile,
@@ -112,6 +122,16 @@ export async function createRuntimeHostTuiContext(
   }
 }
 
+function createRuntimeHostAgentGraphHistory(
+  connection: RuntimeHostConnection,
+): RuntimeHostTuiContext['agentGraphHistory'] {
+  return {
+    listEpochs: (rootSessionId) => readRuntimeHostAgentGraphEpochs(connection, rootSessionId),
+    getSnapshot: (rootSessionId, graphId) =>
+      connection.request('agent.graph.query', { rootSessionId, graphId }),
+  };
+}
+
 function createRuntimeHostRecapGenerator(connection: RuntimeHostConnection): SessionRecapGenerator {
   return {
     generate: async (sessionId, reason) => {