fix(thread-read): remove ### Output section and deduplicate ### Prompt globally

LLM sometimes emits plain text (e.g. 'Now I'll write the tests...')
without calling tools, which the loop treated as final output. Now
the loop detects this and injects a user message nudging the LLM
to either continue using tools or output frontmatter with ---.

package.json

@@ -9,7 +9,7 @@
     "check": "bunx tsc --build && biome check . && bash scripts/lint-log-tags.sh",
     "typecheck": "bunx tsc --build",
     "format": "biome format --write .",
-    "test": "bun run --filter '*' test",
+    "test": "bun run --filter './packages/*' test",
     "changeset": "bunx changeset",
     "version": "bunx changeset version",
     "release": "bun run build && bun test && node scripts/publish-all.mjs"

packages/cli-workflow/src/__tests__/thread.test.ts

@@ -266,12 +266,7 @@ describe("cmdThreadRead ### Content section", () => {
 
     expect(markdown).toContain("### Content");
     expect(markdown).toContain("The assistant response text");
-
-    const contentIdx = markdown.indexOf("### Content");
-    const outputIdx = markdown.indexOf("### Output");
-    expect(contentIdx).toBeGreaterThanOrEqual(0);
-    expect(outputIdx).toBeGreaterThanOrEqual(0);
-    expect(contentIdx).toBeLessThan(outputIdx);
+    expect(markdown).not.toContain("### Output");
   });
 
   test("omits ### Content when detail has no matching assistant turns", async () => {
@@ -314,7 +309,7 @@ describe("cmdThreadRead ### Content section", () => {
     const markdown = await cmdThreadRead(tmpDir, threadId, THREAD_READ_DEFAULT_QUOTA, null, false);
 
     expect(markdown).not.toContain("### Content");
-    expect(markdown).toContain("### Output");
+    expect(markdown).not.toContain("### Output");
   });
 });
 
@@ -392,3 +387,87 @@ describe("cmdThreadStepDetails", () => {
     await expect(cmdThreadStepDetails(tmpDir, "nonexistenth0" as CasRef)).rejects.toThrow();
   });
 });
+
+// ── cmdThreadRead: ### Prompt deduplication ───────────────────────────────────
+
+describe("cmdThreadRead ### Prompt deduplication", () => {
+  async function makeThreadWithRoles(uwf: UwfStore, roles: string[]): Promise<string> {
+    const roleMap: Record<string, unknown> = {};
+    for (const r of [...new Set(roles)]) {
+      roleMap[r] = {
+        description: r,
+        goal: `Goal for ${r}`,
+        capabilities: [],
+        procedure: "Do stuff.",
+        output: "Output.",
+        meta: "placeholder00" as CasRef,
+      };
+    }
+    const workflowHash = await uwf.store.put(uwf.schemas.workflow, {
+      name: "dedup-wf",
+      description: "desc",
+      roles: roleMap,
+      conditions: {},
+      graph: {},
+    });
+    const startHash = await uwf.store.put(uwf.schemas.startNode, {
+      workflow: workflowHash,
+      prompt: "Start",
+    });
+    const outputHash = await uwf.store.put(uwf.schemas.workflow, {
+      name: "out",
+      description: "",
+      roles: {},
+      conditions: {},
+      graph: {},
+    });
+
+    let prev: string | null = null;
+    let stepHash = "";
+    for (const role of roles) {
+      stepHash = await uwf.store.put(uwf.schemas.stepNode, {
+        start: startHash,
+        prev: prev as CasRef | null,
+        role,
+        output: outputHash,
+        detail: null,
+        agent: "uwf-test",
+      });
+      prev = stepHash;
+    }
+    return stepHash;
+  }
+
+  test("same consecutive role shows ### Prompt once", async () => {
+    const uwf = await makeUwfStore(tmpDir);
+    const headHash = await makeThreadWithRoles(uwf, ["writer", "writer"]);
+    const threadId = "01JTEST0000000000000003" as ThreadId;
+    await saveThreadsIndex(tmpDir, { [threadId]: headHash });
+
+    const markdown = await cmdThreadRead(tmpDir, threadId, THREAD_READ_DEFAULT_QUOTA, null, false);
+    const count = (markdown.match(/### Prompt/g) ?? []).length;
+    expect(count).toBe(1);
+  });
+
+  test("different consecutive roles each show ### Prompt", async () => {
+    const uwf = await makeUwfStore(tmpDir);
+    const headHash = await makeThreadWithRoles(uwf, ["planner", "coder"]);
+    const threadId = "01JTEST0000000000000004" as ThreadId;
+    await saveThreadsIndex(tmpDir, { [threadId]: headHash });
+
+    const markdown = await cmdThreadRead(tmpDir, threadId, THREAD_READ_DEFAULT_QUOTA, null, false);
+    const count = (markdown.match(/### Prompt/g) ?? []).length;
+    expect(count).toBe(2);
+  });
+
+  test("non-consecutive same role shows ### Prompt twice", async () => {
+    const uwf = await makeUwfStore(tmpDir);
+    const headHash = await makeThreadWithRoles(uwf, ["roleA", "roleB", "roleA"]);
+    const threadId = "01JTEST0000000000000005" as ThreadId;
+    await saveThreadsIndex(tmpDir, { [threadId]: headHash });
+
+    const markdown = await cmdThreadRead(tmpDir, threadId, THREAD_READ_DEFAULT_QUOTA, null, false);
+    const count = (markdown.match(/### Prompt/g) ?? []).length;
+    expect(count).toBe(2);
+  });
+});

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

@@ -655,11 +655,11 @@ function formatThreadReadMarkdown(options: {
 
   // Step blocks
   const startIndex = candidates.length - selected.length;
+  const shownPromptRoles = new Set<string>();
   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", " ")
@@ -669,9 +669,10 @@ function formatThreadReadMarkdown(options: {
       `**Agent:** ${item.payload.agent} | **Time:** ${ts}`,
     ];
     const roleDef = workflow.roles[item.payload.role];
-    if (roleDef) {
+    if (roleDef && !shownPromptRoles.has(item.payload.role)) {
       const prompt = roleDef.goal;
       stepLines.push("", "### Prompt", "", prompt);
+      shownPromptRoles.add(item.payload.role);
     }
     if (item.payload.detail) {
       const content = extractLastAssistantContent(uwf, item.payload.detail);
@@ -679,7 +680,6 @@ function formatThreadReadMarkdown(options: {
         stepLines.push("", "### Content", "", content);
       }
     }
-    stepLines.push("", "### Output", "", "```yaml", outputYaml, "```");
     parts.push(stepLines.join("\n"));
   }
 

packages/workflow-agent-builtin/src/agent.ts

@@ -66,6 +66,7 @@ async function runBuiltinWithMessages(
   session: SessionRecord,
   store: Store,
   maxTurns: number,
+  noTools: boolean,
 ): Promise<AgentRunResult> {
   const loopResult = await runBuiltinLoop({
     provider,
@@ -74,6 +75,7 @@ async function runBuiltinWithMessages(
     maxTurns,
     storageRoot,
     sessionId: session.sessionId,
+    noTools,
   });
 
   session.messages = loopResult.messages;
@@ -119,6 +121,7 @@ async function runBuiltin(ctx: AgentContext): Promise<AgentRunResult> {
     session,
     ctx.store,
     BUILTIN_MAX_TURNS,
+    false,
   );
 }
 
@@ -141,6 +144,7 @@ async function continueBuiltin(
     session,
     store,
     BUILTIN_CONTINUE_MAX_TURNS,
+    true,
   );
 }
 

packages/workflow-agent-builtin/src/llm/llm.ts

@@ -96,8 +96,17 @@ function serializeMessage(message: ChatMessage): Record<string, unknown> {
 export async function chatCompletionWithTools(
   provider: ResolvedLlmProvider,
   messages: ChatMessage[],
-  tools: OpenAiToolDefinition[],
+  tools: OpenAiToolDefinition[] | null,
 ): Promise<LlmAssistantResponse> {
+  const body: Record<string, unknown> = {
+    model: provider.model,
+    messages: messages.map(serializeMessage),
+  };
+  if (tools !== null && tools.length > 0) {
+    body.tools = tools;
+    body.tool_choice = "auto";
+  }
+
   let response: Response;
   try {
     response = await fetch(chatUrl(provider.baseUrl), {
@@ -106,12 +115,7 @@ export async function chatCompletionWithTools(
         Authorization: `Bearer ${provider.apiKey}`,
         "Content-Type": "application/json",
       },
-      body: JSON.stringify({
-        model: provider.model,
-        messages: messages.map(serializeMessage),
-        tools,
-        tool_choice: "auto",
-      }),
+      body: JSON.stringify(body),
     });
   } catch (cause) {
     const message = cause instanceof Error ? cause.message : String(cause);

packages/workflow-agent-builtin/src/loop.ts

@@ -23,6 +23,8 @@ export type RunBuiltinLoopOptions = {
   maxTurns: number;
   storageRoot: string;
   sessionId: string;
+  /** When true, do not provide tools — force LLM to emit text only. */
+  noTools: boolean;
 };
 
 export type RunBuiltinLoopResult = {
@@ -73,13 +75,17 @@ export async function runBuiltinLoop(
   options: RunBuiltinLoopOptions,
 ): Promise<RunBuiltinLoopResult> {
   const messages = [...options.messages];
-  const openAiTools = builtinToolsToOpenAi(getBuiltinTools());
+  const openAiTools = options.noTools ? [] : builtinToolsToOpenAi(getBuiltinTools());
   let finalText = "";
   let turnCount = 0;
 
   for (let turn = 0; turn < options.maxTurns; turn++) {
     log("8K2M4N7P", `builtin loop turn ${turn + 1}/${options.maxTurns}`);
-    const response = await chatCompletionWithTools(options.provider, messages, openAiTools);
+    const response = await chatCompletionWithTools(
+      options.provider,
+      messages,
+      openAiTools.length > 0 ? openAiTools : null,
+    );
 
     const assistantMessage: ChatMessage = {
       role: "assistant",
@@ -89,14 +95,27 @@ export async function runBuiltinLoop(
     messages.push(assistantMessage);
 
     if (response.toolCalls === null || response.toolCalls.length === 0) {
-      finalText = response.content ?? "";
+      const text = response.content ?? "";
       await appendTurn(options.storageRoot, options.sessionId, {
         role: "assistant",
-        content: response.content ?? "",
+        content: text,
         toolCalls: null,
         reasoning: null,
       });
       turnCount += 1;
+
+      // If tools are available but LLM stopped calling them without producing
+      // frontmatter, nudge it to continue working or output frontmatter.
+      if (!options.noTools && !text.trimStart().startsWith("---") && turn < options.maxTurns - 1) {
+        log("7FXQM2KN", "text-only turn without frontmatter, nudging LLM to continue");
+        const nudge =
+          "You stopped calling tools but your response does not start with the required `---` YAML frontmatter. " +
+          "Either continue using tools to complete your work, or output your final response starting with `---`.";
+        messages.push({ role: "user", content: nudge });
+        continue;
+      }
+
+      finalText = text;
       break;
     }
 

packages/workflow-agent-builtin/src/prompt.ts

@@ -63,8 +63,11 @@ export function buildBuiltinMessages(ctx: AgentContext): ChatMessage[] {
     "",
     "## Workflow",
     "",
+    `Your working directory is: ${process.cwd()}`,
+    "",
     "You have tools available (read_file, write_file, run_command). " +
       "Use them to complete your task — read files, run commands, make changes as needed. " +
+      "Your task is described in the user message below — do NOT use uwf or workflow CLI commands to discover your task. " +
       "When you are done, output your final response with the YAML frontmatter block as specified above. " +
       "Do NOT output the frontmatter until you have completed all necessary work. " +
       "CRITICAL: Your final output MUST start with the `---` fence on the very first line — " +