feat(thread-read): show role system prompt in each step

Each step block now includes a '### Prompt' section showing the
role's systemPrompt from the workflow definition.

Refs #349

.gitignore

@@ -10,3 +10,4 @@ xiaoju/
 solve-issue-entry.ts
 packages/workflow-template-develop/develop.esm.js
 .DS_Store
+*.py

packages/cli-uwf/package.json

@@ -11,8 +11,8 @@
     "uwf": "./src/cli.ts"
   },
   "dependencies": {
-    "@uncaged/json-cas": "^0.1.3",
-    "@uncaged/json-cas-fs": "^0.1.2",
+    "@uncaged/json-cas": "^0.3.0",
+    "@uncaged/json-cas-fs": "^0.3.0",
     "@uncaged/uwf-agent-kit": "workspace:^",
     "@uncaged/uwf-moderator": "workspace:^",
     "@uncaged/uwf-protocol": "workspace:^",

packages/cli-uwf/src/cli.ts

@@ -1,21 +1,26 @@
 #!/usr/bin/env bun
 
 import { Command } from "commander";
+import type { ThreadId } from "@uncaged/uwf-protocol";
 
 import {
+  cmdThreadFork,
   cmdThreadKill,
   cmdThreadList,
+  cmdThreadRead,
+  THREAD_READ_DEFAULT_QUOTA,
   cmdThreadShow,
   cmdThreadStart,
   cmdThreadStep,
+  cmdThreadSteps,
 } from "./commands/thread.js";
 import { cmdWorkflowList, cmdWorkflowPut, cmdWorkflowShow } from "./commands/workflow.js";
 import { cmdSetup, cmdSetupInteractive } from "./commands/setup.js";
 import {
-  cmdCasCat,
   cmdCasGet,
   cmdCasHas,
   cmdCasPut,
+  cmdCasReindex,
   cmdCasRefs,
   cmdCasSchemaGet,
   cmdCasSchemaList,
@@ -144,6 +149,52 @@ thread
     });
   });
 
+thread
+  .command("steps")
+  .description("List all steps in a thread")
+  .argument("<thread-id>", "Thread ULID")
+  .action((threadId: string) => {
+    const storageRoot = resolveStorageRoot();
+    runAction(async () => {
+      const result = await cmdThreadSteps(storageRoot, threadId);
+      writeOutput(result);
+    });
+  });
+
+thread
+  .command("read")
+  .description("Read thread context as human-readable markdown")
+  .argument("<thread-id>", "Thread ULID")
+  .option("--quota <chars>", "Max output characters", String(THREAD_READ_DEFAULT_QUOTA))
+  .option("--before <step-hash>", "Load steps before this hash (exclusive)")
+  .option("--start", "Include start step in output")
+  .option("--detail", "Expand detail content for each step")
+  .action((threadId: string, opts: { quota: string; before: string | undefined; start: boolean; detail: boolean }) => {
+    const storageRoot = resolveStorageRoot();
+    runAction(async () => {
+      const quota = Number.parseInt(opts.quota, 10);
+      if (!Number.isFinite(quota) || quota < 1) {
+        process.stderr.write("invalid --quota: must be a positive integer\n");
+        process.exit(1);
+      }
+      const before = opts.before ?? null;
+      const markdown = await cmdThreadRead(storageRoot, threadId as ThreadId, quota, before, opts.start ?? false, opts.detail ?? false);
+      process.stdout.write(markdown.endsWith("\n") ? markdown : `${markdown}\n`);
+    });
+  });
+
+thread
+  .command("fork")
+  .description("Fork a thread from a specific step")
+  .argument("<step-hash>", "CAS hash of the StartNode or StepNode to fork from")
+  .action((stepHash: string) => {
+    const storageRoot = resolveStorageRoot();
+    runAction(async () => {
+      const result = await cmdThreadFork(storageRoot, stepHash);
+      writeOutput(result);
+    });
+  });
+
 program
   .command("setup")
   .description("Configure provider, model, and agent")
@@ -185,24 +236,13 @@ const cas = program.command("cas").description("Content-addressable storage oper
 
 cas
   .command("get")
-  .description("Read a CAS node as JSON")
+  .description("Read a CAS node (type + payload; use --timestamp to include timestamp)")
   .argument("<hash>", "CAS hash (13 char)")
-  .action((hash: string) => {
+  .option("--timestamp", "Include timestamp in output")
+  .action((hash: string, opts: { timestamp?: boolean }) => {
     const storageRoot = resolveStorageRoot();
     runAction(async () => {
-      writeOutput(await cmdCasGet(storageRoot, hash));
-    });
-  });
-
-cas
-  .command("cat")
-  .description("Output a CAS node (--payload for payload only)")
-  .argument("<hash>", "CAS hash (13 char)")
-  .option("--payload", "Output only the payload")
-  .action((hash: string, opts: { payload?: boolean }) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      writeOutput(await cmdCasCat(storageRoot, hash, opts));
+      writeOutput(await cmdCasGet(storageRoot, hash, opts));
     });
   });
 
@@ -251,6 +291,16 @@ cas
     });
   });
 
+cas
+  .command("reindex")
+  .description("Rebuild type index from all CAS nodes")
+  .action(() => {
+    const storageRoot = resolveStorageRoot();
+    runAction(async () => {
+      writeOutput(await cmdCasReindex(storageRoot));
+    });
+  });
+
 const casSchema = cas.command("schema").description("CAS schema operations");
 
 casSchema

packages/cli-uwf/src/commands/cas.ts

@@ -28,26 +28,18 @@ function readJsonArg(fileOrInline: string): unknown {
 export async function cmdCasGet(
   storageRoot: string,
   hash: string,
+  opts: { timestamp?: boolean },
 ): Promise<unknown> {
   const store = openStore(storageRoot);
   const node = store.get(hash);
   if (node === null) {
     throw new Error(`Node not found: ${hash}`);
   }
-  return node;
-}
-
-export async function cmdCasCat(
-  storageRoot: string,
-  hash: string,
-  opts: { payload?: boolean },
-): Promise<unknown> {
-  const store = openStore(storageRoot);
-  const node = store.get(hash);
-  if (node === null) {
-    throw new Error(`Node not found: ${hash}`);
+  if (opts.timestamp) {
+    return node;
   }
-  return opts.payload ? node.payload : node;
+  const { timestamp: _, ...rest } = node as Record<string, unknown>;
+  return rest;
 }
 
 export async function cmdCasPut(
@@ -108,10 +100,10 @@ export async function cmdCasSchemaList(
   // Include meta-schema itself
   entries.push({ hash: metaHash, title: "(meta-schema)" });
 
-  for (const hash of store.list()) {
+  for (const hash of store.listByType(metaHash)) {
     if (hash === metaHash) continue;
     const node = store.get(hash);
-    if (node !== null && node.type === metaHash) {
+    if (node !== null) {
       const schema = node.payload as JSONSchema;
       const title =
         (schema.title as string | undefined) ??
@@ -123,6 +115,17 @@ export async function cmdCasSchemaList(
   return entries;
 }
 
+export async function cmdCasReindex(
+  storageRoot: string,
+): Promise<{ status: string }> {
+  const indexDir = join(storageRoot, "cas", "_index");
+  const { rmSync } = await import("node:fs");
+  rmSync(indexDir, { recursive: true, force: true });
+  // Re-open store to trigger migration rebuild
+  openStore(storageRoot);
+  return { status: "reindexed" };
+}
+
 export async function cmdCasSchemaGet(
   storageRoot: string,
   hash: string,

packages/cli-uwf/src/commands/thread.ts

@@ -1,6 +1,8 @@
 import { execFileSync } from "node:child_process";
 
-import { validate } from "@uncaged/json-cas";
+import { getSchema, validate } from "@uncaged/json-cas";
+import type { JSONSchema, Store as CasStore } from "@uncaged/json-cas";
+import { stringify } from "yaml";
 import { getEnvPath, loadWorkflowConfig } from "@uncaged/uwf-agent-kit";
 import { evaluate } from "@uncaged/uwf-moderator";
 import type {
@@ -8,13 +10,17 @@ import type {
   AgentConfig,
   CasRef,
   ModeratorContext,
+  StartEntry,
   StartNodePayload,
   StartOutput,
   StepContext,
+  StepEntry,
   StepNodePayload,
   StepOutput,
+  ThreadForkOutput,
   ThreadId,
   ThreadListItem,
+  ThreadStepsOutput,
   WorkflowConfig,
   WorkflowPayload,
 } from "@uncaged/uwf-protocol";
@@ -36,6 +42,7 @@ import {
 import { isCasRef } from "../validate.js";
 
 const END_ROLE = "$END";
+export const THREAD_READ_DEFAULT_QUOTA = 4000;
 
 type ChainState = {
   startHash: CasRef;
@@ -44,6 +51,12 @@ type ChainState = {
   headIsStart: boolean;
 };
 
+type OrderedStepItem = {
+  hash: CasRef;
+  payload: StepNodePayload;
+  timestamp: number;
+};
+
 export type KillOutput = {
   thread: ThreadId;
   archived: boolean;
@@ -262,6 +275,215 @@ function expandOutput(uwf: UwfStore, outputRef: CasRef): unknown {
   return node.payload;
 }
 
+/**
+ * Recursively expand all cas_ref fields in a CAS node's payload,
+ * replacing hash strings with the referenced node's expanded payload.
+ */
+function expandDeep(store: CasStore, hash: CasRef, visited?: Set<string>): unknown {
+  const seen = visited ?? new Set<string>();
+  if (seen.has(hash)) return hash; // cycle guard
+  seen.add(hash);
+
+  const node = store.get(hash);
+  if (node === null) return hash;
+
+  const schema = getSchema(store, node.type);
+  if (schema === null) return node.payload;
+
+  return expandValue(store, schema, node.payload, seen);
+}
+
+function expandValue(store: CasStore, schema: JSONSchema, value: unknown, visited: Set<string>): unknown {
+  // If this field is a cas_ref, expand it
+  if (schema.format === "cas_ref") {
+    if (typeof value === "string") {
+      return expandDeep(store, value as CasRef, visited);
+    }
+    return value;
+  }
+
+  // anyOf (nullable refs)
+  if (Array.isArray(schema.anyOf)) {
+    for (const sub of schema.anyOf as JSONSchema[]) {
+      if (sub.format === "cas_ref" && typeof value === "string") {
+        return expandDeep(store, value as CasRef, visited);
+      }
+    }
+    return value;
+  }
+
+  // Array of cas_ref items
+  if (schema.type === "array" && schema.items && Array.isArray(value)) {
+    const itemSchema = schema.items as JSONSchema;
+    return (value as unknown[]).map((item) => expandValue(store, itemSchema, item, visited));
+  }
+
+  // Object with properties
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && schema.properties) {
+    const props = schema.properties as Record<string, JSONSchema>;
+    const obj = value as Record<string, unknown>;
+    const result: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(obj)) {
+      const propSchema = props[key];
+      result[key] = propSchema ? expandValue(store, propSchema, val, visited) : val;
+    }
+    return result;
+  }
+
+  return value;
+}
+
+function collectOrderedSteps(
+  uwf: UwfStore,
+  headHash: CasRef,
+  chain: ChainState,
+): OrderedStepItem[] {
+  let hash: CasRef | null = headHash;
+  const hashToNode = new Map<string, { payload: StepNodePayload; timestamp: number }>();
+  while (hash !== null) {
+    const node = uwf.store.get(hash);
+    if (node === null || node.type !== uwf.schemas.stepNode) {
+      break;
+    }
+    const payload = node.payload as StepNodePayload;
+    hashToNode.set(hash, { payload, timestamp: node.timestamp });
+    hash = payload.prev;
+  }
+
+  let cur: CasRef | null = chain.headIsStart ? null : headHash;
+  const ordered: OrderedStepItem[] = [];
+  while (cur !== null) {
+    const entry = hashToNode.get(cur);
+    if (entry === undefined) {
+      break;
+    }
+    ordered.push({ hash: cur, ...entry });
+    cur = entry.payload.prev;
+  }
+  ordered.reverse();
+  return ordered;
+}
+
+function formatYaml(value: unknown): string {
+  return stringify(value).trimEnd();
+}
+
+function formatCompactStep(index: number, item: OrderedStepItem, outputYaml: string): string {
+  return [
+    `## Step ${index}: ${item.payload.role}`,
+    "",
+    `- **Hash:** \`${item.hash}\``,
+    `- **Agent:** ${item.payload.agent}`,
+    "",
+    "### Output",
+    "",
+    "```yaml",
+    outputYaml,
+    "```",
+  ].join("\n");
+}
+
+function formatThreadReadMarkdown(options: {
+  threadId: ThreadId;
+  workflowName: string;
+  workflowHash: CasRef;
+  prompt: string;
+  ordered: OrderedStepItem[];
+  uwf: UwfStore;
+  workflow: WorkflowPayload;
+  quota: number;
+  before: CasRef | null;
+  showStart: boolean;
+  showDetail: boolean;
+}): string {
+  const { ordered, uwf, workflow, quota, before, showStart, showDetail } = options;
+
+  // Determine which steps to consider
+  let candidates = ordered;
+  if (before !== null) {
+    const idx = candidates.findIndex((s) => s.hash === before);
+    if (idx === -1) {
+      fail(`step ${before} not found in thread ${options.threadId}`);
+    }
+    candidates = candidates.slice(0, idx);
+  }
+
+  // Walk backward from newest, accumulating chars until quota exceeded
+  const selected: OrderedStepItem[] = [];
+  let totalChars = 0;
+  for (let i = candidates.length - 1; i >= 0; i--) {
+    const item = candidates[i];
+    if (item === undefined) continue;
+    const outputYaml = formatYaml(expandOutput(uwf, item.payload.output));
+    const blockLen = formatCompactStep(i + 1, item, outputYaml).length;
+    selected.unshift(item);
+    totalChars += blockLen;
+    if (totalChars > quota) break;
+  }
+
+  const skippedCount = candidates.length - selected.length;
+  const parts: string[] = [];
+
+  // Start section
+  if (before === null || showStart) {
+    parts.push(
+      [
+        `# Thread \`${options.threadId}\``,
+        "",
+        `**Workflow:** ${options.workflowName} (\`${options.workflowHash}\`)`,
+        "",
+        "## Task",
+        "",
+        options.prompt,
+      ].join("\n"),
+    );
+  }
+
+  // Skip hint
+  if (skippedCount > 0 && selected.length > 0) {
+    const firstSelected = selected[0];
+    if (firstSelected !== undefined) {
+      parts.push(
+        `*(${skippedCount} earlier step${skippedCount > 1 ? "s" : ""}, load with \`uwf thread read ${options.threadId} --before ${firstSelected.hash}\`)*`,
+      );
+    }
+  }
+
+  // Step blocks
+  const startIndex = candidates.length - selected.length;
+  for (let i = 0; i < selected.length; i++) {
+    const item = selected[i];
+    if (item === undefined) continue;
+    const stepNum = startIndex + i + 1;
+    const outputYaml = formatYaml(expandOutput(uwf, item.payload.output));
+    const ts = new Date(item.timestamp).toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+    const stepLines = [
+      `## Step ${stepNum}: ${item.payload.role} \`${item.hash}\``,
+      `**Agent:** ${item.payload.agent} | **Time:** ${ts}`,
+    ];
+    const roleDef = workflow.roles[item.payload.role];
+    if (roleDef) {
+      stepLines.push("", "### Prompt", "", roleDef.systemPrompt);
+    }
+    stepLines.push(
+      "",
+      "### Output",
+      "",
+      "```yaml",
+      outputYaml,
+      "```",
+    );
+    if (showDetail && item.payload.detail) {
+      const detailExpanded = expandDeep(uwf.store, item.payload.detail);
+      const detailYaml = formatYaml(detailExpanded);
+      stepLines.push("", "### Detail", "", "```yaml", detailYaml, "```");
+    }
+    parts.push(stepLines.join("\n"));
+  }
+
+  return parts.join("\n\n---\n\n");
+}
+
 function buildModeratorContext(uwf: UwfStore, chain: ChainState): ModeratorContext {
   const chronological = [...chain.stepsNewestFirst].reverse();
   const steps: StepContext[] = chronological.map((step) => ({
@@ -437,6 +659,115 @@ export async function cmdThreadStep(
   };
 }
 
+async function resolveHeadHash(storageRoot: string, threadId: ThreadId): Promise<CasRef> {
+  const index = await loadThreadsIndex(storageRoot);
+  const activeHead = index[threadId];
+  if (activeHead !== undefined) {
+    return activeHead;
+  }
+  const hist = await findThreadInHistory(storageRoot, threadId);
+  if (hist !== null) {
+    return hist.head;
+  }
+  fail(`thread not found: ${threadId}`);
+}
+
+export async function cmdThreadSteps(
+  storageRoot: string,
+  threadId: ThreadId,
+): Promise<ThreadStepsOutput> {
+  const headHash = await resolveHeadHash(storageRoot, threadId);
+  const uwf = await createUwfStore(storageRoot);
+  const chain = walkChain(uwf, headHash);
+
+  const startNode = uwf.store.get(chain.startHash);
+  if (startNode === null) {
+    fail(`StartNode not found: ${chain.startHash}`);
+  }
+
+  const startEntry: StartEntry = {
+    hash: chain.startHash,
+    workflow: chain.start.workflow,
+    prompt: chain.start.prompt,
+    timestamp: startNode.timestamp,
+  };
+
+  const stepEntries: StepEntry[] = [];
+  const ordered = collectOrderedSteps(uwf, headHash, chain);
+
+  for (const item of ordered) {
+    stepEntries.push({
+      hash: item.hash,
+      role: item.payload.role,
+      output: expandOutput(uwf, item.payload.output),
+      detail: item.payload.detail,
+      agent: item.payload.agent,
+      timestamp: item.timestamp,
+    });
+  }
+
+  return {
+    thread: threadId,
+    workflow: chain.start.workflow,
+    steps: [startEntry, ...stepEntries],
+  };
+}
+
+export async function cmdThreadRead(
+  storageRoot: string,
+  threadId: ThreadId,
+  quota: number = THREAD_READ_DEFAULT_QUOTA,
+  before: CasRef | null = null,
+  showStart: boolean = false,
+  showDetail: boolean = false,
+): Promise<string> {
+  const headHash = await resolveHeadHash(storageRoot, threadId);
+  const uwf = await createUwfStore(storageRoot);
+  const chain = walkChain(uwf, headHash);
+  const workflow = loadWorkflowPayload(uwf, chain.start.workflow);
+  const ordered = collectOrderedSteps(uwf, headHash, chain);
+
+  return formatThreadReadMarkdown({
+    threadId,
+    workflowName: workflow.name,
+    workflowHash: chain.start.workflow,
+    prompt: chain.start.prompt,
+    ordered,
+    uwf,
+    workflow,
+    quota,
+    before,
+    showStart,
+    showDetail,
+  });
+}
+
+export async function cmdThreadFork(
+  storageRoot: string,
+  stepHash: CasRef,
+): Promise<ThreadForkOutput> {
+  const uwf = await createUwfStore(storageRoot);
+  const node = uwf.store.get(stepHash);
+  if (node === null) {
+    fail(`CAS node not found: ${stepHash}`);
+  }
+  if (node.type !== uwf.schemas.startNode && node.type !== uwf.schemas.stepNode) {
+    fail(`node ${stepHash} is not a StartNode or StepNode`);
+  }
+
+  const newThreadId = generateUlid(Date.now()) as ThreadId;
+  const index = await loadThreadsIndex(storageRoot);
+  index[newThreadId] = stepHash;
+  await saveThreadsIndex(storageRoot, index);
+
+  return {
+    thread: newThreadId,
+    forkedFrom: {
+      step: stepHash,
+    },
+  };
+}
+
 export async function cmdThreadKill(storageRoot: string, threadId: ThreadId): Promise<KillOutput> {
   const index = await loadThreadsIndex(storageRoot);
   const head = index[threadId];

packages/uwf-agent-hermes/__tests__/session-detail.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, test } from "bun:test";
+import { createMemoryStore, refs, validate, walk } from "@uncaged/json-cas";
+
+import {
+  computeDurationMs,
+  extractLastAssistantContent,
+  messageToTurnPayload,
+  parseSessionIdFromStdout,
+  storeHermesSessionDetail,
+} from "../src/session-detail.js";
+import type { HermesSessionJson, HermesSessionMessage } from "../src/types.js";
+
+describe("parseSessionIdFromStdout", () => {
+  test("reads session_id from the last non-empty line", () => {
+    const stdout = "Done.\n\nsession_id: 20260518_223724_45ab80\n";
+    expect(parseSessionIdFromStdout(stdout)).toBe("20260518_223724_45ab80");
+  });
+
+  test("reads session_id from the first line (quiet mode)", () => {
+    const stdout = "session_id: 20260518_165315_3467a1\nHello world\n";
+    expect(parseSessionIdFromStdout(stdout)).toBe("20260518_165315_3467a1");
+  });
+
+  test("returns null when no session_id line present", () => {
+    expect(parseSessionIdFromStdout("only assistant text\n")).toBeNull();
+  });
+});
+
+describe("messageToTurnPayload", () => {
+  test("maps assistant tool_calls to toolCalls", () => {
+    const msg: HermesSessionMessage = {
+      role: "assistant",
+      content: "",
+      reasoning: null,
+      tool_calls: [{ function: { name: "read_file", arguments: '{"path":"x"}' } }],
+    };
+    const turn = messageToTurnPayload(msg, 0);
+    expect(turn).toEqual({
+      index: 0,
+      role: "assistant",
+      content: "",
+      toolCalls: [{ name: "read_file", args: '{"path":"x"}' }],
+      reasoning: null,
+    });
+  });
+
+  test("skips user messages", () => {
+    const msg: HermesSessionMessage = {
+      role: "user",
+      content: "hi",
+      reasoning: null,
+      tool_calls: null,
+    };
+    expect(messageToTurnPayload(msg, 0)).toBeNull();
+  });
+});
+
+describe("extractLastAssistantContent", () => {
+  test("returns the last non-empty assistant content", () => {
+    const messages: HermesSessionMessage[] = [
+      { role: "assistant", content: "first", reasoning: null, tool_calls: null },
+      { role: "tool", content: "tool output", reasoning: null, tool_calls: null },
+      { role: "assistant", content: "", reasoning: null, tool_calls: null },
+      { role: "assistant", content: "final answer", reasoning: null, tool_calls: null },
+    ];
+    expect(extractLastAssistantContent(messages)).toBe("final answer");
+  });
+});
+
+describe("computeDurationMs", () => {
+  test("computes elapsed time from session_start", () => {
+    const now = Date.parse("2026-05-18T13:32:59.028640Z");
+    const duration = computeDurationMs("2026-05-18T13:31:59.028640Z", now);
+    expect(duration).toBe(60_000);
+  });
+});
+
+describe("storeHermesSessionDetail", () => {
+  test("stores hermes-detail root with cas_ref turns walkable", async () => {
+    const session: HermesSessionJson = {
+      session_id: "20260518_133159_6a84e8",
+      model: "claude-opus-4.6",
+      session_start: "2026-05-18T13:31:59.028640",
+      messages: [
+        { role: "user", content: "task", reasoning: null, tool_calls: null },
+        {
+          role: "assistant",
+          content: "",
+          reasoning: "thinking",
+          tool_calls: [{ function: { name: "terminal", arguments: "{}" } }],
+        },
+        { role: "tool", content: "ok", reasoning: null, tool_calls: null },
+        { role: "assistant", content: "done", reasoning: null, tool_calls: null },
+      ],
+    };
+
+    const store = createMemoryStore();
+    const now = Date.parse("2026-05-18T13:32:59.028640");
+    const { detailHash, output } = await storeHermesSessionDetail(store, session, now);
+
+    expect(output).toBe("done");
+
+    const detailNode = store.get(detailHash);
+    expect(detailNode).not.toBeNull();
+    if (detailNode === null) {
+      return;
+    }
+    expect(validate(store, detailNode)).toBe(true);
+    expect(detailNode.payload).toMatchObject({
+      sessionId: "20260518_133159_6a84e8",
+      model: "claude-opus-4.6",
+      duration: 60_000,
+      turnCount: 3,
+    });
+
+    const turnRefs = refs(store, detailNode);
+    expect(turnRefs).toHaveLength(3);
+
+    const visited: string[] = [];
+    walk(store, detailHash, (hash) => visited.push(hash));
+    expect(visited).toContain(detailHash);
+    for (const turnHash of turnRefs) {
+      expect(visited).toContain(turnHash);
+    }
+  });
+});

packages/uwf-agent-hermes/package.json

@@ -21,6 +21,7 @@
     "test": "bun test"
   },
   "dependencies": {
+    "@uncaged/json-cas": "^0.3.0",
     "@uncaged/uwf-agent-kit": "workspace:^"
   },
   "devDependencies": {

packages/uwf-agent-hermes/src/hermes.ts

@@ -1,18 +1,25 @@
 import { spawn } from "node:child_process";
 
-import { type AgentContext, createAgent } from "@uncaged/uwf-agent-kit";
+import { type AgentContext, type AgentRunResult, createAgent } from "@uncaged/uwf-agent-kit";
+
+import {
+  loadHermesSession,
+  parseSessionIdFromStdout,
+  storeHermesRawOutput,
+  storeHermesSessionDetail,
+} from "./session-detail.js";
 
 const HERMES_COMMAND = "hermes";
 const HERMES_MAX_TURNS = 90;
 
-function buildHistorySummary(history: AgentContext["history"]): string {
-  if (history.length === 0) {
+function buildHistorySummary(steps: AgentContext["steps"]): string {
+  if (steps.length === 0) {
     return "";
   }
 
   const lines: string[] = ["## Previous Steps"];
-  for (let i = 0; i < history.length; i++) {
-    const step = history[i];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
     if (step === undefined) {
       continue;
     }
@@ -26,15 +33,17 @@ function buildHistorySummary(history: AgentContext["history"]): string {
 
 /** Assemble system prompt, task, and prior step outputs for Hermes. */
 export function buildHermesPrompt(ctx: AgentContext): string {
-  const parts: string[] = [ctx.systemPrompt, "", "## Task", ctx.prompt];
-  const historyBlock = buildHistorySummary(ctx.history);
+  const roleDef = ctx.workflow.roles[ctx.role];
+  const systemPrompt = roleDef?.systemPrompt ?? "";
+  const parts: string[] = [systemPrompt, "", "## Task", ctx.start.prompt];
+  const historyBlock = buildHistorySummary(ctx.steps);
   if (historyBlock !== "") {
     parts.push("", historyBlock);
   }
   return parts.join("\n");
 }
 
-function spawnHermesChat(prompt: string): Promise<string> {
+function spawnHermesChat(prompt: string): Promise<{ stdout: string; stderr: string }> {
   return new Promise((resolve, reject) => {
     const args = [
       "chat",
@@ -67,7 +76,7 @@ function spawnHermesChat(prompt: string): Promise<string> {
 
     child.on("close", (code) => {
       if (code === 0) {
-        resolve(stdout);
+        resolve({ stdout, stderr });
         return;
       }
       const detail = stderr.trim() !== "" ? ` stderr=${stderr.trim()}` : "";
@@ -76,9 +85,23 @@ function spawnHermesChat(prompt: string): Promise<string> {
   });
 }
 
-async function runHermes(ctx: AgentContext): Promise<string> {
+async function runHermes(ctx: AgentContext): Promise<AgentRunResult> {
   const fullPrompt = buildHermesPrompt(ctx);
-  return spawnHermesChat(fullPrompt);
+  const { stdout, stderr } = await spawnHermesChat(fullPrompt);
+  const { store } = ctx;
+
+  // --quiet mode: session_id may be on stdout or stderr
+  const sessionId = parseSessionIdFromStdout(stderr) ?? parseSessionIdFromStdout(stdout);
+  if (sessionId !== null) {
+    const session = await loadHermesSession(sessionId);
+    if (session !== null) {
+      const { detailHash, output } = await storeHermesSessionDetail(store, session);
+      return { output, detailHash };
+    }
+  }
+
+  const detailHash = await storeHermesRawOutput(store, stdout);
+  return { output: stdout, detailHash };
 }
 
 /** Agent CLI factory: parses argv, runs Hermes, extracts output, writes StepNode. */

packages/uwf-agent-hermes/src/schemas.ts

@@ -0,0 +1,57 @@
+import type { JSONSchema } from "@uncaged/json-cas";
+
+const HERMES_TOOL_CALL_SCHEMA: JSONSchema = {
+  type: "object",
+  required: ["name", "args"],
+  properties: {
+    name: { type: "string" },
+    args: { type: "string" },
+  },
+  additionalProperties: false,
+};
+
+export const HERMES_TURN_SCHEMA: JSONSchema = {
+  title: "hermes-turn",
+  type: "object",
+  required: ["index", "role", "content"],
+  properties: {
+    index: { type: "integer" },
+    role: { type: "string", enum: ["assistant", "tool"] },
+    content: { type: "string" },
+    toolCalls: {
+      anyOf: [{ type: "array", items: HERMES_TOOL_CALL_SCHEMA }, { type: "null" }],
+    },
+    reasoning: {
+      anyOf: [{ type: "string" }, { type: "null" }],
+    },
+  },
+  additionalProperties: false,
+};
+
+export const HERMES_DETAIL_SCHEMA: JSONSchema = {
+  title: "hermes-detail",
+  type: "object",
+  required: ["sessionId", "model", "duration", "turnCount", "turns"],
+  properties: {
+    sessionId: { type: "string" },
+    model: { type: "string" },
+    duration: { type: "integer" },
+    turnCount: { type: "integer" },
+    turns: {
+      type: "array",
+      items: { type: "string", format: "cas_ref" },
+    },
+  },
+  additionalProperties: false,
+};
+
+/** Fallback detail when Hermes session file is unavailable. */
+export const HERMES_RAW_OUTPUT_SCHEMA: JSONSchema = {
+  title: "hermes-raw-output",
+  type: "object",
+  required: ["text"],
+  properties: {
+    text: { type: "string" },
+  },
+  additionalProperties: false,
+};

packages/uwf-agent-hermes/src/session-detail.ts

@@ -0,0 +1,223 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { bootstrap, putSchema, type Store } from "@uncaged/json-cas";
+
+import { HERMES_DETAIL_SCHEMA, HERMES_RAW_OUTPUT_SCHEMA, HERMES_TURN_SCHEMA } from "./schemas.js";
+import type {
+  HermesDetailPayload,
+  HermesSessionJson,
+  HermesSessionMessage,
+  HermesToolCall,
+  HermesTurnPayload,
+  HermesTurnRole,
+} from "./types.js";
+
+const SESSION_ID_LINE = /^session_id:\s*(\S+)\s*$/i;
+
+export function getHermesSessionsDir(): string {
+  return join(homedir(), ".hermes", "sessions");
+}
+
+export function getHermesSessionPath(sessionId: string): string {
+  return join(getHermesSessionsDir(), `session_${sessionId}.json`);
+}
+
+/** Parse `session_id: …` from any line of Hermes stdout. */
+export function parseSessionIdFromStdout(stdout: string): string | null {
+  const lines = stdout.split(/\r?\n/);
+  for (const line of lines) {
+    const match = SESSION_ID_LINE.exec(line.trim());
+    if (match?.[1] !== undefined) {
+      return match[1];
+    }
+  }
+  return null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseToolCalls(raw: unknown): HermesSessionMessage["tool_calls"] {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return null;
+  }
+  const calls: NonNullable<HermesSessionMessage["tool_calls"]> = [];
+  for (const entry of raw) {
+    if (!isRecord(entry)) {
+      continue;
+    }
+    const fn = entry.function;
+    if (!isRecord(fn)) {
+      continue;
+    }
+    const name = fn.name;
+    const args = fn.arguments;
+    if (typeof name !== "string" || typeof args !== "string") {
+      continue;
+    }
+    calls.push({ function: { name, arguments: args } });
+  }
+  return calls.length > 0 ? calls : null;
+}
+
+function normalizeMessage(raw: unknown): HermesSessionMessage | null {
+  if (!isRecord(raw)) {
+    return null;
+  }
+  const role = raw.role;
+  if (role !== "assistant" && role !== "tool" && role !== "user") {
+    return null;
+  }
+  const content = typeof raw.content === "string" ? raw.content : raw.content === null ? null : "";
+  const reasoning =
+    typeof raw.reasoning === "string"
+      ? raw.reasoning
+      : raw.reasoning === null || raw.reasoning === undefined
+        ? null
+        : null;
+  const tool_calls = parseToolCalls(raw.tool_calls);
+  return { role, content, reasoning, tool_calls };
+}
+
+function parseSessionJson(raw: unknown): HermesSessionJson | null {
+  if (!isRecord(raw)) {
+    return null;
+  }
+  const session_id = raw.session_id;
+  const model = raw.model;
+  const session_start = raw.session_start;
+  const messagesRaw = raw.messages;
+  if (
+    typeof session_id !== "string" ||
+    typeof model !== "string" ||
+    typeof session_start !== "string" ||
+    !Array.isArray(messagesRaw)
+  ) {
+    return null;
+  }
+  const messages: HermesSessionMessage[] = [];
+  for (const entry of messagesRaw) {
+    const msg = normalizeMessage(entry);
+    if (msg !== null) {
+      messages.push(msg);
+    }
+  }
+  return { session_id, model, session_start, messages };
+}
+
+export async function loadHermesSession(sessionId: string): Promise<HermesSessionJson | null> {
+  const path = getHermesSessionPath(sessionId);
+  try {
+    const text = await readFile(path, "utf8");
+    const raw = JSON.parse(text) as unknown;
+    return parseSessionJson(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function computeDurationMs(sessionStart: string, nowMs: number = Date.now()): number {
+  const startMs = Date.parse(sessionStart);
+  if (Number.isNaN(startMs)) {
+    return 0;
+  }
+  return Math.max(0, nowMs - startMs);
+}
+
+function mapSessionToolCalls(
+  toolCalls: HermesSessionMessage["tool_calls"],
+): HermesToolCall[] | null {
+  if (toolCalls === null || toolCalls.length === 0) {
+    return null;
+  }
+  return toolCalls.map((call) => ({
+    name: call.function.name,
+    args: call.function.arguments,
+  }));
+}
+
+export function messageToTurnPayload(
+  message: HermesSessionMessage,
+  index: number,
+): HermesTurnPayload | null {
+  if (message.role !== "assistant" && message.role !== "tool") {
+    return null;
+  }
+  const role = message.role as HermesTurnRole;
+  return {
+    index,
+    role,
+    content: message.content ?? "",
+    toolCalls: mapSessionToolCalls(message.tool_calls),
+    reasoning: message.reasoning,
+  };
+}
+
+/** Last assistant message with non-empty text content (walks backward). */
+export function extractLastAssistantContent(messages: HermesSessionMessage[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg === undefined) {
+      continue;
+    }
+    if (msg.role === "assistant" && msg.content !== null && msg.content.trim() !== "") {
+      return msg.content;
+    }
+  }
+  return "";
+}
+
+type HermesSchemaHashes = {
+  turn: string;
+  detail: string;
+  rawOutput: string;
+};
+
+async function registerHermesSchemas(store: Store): Promise<HermesSchemaHashes> {
+  await bootstrap(store);
+  const [turn, detail, rawOutput] = await Promise.all([
+    putSchema(store, HERMES_TURN_SCHEMA),
+    putSchema(store, HERMES_DETAIL_SCHEMA),
+    putSchema(store, HERMES_RAW_OUTPUT_SCHEMA),
+  ]);
+  return { turn, detail, rawOutput };
+}
+
+export async function storeHermesSessionDetail(
+  store: Store,
+  session: HermesSessionJson,
+  nowMs: number = Date.now(),
+): Promise<{ detailHash: string; output: string }> {
+  const schemas = await registerHermesSchemas(store);
+  const turnHashes: string[] = [];
+  let turnIndex = 0;
+
+  for (const message of session.messages) {
+    const turn = messageToTurnPayload(message, turnIndex);
+    if (turn === null) {
+      continue;
+    }
+    const hash = await store.put(schemas.turn, turn);
+    turnHashes.push(hash);
+    turnIndex += 1;
+  }
+
+  const detail: HermesDetailPayload = {
+    sessionId: session.session_id,
+    model: session.model,
+    duration: computeDurationMs(session.session_start, nowMs),
+    turnCount: turnHashes.length,
+    turns: turnHashes,
+  };
+  const detailHash = await store.put(schemas.detail, detail);
+  const output = extractLastAssistantContent(session.messages);
+  return { detailHash, output };
+}
+
+export async function storeHermesRawOutput(store: Store, rawOutput: string): Promise<string> {
+  const schemas = await registerHermesSchemas(store);
+  return store.put(schemas.rawOutput, { text: rawOutput });
+}

packages/uwf-agent-hermes/src/types.ts

@@ -0,0 +1,43 @@
+export type HermesTurnRole = "assistant" | "tool";
+
+export type HermesToolCall = {
+  name: string;
+  args: string;
+};
+
+export type HermesTurnPayload = {
+  index: number;
+  role: HermesTurnRole;
+  content: string;
+  toolCalls: HermesToolCall[] | null;
+  reasoning: string | null;
+};
+
+export type HermesDetailPayload = {
+  sessionId: string;
+  model: string;
+  duration: number;
+  turnCount: number;
+  turns: string[];
+};
+
+export type HermesSessionToolCall = {
+  function: {
+    name: string;
+    arguments: string;
+  };
+};
+
+export type HermesSessionMessage = {
+  role: string;
+  content: string | null;
+  tool_calls: HermesSessionToolCall[] | null;
+  reasoning: string | null;
+};
+
+export type HermesSessionJson = {
+  session_id: string;
+  model: string;
+  session_start: string;
+  messages: HermesSessionMessage[];
+};

packages/uwf-agent-kit/package.json

@@ -18,8 +18,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@uncaged/json-cas": "^0.1.3",
-    "@uncaged/json-cas-fs": "^0.1.2",
+    "@uncaged/json-cas": "^0.3.0",
+    "@uncaged/json-cas-fs": "^0.3.0",
     "@uncaged/uwf-protocol": "workspace:^",
     "dotenv": "^16.6.1",
     "yaml": "^2.8.4"

packages/uwf-agent-kit/src/context.ts

@@ -1,3 +1,4 @@
+import type { Store } from "@uncaged/json-cas";
 import type {
   CasRef,
   StartNodePayload,
@@ -6,6 +7,7 @@ import type {
   ThreadId,
 } from "@uncaged/uwf-protocol";
 import { createAgentStore, loadThreadsIndex, resolveStorageRoot } from "./storage.js";
+import type { AgentStore } from "./storage.js";
 import type { AgentContext } from "./types.js";
 
 type ChainState = {
@@ -20,8 +22,8 @@ function fail(message: string): never {
 }
 
 function walkChain(
-  store: Awaited<ReturnType<typeof createAgentStore>>["store"],
-  schemas: Awaited<ReturnType<typeof createAgentStore>>["schemas"],
+  store: Store,
+  schemas: AgentStore["schemas"],
   headHash: CasRef,
 ): ChainState {
   const headNode = store.get(headHash);
@@ -77,7 +79,7 @@ function walkChain(
 }
 
 function expandOutput(
-  store: Awaited<ReturnType<typeof createAgentStore>>["store"],
+  store: Store,
   outputRef: CasRef,
 ): unknown {
   const node = store.get(outputRef);
@@ -88,7 +90,7 @@ function expandOutput(
 }
 
 async function buildHistory(
-  store: Awaited<ReturnType<typeof createAgentStore>>["store"],
+  store: Store,
   stepsNewestFirst: StepNodePayload[],
 ): Promise<StepContext[]> {
   const chronological = [...stepsNewestFirst].reverse();
@@ -105,8 +107,8 @@ async function buildHistory(
 }
 
 async function loadWorkflow(
-  store: Awaited<ReturnType<typeof createAgentStore>>["store"],
-  schemas: Awaited<ReturnType<typeof createAgentStore>>["schemas"],
+  store: Store,
+  schemas: AgentStore["schemas"],
   workflowRef: CasRef,
 ) {
   const node = store.get(workflowRef);
@@ -141,22 +143,22 @@ export async function buildContext(threadId: ThreadId, role: string): Promise<Ag
     fail(`unknown role "${role}" in workflow "${workflow.name}"`);
   }
 
-  const history = await buildHistory(store, chain.stepsNewestFirst);
+  const steps = await buildHistory(store, chain.stepsNewestFirst);
 
   return {
     threadId,
     role,
-    systemPrompt: roleDef.systemPrompt,
-    prompt: chain.start.prompt,
-    history,
+    start: chain.start,
+    steps,
     workflow,
+    store,
   };
 }
 
 export type BuildContextMeta = {
   storageRoot: string;
-  store: Awaited<ReturnType<typeof createAgentStore>>["store"];
-  schemas: Awaited<ReturnType<typeof createAgentStore>>["schemas"];
+  store: Store;
+  schemas: AgentStore["schemas"];
   headHash: CasRef;
   chain: ChainState;
 };
@@ -185,15 +187,15 @@ export async function buildContextWithMeta(
     fail(`unknown role "${role}" in workflow "${workflow.name}"`);
   }
 
-  const history = await buildHistory(store, chain.stepsNewestFirst);
+  const steps = await buildHistory(store, chain.stepsNewestFirst);
 
   return {
     threadId,
     role,
-    systemPrompt: roleDef.systemPrompt,
-    prompt: chain.start.prompt,
-    history,
+    start: chain.start,
+    steps,
     workflow,
+    store,
     meta: { storageRoot, store, schemas, headHash, chain },
   };
 }

packages/uwf-agent-kit/src/index.ts

@@ -1,6 +1,5 @@
 export type { BuildContextMeta } from "./context.js";
 export { buildContext, buildContextWithMeta } from "./context.js";
-export { getConfigPath, getEnvPath, loadWorkflowConfig } from "./storage.js";
 export type { ExtractResult, ResolvedLlmProvider } from "./extract.js";
 export {
   extract,
@@ -8,4 +7,5 @@ export {
   resolveModel,
 } from "./extract.js";
 export { createAgent } from "./run.js";
-export type { AgentContext, AgentOptions, AgentRunFn } from "./types.js";
+export { getConfigPath, getEnvPath, loadWorkflowConfig } from "./storage.js";
+export type { AgentContext, AgentOptions, AgentRunFn, AgentRunResult } from "./types.js";

packages/uwf-agent-kit/src/run.ts

@@ -6,7 +6,7 @@ import { buildContextWithMeta } from "./context.js";
 import { extract } from "./extract.js";
 import type { AgentStore } from "./storage.js";
 import { getEnvPath, loadWorkflowConfig, resolveStorageRoot } from "./storage.js";
-import type { AgentContext, AgentOptions } from "./types.js";
+import type { AgentContext, AgentOptions, AgentRunResult } from "./types.js";
 
 function fail(message: string): never {
   process.stderr.write(`${message}\n`);
@@ -65,7 +65,7 @@ async function writeStepNode(options: {
   return hash;
 }
 
-async function runAgent(options: AgentOptions, ctx: AgentContext): Promise<string> {
+async function runAgent(options: AgentOptions, ctx: AgentContext): Promise<AgentRunResult> {
   return runWithMessage("agent run failed", () => options.run(ctx));
 }
 
@@ -85,12 +85,11 @@ async function extractOutput(
 
 async function persistStep(options: {
   ctx: Awaited<ReturnType<typeof buildContextWithMeta>>;
-  rawOutput: string;
   outputHash: CasRef;
+  detailHash: CasRef;
   agentName: string;
 }): Promise<CasRef> {
   const { store, schemas, chain, headHash } = options.ctx.meta;
-  const detailHash = await store.put(null, options.rawOutput);
   return writeStepNode({
     store,
     schemas,
@@ -98,7 +97,7 @@ async function persistStep(options: {
     prevHash: chain.headIsStart ? null : headHash,
     role: options.ctx.role,
     outputHash: options.outputHash,
-    detailHash,
+    detailHash: options.detailHash,
     agentName: options.agentName,
   });
 }
@@ -121,12 +120,12 @@ export function createAgent(options: AgentOptions): () => Promise<void> {
       fail(`unknown role: ${role}`);
     }
 
-    const rawOutput = await runAgent(options, ctx);
-    const outputHash = await extractOutput(rawOutput, roleDef.outputSchema, storageRoot);
+    const agentResult = await runAgent(options, ctx);
+    const outputHash = await extractOutput(agentResult.output, roleDef.outputSchema, storageRoot);
     const stepHash = await persistStep({
       ctx,
-      rawOutput,
       outputHash,
+      detailHash: agentResult.detailHash,
       agentName: agentLabel(options.name),
     });
 

packages/uwf-agent-kit/src/schemas.ts

@@ -1,10 +1,6 @@
 import type { Hash, Store } from "@uncaged/json-cas";
 import { putSchema } from "@uncaged/json-cas";
-import {
-  START_NODE_SCHEMA,
-  STEP_NODE_SCHEMA,
-  WORKFLOW_SCHEMA,
-} from "@uncaged/uwf-protocol";
+import { START_NODE_SCHEMA, STEP_NODE_SCHEMA, WORKFLOW_SCHEMA } from "@uncaged/uwf-protocol";
 
 export type UwfAgentSchemaHashes = {
   workflow: Hash;

packages/uwf-agent-kit/src/types.ts

@@ -1,15 +1,19 @@
-import type { StepContext, ThreadId, WorkflowPayload } from "@uncaged/uwf-protocol";
+import type { Store } from "@uncaged/json-cas";
+import type { ModeratorContext, ThreadId, WorkflowPayload } from "@uncaged/uwf-protocol";
 
-export type AgentContext = {
+export type AgentContext = ModeratorContext & {
   threadId: ThreadId;
   role: string;
-  systemPrompt: string;
-  prompt: string;
-  history: StepContext[];
+  store: Store;
   workflow: WorkflowPayload;
 };
 
-export type AgentRunFn = (ctx: AgentContext) => Promise<string>;
+export type AgentRunResult = {
+  output: string;
+  detailHash: string;
+};
+
+export type AgentRunFn = (ctx: AgentContext) => Promise<AgentRunResult>;
 
 export type AgentOptions = {
   name: string;

packages/uwf-protocol/package.json

@@ -15,7 +15,7 @@
     }
   },
   "dependencies": {
-"@uncaged/json-cas-fs": "^0.1.3"
+"@uncaged/json-cas-fs": "^0.3.0"
   },
   "devDependencies": {
     "typescript": "^5.8.3"

packages/uwf-protocol/src/index.ts

@@ -16,14 +16,18 @@ export type {
   RoleDefinition,
   RoleName,
   Scenario,
+  StartEntry,
   StartNodePayload,
   StartOutput,
   StepContext,
+  StepEntry,
   StepNodePayload,
   StepOutput,
   StepRecord,
+  ThreadForkOutput,
   ThreadId,
   ThreadListItem,
+  ThreadStepsOutput,
   ThreadsIndex,
   Transition,
   WorkflowConfig,

packages/uwf-protocol/src/types.ts

@@ -80,6 +80,39 @@ export type StepOutput = {
   done: boolean;
 };
 
+/** uwf thread steps — single step entry */
+export type StepEntry = {
+  hash: CasRef;
+  role: string;
+  output: unknown;
+  detail: CasRef;
+  agent: string;
+  timestamp: number;
+};
+
+/** uwf thread steps — start entry */
+export type StartEntry = {
+  hash: CasRef;
+  workflow: CasRef;
+  prompt: string;
+  timestamp: number;
+};
+
+/** uwf thread steps output */
+export type ThreadStepsOutput = {
+  thread: ThreadId;
+  workflow: CasRef;
+  steps: [StartEntry, ...StepEntry[]];
+};
+
+/** uwf thread fork output */
+export type ThreadForkOutput = {
+  thread: ThreadId;
+  forkedFrom: {
+    step: CasRef;
+  };
+};
+
 /** uwf thread list */
 export type ThreadListItem = {
   thread: ThreadId;

scripts/mock-agent.ts

@@ -1,11 +1,27 @@
 #!/usr/bin/env bun
 // Mock agent for smoke testing
+import { bootstrap, type JSONSchema, putSchema } from "@uncaged/json-cas";
 import { createAgent } from "../packages/uwf-agent-kit/src/index.js";
 
+const MOCK_RAW_OUTPUT_SCHEMA: JSONSchema = {
+  title: "mock-raw-output",
+  type: "object",
+  required: ["text"],
+  properties: {
+    text: { type: "string" },
+  },
+  additionalProperties: false,
+};
+
 const agent = createAgent({
   name: "mock",
   run: async (ctx) => {
-    return `Mock output for role ${ctx.role}: task was "${ctx.prompt}"`;
+    const output = `Mock output for role ${ctx.role}: task was "${ctx.start.prompt}"`;
+    const { store } = ctx;
+    await bootstrap(store);
+    const schemaHash = await putSchema(store, MOCK_RAW_OUTPUT_SCHEMA);
+    const detailHash = await store.put(schemaHash, { text: output });
+    return { output, detailHash };
   },
 });