docs: upgrade debate example — 3 roles, oneOf routing, bounded termination

Based on xiaonuo's battle-tested debate workflow. Changes:
- 3 roles (proponent/opponent/host) instead of 2
- oneOf + const schema (speak/conceded/final) instead of enum
- Bounded: 3rd speech forces final statement
- Host role delivers summary/highlights/verdict
- Critical thinking framework in procedure
- Edge prompts pass structured data via {{{argument}}}/{{{closing}}}

.changeset/inject-thread-progress.md

@@ -0,0 +1,12 @@
+---
+"@united-workforce/agent-hermes": patch
+"@united-workforce/agent-claude-code": patch
+"@united-workforce/util-agent": patch
+---
+
+feat: inject thread progress into agent prompt (#127)
+
+Agents now receive a "Thread Progress" section in their prompt showing the
+current step number and how many times the current role has spoken before.
+This eliminates the need for agents to make tool calls (terminal, delegate_task)
+just to count their own turn history.

.changeset/thread-poke.md

@@ -1,11 +0,0 @@
----
-"@united-workforce/cli": minor
----
-
-feat(cli): add `uwf thread poke` command
-
-New subcommand `uwf thread poke <thread-id> -p <prompt>` re-runs the head step's
-agent with a supplementary prompt, replacing the head step's output. Unlike
-`thread resume`, poke skips the moderator and rewrites the new step's `prev`
-pointer so the new head replaces (not appends to) the old head. Works on idle
-and suspended threads. Resolves issue #144 (Phase 1).

.workflows/solve-issue.yaml

@@ -0,0 +1,247 @@
+name: "solve-issue"
+description: "TDD-driven issue resolution for small, focused changes. Loop protection relies on engine maxRounds."
+roles:
+  planner:
+    description: "Analyzes issue and outputs a TDD test spec"
+    goal: "You are a planning agent. You analyze Gitea issues and produce a TDD test specification that downstream roles will implement and verify."
+    capabilities:
+      - issue-analysis
+      - planning
+    procedure: |
+      On first run (no previous steps):
+      1. Read the issue and all comments from Gitea using `tea issues <number> -r <owner/repo>`
+      2. Look for project conventions files (CLAUDE.md, CONTRIBUTING.md, .cursor/rules/) in the repo
+      3. Assess whether the issue has enough information to produce a test spec
+      4. If insufficient info: comment on the issue via `echo "..." | tea comment <number> -r <owner/repo>` (skip if you already commented), then output $status=insufficient_info
+      5. If sufficient: produce a detailed TDD test spec in markdown covering all scenarios
+
+      On subsequent runs (bounced back by tester with fix_spec):
+      1. Read the tester's output from the previous step to understand what's wrong with the spec
+      2. Revise the test spec accordingly
+
+      After producing the test spec:
+      1. The test spec is stored in CAS automatically by the uwf pipeline (agents do not need to call `ocas put` directly)
+      2. Put the plan hash in frontmatter.plan (required when $status=ready)
+      3. Set repoPath to the absolute path of the repository root
+
+      IMPORTANT: Extract the repo remote (owner/repo) from git:
+      ```bash
+      git remote get-url origin | sed 's|.*[:/]\([^/]*/[^.]*\).*|\1|'
+      ```
+      Store the result as repoRemote in your frontmatter output so downstream roles can use it for tea/API calls.
+    output: "Output a brief summary of the test spec. Set $status to ready (with plan hash and repoPath) or insufficient_info."
+    frontmatter:
+      oneOf:
+        - properties:
+            $status: { const: "ready" }
+            plan: { type: string }
+            repoPath: { type: string }
+            repoRemote: { type: string }
+          required: [$status, plan, repoPath, repoRemote]
+        - properties:
+            $status: { const: "insufficient_info" }
+            reason: { type: string }
+          required: [$status, reason]
+  developer:
+    description: "TDD implementation per test spec"
+    goal: "You are a developer agent. You implement code changes following TDD — write tests first, then implementation."
+    capabilities:
+      - coding
+    procedure: |
+      IMPORTANT: Always work in a git worktree, NEVER modify the main working directory directly.
+      The repo path and other details are provided in your task prompt.
+
+      Before starting any work, set up an isolated worktree:
+      1. cd into the repo path provided in your task prompt
+      2. `git fetch origin` to get latest refs
+      3. First time (no existing branch):
+         - `git worktree add .worktrees/fix/<issue-number>-<short-slug> -b fix/<issue-number>-<short-slug> origin/main`
+         - `cd .worktrees/fix/<issue-number>-<short-slug> && bun install`
+      4. If bounced back from reviewer or tester (branch already exists):
+         - cd into the existing worktree under `.worktrees/fix/<issue-number>-<short-slug>`
+         - `git fetch origin && git rebase origin/main`
+      5. ALL subsequent work must happen inside the worktree directory.
+
+      Then implement TDD:
+      6. Read the test spec from CAS: `ocas get <plan hash>` (find the hash from the planner's output in your task prompt)
+      7. If bounced back from reviewer or tester: read the previous role's feedback in your task prompt
+      8. Write tests first based on the spec
+      9. Implement the code to make tests pass
+      10. Ensure `bun run build` passes with no errors
+      11. Run `bun test` to verify all tests pass
+          - If tests fail on first run:
+            * Read the test output carefully for missing imports or setup issues
+            * Check if you're running tests from the correct working directory (package root vs workspace root)
+            * Fix the immediate issue and rerun ONCE
+            * If tests still fail after 2 attempts: check the test spec for ambiguities
+            * If stuck after 3 test cycles: set $status=failed with detailed error report rather than continuing blind retries
+      12. MANDATORY VERIFICATION before reporting done:
+          - Run `git branch --show-current` and confirm branch name matches expected
+          - Run `git status` and verify changed files exist
+          - Run `ls -la <key-implementation-files>` to verify they exist on disk
+          - If ANY verification fails: retry the implementation, do NOT report done
+
+      If you cannot complete the implementation (e.g. the issue is too complex, blocked by external factors,
+      or repeated attempts fail), set $status=failed with a reason.
+    output: "List all files changed and provide a summary. Set $status to done (with branch/worktree), or failed (with reason)."
+    frontmatter:
+      oneOf:
+        - properties:
+            $status: { const: "done" }
+            branch: { type: string }
+            worktree: { type: string }
+            repoRemote: { type: string }
+          required: [$status, branch, worktree]
+        - properties:
+            $status: { const: "failed" }
+            reason: { type: string }
+          required: [$status, reason]
+  reviewer:
+    description: "Code standards compliance check"
+    goal: "You are a code reviewer. You verify code standards compliance — NOT functionality (that's the tester's job)."
+    capabilities:
+      - code-review
+      - static-analysis
+    procedure: |
+      The worktree path is provided in your task prompt. cd into it first.
+
+      CRITICAL: You MUST execute every verification command below. Do NOT report results without running the actual commands. Do NOT rely on prior context or assumptions.
+
+      Before reviewing, verify the worktree and branch exist:
+      0. Run `cd <worktree-path> && pwd` to confirm the path is accessible
+         - If the cd fails: the worktree truly doesn't exist, reject with that reason
+         - If the cd succeeds: proceed with step 1 below
+      1. Run `git branch --show-current` — confirm the branch name references the issue number being worked on
+      2. If the branch doesn't correspond to the issue, flag it in your output and reject
+
+      Then perform code review:
+      Hard checks (must all pass):
+      3. `bun run build` — no build errors
+      4. `bunx biome check` — no lint violations
+      5. TypeScript strict mode — no type errors
+
+      Soft checks (review against project conventions if CLAUDE.md / .cursor/rules exist):
+      - Naming conventions, module boundaries, code style
+      - No `console.log` in production code
+      - No dynamic imports in production code
+
+      Only review standards compliance. Do NOT test functionality.
+      If rejecting, you MUST explain the specific reason in your output.
+    output: "Explain your decision with specific file/line references. Set $status to approved (with branch/worktree) or rejected (with comments)."
+    frontmatter:
+      oneOf:
+        - properties:
+            $status: { const: "approved" }
+            branch: { type: string }
+            worktree: { type: string }
+            repoRemote: { type: string }
+          required: [$status, branch, worktree]
+        - properties:
+            $status: { const: "rejected" }
+            comments: { type: string }
+            worktree: { type: string }
+            repoRemote: { type: string }
+          required: [$status, comments, worktree]
+  tester:
+    description: "Functional correctness verification"
+    goal: "You are a tester agent. You verify that the implementation correctly satisfies every scenario in the test spec."
+    capabilities:
+      - testing
+    procedure: |
+      The worktree path is provided in your task prompt. cd into it first.
+
+      1. Run `bun test` for automated test verification
+      2. Read the test spec from CAS: `ocas get <plan hash>` (find the hash from the planner step in the thread history)
+      3. Verify each scenario in the spec is covered and passing
+      4. Determine outcome:
+         - passed: all scenarios verified, tests pass
+         - fix_code: tests fail or implementation doesn't match spec → send back to developer
+         - fix_spec: the spec itself is wrong or incomplete → send back to planner
+    output: "Report test results per scenario. Set $status to passed (with branch/worktree), fix_code (with report), or fix_spec (with report)."
+    frontmatter:
+      oneOf:
+        - properties:
+            $status: { const: "passed" }
+            branch: { type: string }
+            worktree: { type: string }
+            repoRemote: { type: string }
+          required: [$status, branch, worktree]
+        - properties:
+            $status: { const: "fix_code" }
+            report: { type: string }
+            repoRemote: { type: string }
+            worktree: { type: string }
+            branch: { type: string }
+          required: [$status, report]
+        - properties:
+            $status: { const: "fix_spec" }
+            report: { type: string }
+            repoRemote: { type: string }
+            worktree: { type: string }
+            branch: { type: string }
+          required: [$status, report]
+  committer:
+    description: "Commits and creates PR"
+    goal: "You are a committer agent. You create a clean commit and push a PR linking the original issue."
+    capabilities: []
+    procedure: |
+      The worktree path, branch name, and repo remote (owner/repo) are provided in your task prompt.
+      cd into the worktree first.
+
+      Note: You inherit the developer's worktree and branch. Do NOT create a new branch.
+      1. Check `git status` — if working tree is clean and branch is ahead of origin, skip to step 3 (push).
+      2. If there are unstaged/uncommitted changes: `git add -A` then `git commit -m "type: description\n\nFixes #N"`
+      3. Push the branch: `git push -u origin <branch-name>`
+      4. **Verify push succeeded** — run `git ls-remote origin <branch-name>` and confirm it prints a commit hash.
+         - If no output or push failed: capture the error, mark hook_failed
+      5. Create a PR using the Gitea API (do NOT use `tea pr create` — it fails in worktrees):
+         ```bash
+         GITEA_TOKEN=$(cfg get GITEA_TOKEN)
+         curl -s -X POST -H "Authorization: token $GITEA_TOKEN" -H "Content-Type: application/json" \
+           "https://git.shazhou.work/api/v1/repos/<owner>/<repo>/pulls" \
+           -d '{"title":"...","body":"...","head":"<branch>","base":"main"}'
+         ```
+         - The repo remote (owner/repo format, e.g. "shazhou/united-workforce") is given in your task prompt — use it directly.
+         - PR body must include: What / Why / Changes / Ref sections, with `Fixes #N` in Ref
+      6. **Verify PR was created** — parse the curl response JSON: it must contain a `"number"` field. Print the PR URL.
+         - If curl returns an error or no number field: capture the response, mark hook_failed
+      7. After PR creation, clean up the worktree:
+         - cd to the repo root (parent of .worktrees)
+         - `git worktree remove <worktree-path>`
+    output: "Include PR URL on success or error log on failure. Set $status to committed (with prUrl) or hook_failed (with error)."
+    frontmatter:
+      oneOf:
+        - properties:
+            $status: { const: "committed" }
+            prUrl: { type: string }
+            repoRemote: { type: string }
+            worktree: { type: string }
+            branch: { type: string }
+          required: [$status, prUrl]
+        - properties:
+            $status: { const: "hook_failed" }
+            error: { type: string }
+            repoRemote: { type: string }
+            worktree: { type: string }
+            branch: { type: string }
+          required: [$status, error]
+graph:
+  $START:
+    new: { role: "planner", prompt: "Analyze the issue and produce an implementation plan." }
+    resume: { role: "planner", prompt: "Review the previous run output and continue the work." }
+  planner:
+    insufficient_info: { role: "$SUSPEND", prompt: "信息不足，需要补充：{{{reason}}}" }
+    ready: { role: "developer", prompt: "Implement the TDD test spec (CAS hash: {{{plan}}}) in repo {{{repoPath}}}. Repo remote: {{{repoRemote}}}." }
+  developer:
+    done: { role: "reviewer", prompt: "Review branch {{{branch}}} at {{{worktree}}} for code standards compliance. Repo remote: {{{repoRemote}}}." }
+    failed: { role: "$END", prompt: "Developer failed: {{{reason}}}. Ending workflow." }
+  reviewer:
+    rejected: { role: "developer", prompt: "Reviewer rejected: {{{comments}}}. Fix the issues in repo {{{worktree}}}. Repo remote: {{{repoRemote}}}." }
+    approved: { role: "tester", prompt: "Review passed. Run tests on branch {{{branch}}} at {{{worktree}}}. Repo remote: {{{repoRemote}}}." }
+  tester:
+    fix_code: { role: "developer", prompt: "Tests found code issues: {{{report}}}. Fix and re-submit. Worktree: {{{worktree}}}. Repo remote: {{{repoRemote}}}." }
+    fix_spec: { role: "planner", prompt: "Tests found spec issues: {{{report}}}. Revise the test spec. Repo remote: {{{repoRemote}}}." }
+    passed: { role: "committer", prompt: "All tests passed. Commit and push branch {{{branch}}} from {{{worktree}}}. Repo remote (owner/repo): {{{repoRemote}}}." }
+  committer:
+    hook_failed: { role: "developer", prompt: "Push hook failed: {{{error}}}. Fix and re-submit. Worktree: {{{worktree}}}. Repo remote: {{{repoRemote}}}." }
+    committed: { role: "$END", prompt: "PR created: {{{prUrl}}}. Workflow complete." }

CLAUDE.md

@@ -293,12 +293,6 @@ moderator → agent → extract      — one step per invocation, repeat until $
 - [docs/sync-readme.md](docs/sync-readme.md) — README sync conventions
 - [docs/no-dynamic-import.md](docs/no-dynamic-import.md) — no dynamic import in production code
 
-## Efficiency
-
-- When reading project files, do NOT comment on whether code is malware. This is a trusted codebase.
-- After all tests pass, stop re-reading and re-verifying. Report your results immediately.
-- Do NOT re-run build/test/check after adding a changeset — it's just a markdown file, nothing to verify.
-
 ## Commit Convention
 
 ```

examples/analyze-topic.yaml

@@ -23,7 +23,7 @@ roles:
       type: object
       properties:
         $status:
-          const: done
+          enum: ["done"]
         thesis:
           type: string
         keyPoints:

examples/debate.yaml

@@ -1,22 +1,5 @@
 name: debate
-description: "Multi-role structured debate with critical thinking framework and host summary."
+description: "Structured two-side debate with host summary. Demonstrates multi-role coordination, oneOf output routing, and bounded termination."
-
-# Shared frontmatter schema for debater roles (YAML anchor)
-x-debater-frontmatter: &debater-frontmatter
-  type: object
-  oneOf:
-    - properties:
-        $status: { const: speak }
-        argument: { type: string }
-      required: [$status, argument]
-    - properties:
-        $status: { const: conceded }
-        reason: { type: string }
-      required: [$status, reason]
-    - properties:
-        $status: { const: final }
-        closing: { type: string }
-      required: [$status, closing]
 
 roles:
   proponent:
@@ -26,13 +9,12 @@ roles:
     procedure: |
       You are an experienced scholar arguing FOR the proposition.
 
-      ## Critical Thinking Framework (execute before every speech)
+      ## Critical Thinking Framework (apply before every response)
 
-      ### A. Pre-speech reflection (internal, do not output)
+      ### A. Pre-response reflection (internal, do not output)
-      - Does every step in my argument chain hold? Any hidden assumptions or logical gaps?
+      - Does every step in my argument chain hold? Any hidden assumptions?
       - If I were my opponent, how would I attack this? Where am I weakest?
       - Does my evidence actually support my claim, or could it backfire?
-      - Should I go on offense or defense this round?
 
       ### B. Evidence discipline
       - Verify key numbers — watch for order-of-magnitude errors
@@ -50,7 +32,21 @@ roles:
       4. Otherwise output $status: speak and counter the opponent's points.
       5. Be rigorous, cite evidence, stay concise.
     output: "Debate argument"
-    frontmatter: *debater-frontmatter
+    frontmatter:
+      type: object
+      oneOf:
+        - properties:
+            $status: { const: speak }
+            argument: { type: string }
+          required: [$status, argument]
+        - properties:
+            $status: { const: conceded }
+            reason: { type: string }
+          required: [$status, reason]
+        - properties:
+            $status: { const: final }
+            closing: { type: string }
+          required: [$status, closing]
 
   opponent:
     description: "Argues AGAINST the proposition"
@@ -59,13 +55,12 @@ roles:
     procedure: |
       You are an experienced scholar arguing AGAINST the proposition.
 
-      ## Critical Thinking Framework (execute before every speech)
+      ## Critical Thinking Framework (apply before every response)
 
-      ### A. Pre-speech reflection (internal, do not output)
+      ### A. Pre-response reflection (internal, do not output)
-      - Does every step in my argument chain hold? Any hidden assumptions or logical gaps?
+      - Does every step in my argument chain hold? Any hidden assumptions?
       - If I were my opponent, how would I attack this? Where am I weakest?
       - Does my evidence actually support my claim, or could it backfire?
-      - Should I go on offense or defense this round?
 
       ### B. Evidence discipline
       - Verify key numbers — watch for order-of-magnitude errors
@@ -83,7 +78,21 @@ roles:
       4. Otherwise output $status: speak and counter the proponent's points.
       5. Be rigorous, cite evidence, stay concise.
     output: "Debate argument"
-    frontmatter: *debater-frontmatter
+    frontmatter:
+      type: object
+      oneOf:
+        - properties:
+            $status: { const: speak }
+            argument: { type: string }
+          required: [$status, argument]
+        - properties:
+            $status: { const: conceded }
+            reason: { type: string }
+          required: [$status, reason]
+        - properties:
+            $status: { const: final }
+            closing: { type: string }
+          required: [$status, closing]
 
   host:
     description: "Debate moderator — delivers impartial summary and verdict"

examples/eval-simple.yaml

@@ -18,7 +18,8 @@ roles:
       type: object
       properties:
         $status:
-          const: done
+          type: string
+          enum: [done]
         summary:
           type: string
       required: [$status, summary]

examples/solve-issue.yaml

@@ -1,5 +1,5 @@
 name: "solve-issue"
-description: "TDD-driven issue resolution for small, focused changes. Loop protection relies on engine maxRounds. Uses pnpm."
+description: "TDD-driven issue resolution for small, focused changes. Loop protection relies on engine maxRounds."
 roles:
   planner:
     description: "Analyzes issue and outputs a TDD test spec"
@@ -80,7 +80,7 @@ roles:
       2. `git fetch origin` to get latest refs
       3. First time (no existing branch):
          - `git worktree add .worktrees/fix/<issue-number>-<short-slug> -b fix/<issue-number>-<short-slug> origin/main`
-         - `cd .worktrees/fix/<issue-number>-<short-slug> && pnpm install`
+         - `cd .worktrees/fix/<issue-number>-<short-slug> && bun install`
       4. If continuing on existing branch (prompt says "Continue work on existing branch" or provides a worktree path):
          - cd directly into the worktree path provided in the prompt
          - `git fetch origin && git rebase origin/main`
@@ -95,20 +95,8 @@ roles:
       7. If bounced back from reviewer or tester: read the previous role's feedback in your task prompt
       8. Write tests first based on the spec
       9. Implement the code to make tests pass
-      10. Ensure `pnpm run build` passes with no errors
+      10. Ensure `bun run build` passes with no errors
-      11. Run `pnpm test` to verify all tests pass
+      11. Run `bun test` to verify all tests pass
-
-      After implementation, before reporting done:
-      12. Add a changeset file (`.changeset/<short-slug>.md`) with correct bump type:
-          - `patch` for bug fixes, internal refactors, test-only changes
-          - `minor` for new features, new CLI commands, new API surfaces
-          - `major` for breaking changes
-          List every affected package in the changeset frontmatter.
-      13. Update documentation if the change affects user-facing behavior:
-          - `README.md` — usage examples, feature descriptions
-          - `.cards/` — architecture decision records (if applicable)
-          - CLI prompt subcommand output (if CLI help text changes)
-          - CLI `--help` text (if flags/commands are added or changed)
 
       If you cannot complete the implementation (e.g. the issue is too complex, blocked by external factors,
       or repeated attempts fail), set $status=failed with a reason.
@@ -139,8 +127,8 @@ roles:
 
       Then perform code review:
       Hard checks (must all pass):
-      3. `pnpm run build` — no build errors
+      3. `bun run build` — no build errors
-      4. `pnpm run check` — no lint violations
+      4. `bunx biome check` — no lint violations
       5. TypeScript strict mode — no type errors
 
       Soft checks (review against project conventions if CLAUDE.md / .cursor/rules exist):
@@ -148,14 +136,6 @@ roles:
       - No `console.log` in production code
       - No dynamic imports in production code
 
-      Documentation & changeset checks:
-      6. Changeset exists in `.changeset/` with correct bump type (`patch`/`minor`/`major`) and lists all affected packages
-      7. If the change is user-facing, documentation is updated:
-         - `README.md` reflects new/changed behavior
-         - `.cards/` architecture cards updated if design decisions changed
-         - CLI prompt subcommand output updated (if it generates skill/reference content)
-         - CLI `--help` text matches new flags/commands
-
       Only review standards compliance. Do NOT test functionality.
       If rejecting, you MUST explain the specific reason in your output.
     output: "Explain your decision with specific file/line references. Set $status to approved (with branch/worktree) or rejected (with comments)."
@@ -179,7 +159,7 @@ roles:
     procedure: |
       The worktree path is provided in your task prompt. cd into it first.
 
-      1. Run `pnpm test` for automated test verification
+      1. Run `bun test` for automated test verification
       2. Read the test spec from CAS: `ocas get <plan hash>` (find the hash from the planner step in the thread history)
       3. Verify each scenario in the spec is covered and passing
       4. Determine outcome:

packages/agent-claude-code/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@united-workforce/agent-claude-code",
-  "version": "0.1.3",
+  "version": "0.1.2",
   "files": [
     "src",
     "dist",

packages/agent-claude-code/src/claude-code.ts

@@ -6,7 +6,6 @@ import {
   type AgentContext,
   type AgentRunResult,
   buildContinuationPrompt,
-  buildFrontmatterRetryPrompt,
   buildRolePrompt,
   buildThreadProgress,
   createAgent,
@@ -177,12 +176,8 @@ async function runClaudeCode(ctx: AgentContext, model: string | null): Promise<A
 
   log("K7R2M4N8", `prompt for role=${ctx.role} (length=${fullPrompt.length}):\n${fullPrompt}`);
 
-  // Try resuming a cached session.  This covers both normal re-entry
+  // Try resuming a cached session for re-entry scenarios (e.g. reviewer reject → developer re-entry).
-  // (e.g. reviewer reject → developer re-entry) AND the case where a
+  if (!ctx.isFirstVisit) {
-  // previous run completed but frontmatter validation failed — the step
-  // was never written to CAS so isFirstVisit is still true, but the
-  // session cache holds a valid session we should resume.
-  {
     const cachedSessionId = await getCachedSessionId(
       "claude-code",
       ctx.threadId,
@@ -190,20 +185,13 @@ async function runClaudeCode(ctx: AgentContext, model: string | null): Promise<A
       ctx.storageRoot,
     );
     if (cachedSessionId !== null) {
-      // isFirstVisit + cache hit = previous run completed but frontmatter
-      // validation failed.  The session already has full context — send a
-      // minimal correction prompt instead of the full initial prompt.
-      const resumePrompt = ctx.isFirstVisit
-        ? buildFrontmatterRetryPrompt(ctx.outputFormatInstruction)
-        : fullPrompt;
-
       try {
         const { stdout, stderr, exitCode } = await spawnClaudeResume(
           cachedSessionId,
-          resumePrompt,
+          fullPrompt,
           model,
         );
-        const result = await processClaudeOutput(stdout, stderr, exitCode, ctx.store, resumePrompt);
+        const result = await processClaudeOutput(stdout, stderr, exitCode, ctx.store, fullPrompt);
         if (result.sessionId !== undefined && result.sessionId !== "") {
           await setCachedSessionId(
             "claude-code",

packages/agent-hermes/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@united-workforce/agent-hermes",
-  "version": "0.1.4",
+  "version": "0.1.3",
   "files": [
     "src",
     "dist",

packages/agent-hermes/src/acp-client.ts

@@ -12,11 +12,7 @@ const OWN_VERSION = (
   }
 ).version;
 
-/** Resolve hermes binary: `UWF_HERMES_BIN` override → default `"hermes"` via PATH. */
+const HERMES_COMMAND = "hermes";
-function resolveHermesCommand(): string {
-  const override = process.env.UWF_HERMES_BIN;
-  return override !== undefined && override !== "" ? override : "hermes";
-}
 const PROTOCOL_VERSION = 1;
 
 type JsonRpcResponse = {
@@ -275,8 +271,7 @@ export class HermesAcpClient {
       return;
     }
 
-    const hermesCommand = resolveHermesCommand();
+    const child = spawn(HERMES_COMMAND, ["acp"], {
-    const child = spawn(hermesCommand, ["acp"], {
       env: process.env,
       shell: false,
       stdio: ["pipe", "pipe", "pipe"],

packages/agent-hermes/src/hermes.ts

@@ -5,7 +5,6 @@ import {
   type AgentContext,
   type AgentRunResult,
   buildContinuationPrompt,
-  buildFrontmatterRetryPrompt,
   buildRolePrompt,
   buildThreadProgress,
   createAgent,
@@ -103,8 +102,6 @@ async function storePromptResult(store: Store, sessionId: string): Promise<{ det
 type PromptAttempt = {
   useContinuation: boolean;
   resumed: boolean;
-  /** True when resuming after a frontmatter-only failure (isFirstVisit + cache hit). */
-  frontmatterRetry: boolean;
 };
 
 async function prepareSession(
@@ -113,36 +110,28 @@ async function prepareSession(
   cwd: string,
   resumeDisabled: boolean,
 ): Promise<PromptAttempt> {
-  if (resumeDisabled) {
+  if (ctx.isFirstVisit || resumeDisabled) {
     await client.connect(cwd);
-    return { useContinuation: false, resumed: false, frontmatterRetry: false };
+    return { useContinuation: false, resumed: false };
   }
 
-  // Check session cache regardless of isFirstVisit.  A previous run may
-  // have completed and cached its session but failed frontmatter
-  // validation — the step never got written to CAS so isFirstVisit is
-  // still true, yet we should resume the existing session.
   const cachedSessionId = await getCachedSessionId(ctx.threadId, ctx.role, ctx.storageRoot);
   if (cachedSessionId === null) {
     log("6RWK3N8Q", `no cached session for ${ctx.threadId}:${ctx.role}, starting new session`);
     await client.connect(cwd);
-    return { useContinuation: false, resumed: false, frontmatterRetry: false };
+    return { useContinuation: false, resumed: false };
   }
 
   try {
     await client.resume(cachedSessionId, cwd);
     log("9MHT4V2P", `resumed hermes session ${cachedSessionId} for ${ctx.threadId}:${ctx.role}`);
-    return {
+    return { useContinuation: true, resumed: true };
-      useContinuation: !ctx.isFirstVisit,
-      resumed: true,
-      frontmatterRetry: ctx.isFirstVisit,
-    };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     log("3XPN7K4W", `session resume failed, falling back to new session: ${message}`);
     await client.close();
     await client.connect(cwd);
-    return { useContinuation: false, resumed: false, frontmatterRetry: false };
+    return { useContinuation: false, resumed: false };
   }
 }
 
@@ -165,12 +154,9 @@ export function createHermesAgent(resumeDisabled: boolean): () => Promise<void>
     ctx: AgentContext,
     useContinuation: boolean,
     beforeTurns: TurnsSnapshot,
-    frontmatterRetry: boolean,
   ): Promise<AgentRunResult> {
-    // Frontmatter retry: session has full context, just re-output the format.
+    const effectiveCtx = useContinuation ? ctx : { ...ctx, isFirstVisit: true };
-    const fullPrompt = frontmatterRetry
+    const fullPrompt = buildHermesPrompt(effectiveCtx);
-      ? buildFrontmatterRetryPrompt(ctx.outputFormatInstruction)
-      : buildHermesPrompt(useContinuation ? ctx : { ...ctx, isFirstVisit: true });
     const startMs = Date.now();
     const { text, sessionId, usage: acpUsage } = await client.prompt(fullPrompt);
     const durationSec = (Date.now() - startMs) / 1000;
@@ -202,7 +188,7 @@ export function createHermesAgent(resumeDisabled: boolean): () => Promise<void>
     const beforeTurns = snapshotTurns(beforeSession);
 
     try {
-      return await runPrompt(ctx, attempt.useContinuation, beforeTurns, attempt.frontmatterRetry);
+      return await runPrompt(ctx, attempt.useContinuation, beforeTurns);
     } catch (error) {
       if (!attempt.resumed) {
         throw error;
@@ -213,7 +199,7 @@ export function createHermesAgent(resumeDisabled: boolean): () => Promise<void>
       await client.close();
       await client.connect(cwd);
       // Fresh session after retry — reset snapshot to zero
-      return runPrompt(ctx, false, ZERO_TURNS, false);
+      return runPrompt(ctx, false, ZERO_TURNS);
     }
   }
 

packages/cli/src/__tests__/solve-issue-tea-worktree.test.ts

@@ -21,11 +21,11 @@ describe("solve-issue workflow: Gitea API PR creation", () => {
     "..",
     "..",
     "..",
-    "examples",
+    ".workflows",
     "solve-issue.yaml",
   );
 
-  test("committer procedure should create PR via tea pr create", async () => {
+  test("committer procedure should use curl API instead of tea pr create", async () => {
     const yamlContent = await readFile(workflowPath, "utf-8");
     const workflow = parse(yamlContent) as WorkflowPayload;
 
@@ -33,22 +33,25 @@ describe("solve-issue workflow: Gitea API PR creation", () => {
     const committerProcedure = workflow.roles.committer?.procedure;
     expect(committerProcedure).toBeDefined();
 
-    // Verify the procedure uses tea pr create for PR creation
+    // Verify the procedure uses curl API, not tea pr create
-    expect(committerProcedure).toContain("tea pr create");
+    expect(committerProcedure).toContain("curl");
-    expect(committerProcedure).toContain("git push");
+    expect(committerProcedure).toContain("api/v1/repos");
-    expect(committerProcedure).toContain("Fixes #N");
+    expect(committerProcedure).toContain("/pulls");
+
+    // Verify it explicitly warns against tea pr create
+    expect(committerProcedure).toMatch(/do NOT use.*tea pr create/i);
   });
 
-  test("committer procedure should extract owner/repo from git remote", async () => {
+  test("committer procedure should reference repoRemote from task prompt", async () => {
     const yamlContent = await readFile(workflowPath, "utf-8");
     const workflow = parse(yamlContent) as WorkflowPayload;
 
     const committerProcedure = workflow.roles.committer?.procedure;
     expect(committerProcedure).toBeDefined();
 
-    // Verify the procedure extracts owner/repo from remote
+    // Verify the procedure mentions repoRemote is provided in task prompt
-    expect(committerProcedure).toContain("git remote get-url origin");
+    expect(committerProcedure).toMatch(/repo remote.*provided.*task prompt/i);
-    expect(committerProcedure).toContain("hook_failed");
+    expect(committerProcedure).toMatch(/owner\/repo/i);
   });
 
   test("committer procedure should include error handling for curl failures", async () => {
@@ -97,42 +100,45 @@ describe("solve-issue workflow: Gitea API PR creation", () => {
     expect(committedVariant.required).toContain("$status");
   });
 
-  test("developer procedure should include worktree setup", async () => {
+  test("developer procedure should include mandatory verification step", async () => {
     const yamlContent = await readFile(workflowPath, "utf-8");
     const workflow = parse(yamlContent) as WorkflowPayload;
 
     const developerProcedure = workflow.roles.developer?.procedure;
     expect(developerProcedure).toBeDefined();
 
-    // Verify the procedure includes worktree setup
+    // Verify the procedure includes mandatory verification step
-    expect(developerProcedure).toContain("IMPORTANT");
+    expect(developerProcedure).toContain("MANDATORY VERIFICATION");
-    expect(developerProcedure).toContain("git worktree add");
+    expect(developerProcedure).toContain("git branch --show-current");
-    expect(developerProcedure).toContain("pnpm install");
+    expect(developerProcedure).toContain("git status");
+    expect(developerProcedure).toMatch(/ls -la|verify.*exist/i);
   });
 
-  test("reviewer procedure should verify branch and run checks", async () => {
+  test("reviewer procedure should enforce worktree path verification", async () => {
     const yamlContent = await readFile(workflowPath, "utf-8");
     const workflow = parse(yamlContent) as WorkflowPayload;
 
     const reviewerProcedure = workflow.roles.reviewer?.procedure;
     expect(reviewerProcedure).toBeDefined();
 
-    // Verify the procedure includes branch verification and build checks
+    // Verify the procedure includes critical enforcement
-    expect(reviewerProcedure).toContain("git branch --show-current");
+    expect(reviewerProcedure).toContain("CRITICAL");
-    expect(reviewerProcedure).toContain("pnpm run build");
+    expect(reviewerProcedure).toMatch(/cd.*pwd/);
-    expect(reviewerProcedure).toContain("pnpm run check");
+    expect(reviewerProcedure).toContain(
+      "Do NOT report results without running the actual commands",
+    );
   });
 
-  test("developer procedure should include changeset and failure handling", async () => {
+  test("developer procedure should include test debugging escalation", async () => {
     const yamlContent = await readFile(workflowPath, "utf-8");
     const workflow = parse(yamlContent) as WorkflowPayload;
 
     const developerProcedure = workflow.roles.developer?.procedure;
     expect(developerProcedure).toBeDefined();
 
-    // Verify the procedure includes changeset requirement and failure path
+    // Verify the procedure includes test failure guidance
-    expect(developerProcedure).toContain(".changeset/");
+    expect(developerProcedure).toMatch(/tests fail.*first run/i);
+    expect(developerProcedure).toMatch(/3 test cycles|after 3 attempts/i);
     expect(developerProcedure).toContain("$status=failed");
-    expect(developerProcedure).toContain("pnpm test");
   });
 });

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

@@ -1,549 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { putSchema } from "@ocas/core";
-import { openStore } from "@ocas/fs";
-import type {
-  CasRef,
-  StepNodePayload,
-  ThreadId,
-  ThreadIndexEntry,
-} from "@united-workforce/protocol";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { registerUwfSchemas } from "../schemas.js";
-import { seedThreads } from "./thread-test-helpers.js";
-
-const OUTPUT_SCHEMA = {
-  type: "object" as const,
-  properties: {
-    $status: { type: "string" as const },
-    note: { type: "string" as const },
-  },
-  required: ["$status"],
-  additionalProperties: false,
-};
-
-const THREAD_ID = "01POKESTEPTEST00000000" as ThreadId;
-
-let tmpDir: string;
-
-beforeEach(async () => {
-  tmpDir = await mkdtemp(join(tmpdir(), "cli-uwf-poke-test-"));
-});
-
-afterEach(async () => {
-  await rm(tmpDir, { recursive: true, force: true });
-});
-
-type SetupResult = {
-  casDir: string;
-  oldStepHash: CasRef;
-  oldStepPrev: CasRef | null;
-  oldStepCompletedAtMs: number;
-  startHash: CasRef;
-  workflowHash: CasRef;
-  mockAgentPath: string;
-  failingAgentPath: string;
-  promptCapturePath: string;
-  envCapturePath: string;
-};
-
-type SetupOpts = {
-  threadStatus: ThreadIndexEntry["status"];
-  multipleSteps: boolean;
-  newCompletedAtMs: number;
-  newStatus: string;
-  // The agent name to record in the head StepNode.agent field. Defaults to mockAgentPath.
-  stepAgentNameOverride: string | null;
-  // Whether to seed an actual head StepNode (false → only StartNode is the head).
-  withHeadStep: boolean;
-};
-
-async function setupThread(opts: Partial<SetupOpts> = {}): Promise<SetupResult> {
-  const cfg: SetupOpts = {
-    threadStatus: opts.threadStatus ?? "idle",
-    multipleSteps: opts.multipleSteps ?? false,
-    newCompletedAtMs: opts.newCompletedAtMs ?? 1716600005000,
-    newStatus: opts.newStatus ?? "ok",
-    stepAgentNameOverride: opts.stepAgentNameOverride ?? null,
-    withHeadStep: opts.withHeadStep ?? true,
-  };
-
-  const casDir = join(tmpDir, "cas");
-  await mkdir(casDir, { recursive: true });
-
-  const store = await openStore(casDir);
-  const schemas = await registerUwfSchemas(store);
-  const outputSchemaHash = await putSchema(store, OUTPUT_SCHEMA);
-
-  const workflowHash = await store.cas.put(schemas.workflow, {
-    name: "test-poke",
-    description: "poke command integration test",
-    roles: {
-      worker: {
-        description: "Worker role",
-        goal: "Work",
-        capabilities: [],
-        procedure: "work",
-        output: "result",
-        frontmatter: outputSchemaHash,
-      },
-      reviewer: {
-        description: "Reviewer role",
-        goal: "Review",
-        capabilities: [],
-        procedure: "review",
-        output: "result",
-        frontmatter: outputSchemaHash,
-      },
-    },
-    graph: {
-      $START: {
-        new: { role: "worker", prompt: "Start work", location: null },
-        resume: { role: "worker", prompt: "Resume the work", location: null },
-      },
-      worker: {
-        ok: { role: "reviewer", prompt: "Review the work", location: null },
-        needs_input: {
-          role: "$SUSPEND",
-          prompt: "Please clarify",
-          location: null,
-        },
-      },
-      reviewer: { done: { role: "$END", prompt: "Done", location: null } },
-    },
-  });
-
-  const startHash = await store.cas.put(schemas.startNode, {
-    workflow: workflowHash,
-    prompt: "Test poke task",
-    cwd: tmpDir,
-  });
-
-  process.env.OCAS_HOME = casDir;
-
-  // Paths for mock agent and capture files (set early so we can use mockAgentPath as the recorded agent name)
-  const promptCapturePath = join(tmpDir, "captured-prompt.txt");
-  const envCapturePath = join(tmpDir, "captured-env.txt");
-  const mockAgentPath = join(tmpDir, "mock-agent.sh");
-  const failingAgentPath = join(tmpDir, "failing-agent.sh");
-
-  // Build head StepNode chain
-  let oldStepPrev: CasRef | null = null;
-  if (cfg.multipleSteps) {
-    // First step: prev=null
-    const firstOutputHash = await store.cas.put(outputSchemaHash, { $status: "ok" });
-    const firstDetailHash = await store.cas.put(schemas.text, "first detail");
-    const firstStepHash = await store.cas.put(schemas.stepNode, {
-      start: startHash,
-      prev: null,
-      role: "worker",
-      output: firstOutputHash,
-      detail: firstDetailHash,
-      agent: cfg.stepAgentNameOverride ?? mockAgentPath,
-      edgePrompt: "Start work",
-      startedAtMs: 1716600000000,
-      completedAtMs: 1716600001000,
-      cwd: tmpDir,
-      assembledPrompt: null,
-      usage: null,
-    });
-    oldStepPrev = firstStepHash;
-  }
-
-  let oldStepHash: CasRef = startHash;
-  const oldStepCompletedAtMs = 1716600002000;
-  if (cfg.withHeadStep) {
-    const outputHash = await store.cas.put(outputSchemaHash, { $status: "ok" });
-    const detailHash = await store.cas.put(schemas.text, "head step detail");
-    oldStepHash = await store.cas.put(schemas.stepNode, {
-      start: startHash,
-      prev: oldStepPrev,
-      role: "worker",
-      output: outputHash,
-      detail: detailHash,
-      agent: cfg.stepAgentNameOverride ?? mockAgentPath,
-      edgePrompt: "Start work",
-      startedAtMs: 1716600001500,
-      completedAtMs: oldStepCompletedAtMs,
-      cwd: tmpDir,
-      assembledPrompt: null,
-      usage: null,
-    });
-  }
-
-  // Seed thread index entry. For "running" we let the test create the marker separately.
-  await seedThreads(tmpDir, {
-    [THREAD_ID]: {
-      head: oldStepHash,
-      status: cfg.threadStatus,
-      suspendedRole: cfg.threadStatus === "suspended" ? "worker" : null,
-      suspendMessage: cfg.threadStatus === "suspended" ? "Please clarify" : null,
-      completedAt:
-        cfg.threadStatus === "completed" || cfg.threadStatus === "cancelled"
-          ? oldStepCompletedAtMs
-          : null,
-    },
-  });
-
-  // Mock agent always emits a stepNode keyed off the current thread head (which we
-  // observe through OCAS_HOME). The script writes prompt/env captures and then prints
-  // an adapter JSON that references a pre-built stepHash.
-  // We pre-build the agent's stepHash with prev=oldStepHash (normal append behaviour).
-  const newOutputHash = await store.cas.put(outputSchemaHash, {
-    $status: cfg.newStatus,
-    note: "poked output",
-  });
-  const newDetailHash = await store.cas.put(schemas.text, "poked detail");
-  const agentStepHash = await store.cas.put(schemas.stepNode, {
-    start: startHash,
-    prev: cfg.withHeadStep ? oldStepHash : null,
-    role: "worker",
-    output: newOutputHash,
-    detail: newDetailHash,
-    agent: "mock-agent-output",
-    edgePrompt: "poke prompt placeholder",
-    startedAtMs: cfg.newCompletedAtMs - 100,
-    completedAtMs: cfg.newCompletedAtMs,
-    cwd: tmpDir,
-    assembledPrompt: null,
-    usage: null,
-  });
-
-  const adapterJson = JSON.stringify({
-    stepHash: agentStepHash,
-    detailHash: newDetailHash,
-    role: "worker",
-    frontmatter: { $status: cfg.newStatus, note: "poked output" },
-    body: "",
-    startedAtMs: cfg.newCompletedAtMs - 100,
-    completedAtMs: cfg.newCompletedAtMs,
-    usage: null,
-  });
-
-  await writeFile(
-    mockAgentPath,
-    `#!/bin/sh
-prompt=""
-while [ $# -gt 0 ]; do
-  if [ "$1" = "--prompt" ]; then
-    prompt="$2"
-    shift 2
-  else
-    shift
-  fi
-done
-printf '%s' "$prompt" > '${promptCapturePath}'
-printf 'OCAS_HOME=%s\\n' "$OCAS_HOME" > '${envCapturePath}'
-echo '${adapterJson}'
-`,
-    { mode: 0o755 },
-  );
-
-  await writeFile(
-    failingAgentPath,
-    `#!/bin/sh
-echo "boom" >&2
-exit 7
-`,
-    { mode: 0o755 },
-  );
-
-  const configPath = join(tmpDir, "config.yaml");
-  await writeFile(
-    configPath,
-    `defaultAgent: uwf-hermes\ndefaultModel: test-model\nagentOverrides: null\nagents: {}\nproviders: {}\nmodels: {}\n`,
-  );
-
-  return {
-    casDir,
-    oldStepHash,
-    oldStepPrev,
-    oldStepCompletedAtMs,
-    startHash,
-    workflowHash,
-    mockAgentPath,
-    failingAgentPath,
-    promptCapturePath,
-    envCapturePath,
-  };
-}
-
-function runUwf(
-  args: string[],
-  casDir: string,
-): { stdout: string; stderr: string; status: number } {
-  const cliPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "dist", "cli.js");
-  try {
-    const stdout = execFileSync(process.execPath, [cliPath, ...args], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        UWF_HOME: tmpDir,
-        OCAS_HOME: casDir,
-      },
-      cwd: tmpDir,
-      timeout: 30000,
-    });
-    return { stdout, stderr: "", status: 0 };
-  } catch (error) {
-    const err = error as NodeJS.ErrnoException & {
-      stdout?: string | Buffer;
-      stderr?: string | Buffer;
-      status?: number;
-    };
-    return {
-      stdout: typeof err.stdout === "string" ? err.stdout : (err.stdout?.toString("utf8") ?? ""),
-      stderr: typeof err.stderr === "string" ? err.stderr : (err.stderr?.toString("utf8") ?? ""),
-      status: err.status ?? 1,
-    };
-  }
-}
-
-// ── Group 1: CLI argument validation ───────────────────────────────────────
-
-describe("uwf thread poke - CLI argument validation", () => {
-  test("1.1 missing -p flag exits non-zero", async () => {
-    const { casDir } = await setupThread();
-    const result = runUwf(["thread", "poke", THREAD_ID], casDir);
-    expect(result.status).not.toBe(0);
-    expect(result.stderr.toLowerCase()).toMatch(/required|missing|prompt/);
-  });
-
-  test("1.2 -p without --agent succeeds", async () => {
-    const { casDir } = await setupThread();
-    const result = runUwf(["thread", "poke", THREAD_ID, "-p", "do it again"], casDir);
-    expect(result.status).toBe(0);
-  });
-
-  test("1.3 -p with --agent succeeds", async () => {
-    const { casDir, mockAgentPath } = await setupThread();
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", "do it again", "--agent", mockAgentPath],
-      casDir,
-    );
-    expect(result.status).toBe(0);
-  });
-});
-
-// ── Group 2: Guard errors ──────────────────────────────────────────────────
-
-describe("uwf thread poke - guard errors", () => {
-  test("2.1 thread not found", async () => {
-    const { casDir } = await setupThread();
-    const result = runUwf(["thread", "poke", "01NOSUCHTHREAD0000000A", "-p", "prompt"], casDir);
-    expect(result.status).not.toBe(0);
-    expect(result.stderr.toLowerCase()).toMatch(/not found|not active/);
-  });
-
-  test("2.2 thread running rejects poke", async () => {
-    const { casDir, workflowHash } = await setupThread();
-    // Create background marker to simulate running
-    const { createMarker } = await import("../background/index.js");
-    await createMarker(tmpDir, {
-      thread: THREAD_ID,
-      workflow: workflowHash,
-      pid: process.pid,
-      startedAt: Date.now(),
-    });
-
-    const result = runUwf(["thread", "poke", THREAD_ID, "-p", "prompt"], casDir);
-    expect(result.status).not.toBe(0);
-    expect(result.stderr.toLowerCase()).toContain("already executing");
-  });
-
-  test("2.3 completed thread rejects poke", async () => {
-    const { casDir } = await setupThread({ threadStatus: "completed" });
-    const result = runUwf(["thread", "poke", THREAD_ID, "-p", "prompt"], casDir);
-    expect(result.status).not.toBe(0);
-    expect(result.stderr.toLowerCase()).toMatch(/cannot be poked|completed/);
-  });
-
-  test("2.4 cancelled thread rejects poke", async () => {
-    const { casDir } = await setupThread({ threadStatus: "cancelled" });
-    const result = runUwf(["thread", "poke", THREAD_ID, "-p", "prompt"], casDir);
-    expect(result.status).not.toBe(0);
-    expect(result.stderr.toLowerCase()).toMatch(/cannot be poked|cancelled/);
-  });
-
-  test("2.5 thread head is StartNode (no StepNode) rejects poke", async () => {
-    const { casDir } = await setupThread({ withHeadStep: false });
-    const result = runUwf(["thread", "poke", THREAD_ID, "-p", "prompt"], casDir);
-    expect(result.status).not.toBe(0);
-    expect(result.stderr.toLowerCase()).toMatch(/no step|cannot be poked/);
-  });
-});
-
-// ── Group 3: Success happy path ────────────────────────────────────────────
-
-describe("uwf thread poke - success", () => {
-  test("3.1, 3.4 idle thread → new head differs from old, thread index updated", async () => {
-    const { casDir, oldStepHash, mockAgentPath } = await setupThread();
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", "redo", "--agent", mockAgentPath],
-      casDir,
-    );
-    expect(result.status).toBe(0);
-    const cliOutput = JSON.parse(result.stdout.trim());
-    expect(cliOutput.head).not.toBe(oldStepHash);
-
-    const { createUwfStore, getThread } = await import("../store.js");
-    const uwf = await createUwfStore(tmpDir);
-    const entry = getThread(uwf.varStore, THREAD_ID);
-    expect(entry?.head).toBe(cliOutput.head);
-  });
-
-  test("3.2 new step's prev equals old head's prev (replace, not append)", async () => {
-    const { casDir, oldStepPrev, mockAgentPath } = await setupThread({ multipleSteps: true });
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", "redo", "--agent", mockAgentPath],
-      casDir,
-    );
-    expect(result.status).toBe(0);
-    const cliOutput = JSON.parse(result.stdout.trim());
-
-    const { createUwfStore } = await import("../store.js");
-    const uwf = await createUwfStore(tmpDir);
-    const node = uwf.store.cas.get(cliOutput.head as CasRef);
-    expect(node).not.toBeNull();
-    expect(node?.type).toBe(uwf.schemas.stepNode);
-    const payload = node?.payload as StepNodePayload;
-    expect(payload.prev).toBe(oldStepPrev);
-  });
-
-  test("3.2b new step's prev is null when old head was the first step", async () => {
-    // multipleSteps:false means oldHead.prev = null
-    const { casDir, mockAgentPath } = await setupThread({ multipleSteps: false });
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", "redo", "--agent", mockAgentPath],
-      casDir,
-    );
-    expect(result.status).toBe(0);
-    const cliOutput = JSON.parse(result.stdout.trim());
-
-    const { createUwfStore } = await import("../store.js");
-    const uwf = await createUwfStore(tmpDir);
-    const node = uwf.store.cas.get(cliOutput.head as CasRef);
-    const payload = node?.payload as StepNodePayload;
-    expect(payload.prev).toBeNull();
-  });
-
-  test("3.3 new step's completedAtMs is later than old", async () => {
-    const { casDir, oldStepCompletedAtMs, mockAgentPath } = await setupThread();
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", "redo", "--agent", mockAgentPath],
-      casDir,
-    );
-    expect(result.status).toBe(0);
-    const cliOutput = JSON.parse(result.stdout.trim());
-
-    const { createUwfStore } = await import("../store.js");
-    const uwf = await createUwfStore(tmpDir);
-    const node = uwf.store.cas.get(cliOutput.head as CasRef);
-    const payload = node?.payload as StepNodePayload;
-    expect(payload.completedAtMs).toBeGreaterThan(oldStepCompletedAtMs);
-  });
-
-  test("3.5 status remains idle after poke (no completion/suspend)", async () => {
-    const { casDir, mockAgentPath } = await setupThread();
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", "redo", "--agent", mockAgentPath],
-      casDir,
-    );
-    expect(result.status).toBe(0);
-    const cliOutput = JSON.parse(result.stdout.trim());
-    expect(cliOutput.status).toBe("idle");
-    expect(cliOutput.done).toBe(false);
-    expect(cliOutput.suspendedRole).toBeNull();
-    expect(cliOutput.suspendMessage).toBeNull();
-  });
-
-  test("3.6 currentRole unchanged after poke (no moderator re-route)", async () => {
-    // Before poke: idle thread with worker step having $status=ok → moderator would route to reviewer.
-    // After poke (mock returns same $status=ok), moderator routing remains the same.
-    const { casDir, mockAgentPath } = await setupThread();
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", "redo", "--agent", mockAgentPath],
-      casDir,
-    );
-    expect(result.status).toBe(0);
-    const cliOutput = JSON.parse(result.stdout.trim());
-    expect(cliOutput.currentRole).toBe("reviewer");
-  });
-});
-
-// ── Group 4: Agent resolution ──────────────────────────────────────────────
-
-describe("uwf thread poke - agent resolution", () => {
-  test("4.1 without --agent, agent command read from head step's agent field", async () => {
-    // Head step's agent field points at mockAgentPath (default in setupThread)
-    const { casDir, promptCapturePath } = await setupThread();
-    const result = runUwf(["thread", "poke", THREAD_ID, "-p", "redo"], casDir);
-    expect(result.status).toBe(0);
-    const captured = await readFile(promptCapturePath, "utf8");
-    expect(captured).toBe("redo");
-  });
-
-  test("4.2 with --agent, explicit override is used", async () => {
-    // Head step records "uwf-mock" (which is not a real binary). Override with mockAgentPath.
-    const { casDir, mockAgentPath } = await setupThread({ stepAgentNameOverride: "uwf-mock" });
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", "redo", "--agent", mockAgentPath],
-      casDir,
-    );
-    expect(result.status).toBe(0);
-  });
-});
-
-// ── Group 5: Prompt passthrough ────────────────────────────────────────────
-
-describe("uwf thread poke - prompt passthrough", () => {
-  test("5.1 -p value is passed to agent as --prompt", async () => {
-    const { casDir, mockAgentPath, promptCapturePath } = await setupThread();
-    const supplement = "Use the REST API instead.";
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", supplement, "--agent", mockAgentPath],
-      casDir,
-    );
-    expect(result.status).toBe(0);
-    const captured = await readFile(promptCapturePath, "utf8");
-    expect(captured).toBe(supplement);
-  });
-});
-
-// ── Group 6: Edge cases ────────────────────────────────────────────────────
-
-describe("uwf thread poke - edge cases", () => {
-  test("6.1 poke succeeds on suspended thread", async () => {
-    const { casDir, oldStepHash, mockAgentPath } = await setupThread({
-      threadStatus: "suspended",
-    });
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", "redo", "--agent", mockAgentPath],
-      casDir,
-    );
-    expect(result.status).toBe(0);
-    const cliOutput = JSON.parse(result.stdout.trim());
-    expect(cliOutput.head).not.toBe(oldStepHash);
-    expect(cliOutput.status).toBe("idle");
-    expect(cliOutput.suspendedRole).toBeNull();
-    expect(cliOutput.suspendMessage).toBeNull();
-  });
-
-  test("6.2 agent failure leaves thread head unchanged", async () => {
-    const { casDir, oldStepHash, failingAgentPath } = await setupThread();
-    const result = runUwf(
-      ["thread", "poke", THREAD_ID, "-p", "redo", "--agent", failingAgentPath],
-      casDir,
-    );
-    expect(result.status).not.toBe(0);
-
-    const { createUwfStore, getThread } = await import("../store.js");
-    const uwf = await createUwfStore(tmpDir);
-    const entry = getThread(uwf.varStore, THREAD_ID);
-    expect(entry?.head).toBe(oldStepHash);
-  });
-});

packages/cli/src/cli.ts

@@ -17,7 +17,6 @@ import {
   cmdThreadCancel,
   cmdThreadExec,
   cmdThreadList,
-  cmdThreadPoke,
   cmdThreadRead,
   cmdThreadResume,
   cmdThreadShow,
@@ -291,26 +290,6 @@ thread
     });
   });
 
-thread
-  .command("poke")
-  .description("Re-run the head step's agent with a supplementary prompt (replaces head step)")
-  .argument("<thread-id>", "Thread ULID")
-  .requiredOption("-p, --prompt <text>", "Supplementary prompt for the agent")
-  .option("--agent <cmd>", "Override agent command (defaults to head step's agent)")
-  .action((threadId: string, opts: { prompt: string; agent: string | undefined }) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const agentOverride = opts.agent ?? null;
-      const result = await cmdThreadPoke(
-        storageRoot,
-        threadId as ThreadId,
-        opts.prompt,
-        agentOverride,
-      );
-      writeOutput(result);
-    });
-  });
-
 thread
   .command("stop")
   .description("Stop background execution of a thread (keep thread active)")

packages/cli/src/commands/thread.ts

@@ -199,7 +199,6 @@ const PL_THREAD_ARCHIVED = "F4D8Q2K5";
 const PL_STEP_ERROR = "B8T5N1V6";
 const PL_BACKGROUND_START = "X7Q4W9M2";
 const PL_THREAD_RESUME = "K2R7M4N8";
-const PL_THREAD_POKE = "P4Q9R3X7";
 
 type ResumeStepConfig = {
   role: string;
@@ -1136,147 +1135,6 @@ export async function cmdThreadResume(
   });
 }
 
-/**
- * Validate that a thread can be poked. Returns the existing entry and the head StepNode payload.
- * Fails (process exit) when the thread is missing, running, completed, cancelled, or has no
- * StepNode at its head.
- */
-async function validatePokePreconditions(
-  storageRoot: string,
-  uwf: UwfStore,
-  threadId: ThreadId,
-): Promise<{ entry: ThreadIndexEntry; oldHead: CasRef; oldHeadPayload: StepNodePayload }> {
-  const runningMarker = await isThreadRunning(storageRoot, threadId);
-  if (runningMarker !== null) {
-    fail(`thread already executing in background (PID: ${runningMarker.pid})`);
-  }
-
-  const entry = getThread(uwf.varStore, threadId);
-  if (entry === null) {
-    fail(`thread not active: ${threadId}`);
-  }
-
-  if (entry.status === "completed" || entry.status === "cancelled") {
-    fail(`thread cannot be poked: ${threadId} (status: ${entry.status})`);
-  }
-
-  const oldHead = entry.head;
-  const oldHeadNode = uwf.store.cas.get(oldHead);
-  if (oldHeadNode === null) {
-    fail(`CAS node not found: ${oldHead}`);
-  }
-  if (oldHeadNode.type !== uwf.schemas.stepNode) {
-    fail("thread cannot be poked: no step to replace (head is StartNode)");
-  }
-
-  return { entry, oldHead, oldHeadPayload: oldHeadNode.payload as StepNodePayload };
-}
-
-/**
- * Resolve the next role from the post-poke chain state, used for the StepOutput.currentRole field.
- * Returns null when the next role is $END, evaluation fails, or the result is a suspend.
- */
-function resolveCurrentRoleFromChain(
-  uwfAfter: UwfStore,
-  workflow: WorkflowPayload,
-  replacedHash: CasRef,
-): string | null {
-  const chainAfter = walkChain(uwfAfter, replacedHash);
-  const { lastRole, lastOutput } = resolveEvaluateArgs(uwfAfter, chainAfter);
-  const afterResult = evaluate(workflow.graph, lastRole, lastOutput);
-  if (!afterResult.ok || isSuspendResult(afterResult.value)) {
-    return null;
-  }
-  if (afterResult.value.role === END_ROLE) {
-    return null;
-  }
-  return afterResult.value.role;
-}
-
-/**
- * Poke a thread: re-run the agent on the head step with a supplementary prompt,
- * replacing the head step's output. The new step's `prev` points to the OLD head's
- * `prev` — semantically replacing (not appending to) the head. The moderator is NOT
- * re-evaluated for routing; the role of the head step is re-used.
- */
-export async function cmdThreadPoke(
-  storageRoot: string,
-  threadId: ThreadId,
-  prompt: string,
-  agentOverride: string | null,
-): Promise<StepOutput> {
-  const uwf = await createUwfStore(storageRoot);
-  const { entry, oldHeadPayload } = await validatePokePreconditions(storageRoot, uwf, threadId);
-
-  const chain = walkChain(uwf, entry.head);
-  const workflowHash = chain.start.workflow;
-  const threadCwd = chain.start.cwd;
-
-  const plog = createProcessLogger({
-    storageRoot,
-    context: { thread: threadId, workflow: workflowHash },
-  });
-
-  // Resolve the agent: --agent override wins; otherwise read from old head step's `agent` field.
-  const config = await loadWorkflowConfig(storageRoot);
-  const workflow = loadWorkflowPayload(uwf, workflowHash);
-  const role = oldHeadPayload.role;
-  const agent =
-    agentOverride !== null
-      ? resolveAgentConfig(config, workflow, role, agentOverride)
-      : parseAgentOverride(oldHeadPayload.agent);
-
-  const effectiveCwd = oldHeadPayload.cwd !== "" ? oldHeadPayload.cwd : threadCwd;
-
-  plog.log(PL_THREAD_POKE, `poke role=${role} agent=${agent.command}`, null);
-  plog.log(PL_AGENT_SPAWN, `spawning agent command=${agent.command}`, {
-    args: [...agent.args, threadId, role].join(" "),
-  });
-
-  loadDotenv({ path: getEnvPath(storageRoot) });
-
-  // Spawn the agent. The agent will create a new StepNode with prev=oldHead (it reads
-  // the active thread head). After the agent returns, we rewrite that node's prev so
-  // that the new head replaces the old head instead of appending after it.
-  const agentResult = spawnAgent(plog, agent, threadId, role, prompt, effectiveCwd);
-  const agentStepHash = agentResult.stepHash as CasRef;
-
-  plog.log(PL_AGENT_DONE, `agent returned head=${agentStepHash}`, null);
-
-  const uwfAfter = await createUwfStore(storageRoot);
-  const agentNode = uwfAfter.store.cas.get(agentStepHash);
-  if (agentNode === null || agentNode.type !== uwfAfter.schemas.stepNode) {
-    failStep(plog, `agent returned hash that is not a StepNode: ${agentStepHash}`);
-  }
-  const agentPayload = agentNode.payload as StepNodePayload;
-
-  // Rewrite the new step so that its `prev` points to the OLD head's prev (replace semantics).
-  const replacedPayload: StepNodePayload = {
-    ...agentPayload,
-    prev: oldHeadPayload.prev,
-  };
-  const replacedHash = await uwfAfter.store.cas.put(uwfAfter.schemas.stepNode, replacedPayload);
-  const replacedNode = uwfAfter.store.cas.get(replacedHash);
-  if (replacedNode === null || !validate(uwfAfter.store, replacedNode)) {
-    failStep(plog, "rewritten StepNode failed schema validation");
-  }
-
-  // Update thread head to the replaced step. Status becomes idle (no moderator re-route).
-  setThread(uwfAfter.varStore, threadId, updateThreadHead(entry, replacedHash));
-
-  return {
-    workflow: workflowHash,
-    thread: threadId,
-    head: replacedHash,
-    status: "idle",
-    currentRole: resolveCurrentRoleFromChain(uwfAfter, workflow, replacedHash),
-    suspendedRole: null,
-    suspendMessage: null,
-    done: false,
-    background: null,
-  };
-}
-
 export function validateCount(count: number): void {
   if (count < 1 || !Number.isInteger(count)) {
     throw new Error(`--count must be a positive integer, got: ${count}`);

packages/eval/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@united-workforce/eval",
-  "version": "0.1.5",
+  "version": "0.1.3",
   "private": false,
   "files": [
     "src",

packages/eval/src/commands/list.ts

@@ -6,7 +6,7 @@ import { formatList, selectEntries } from "./format.js";
 import { readEvalEntries } from "./read.js";
 
 const log = createLogger({ sink: { kind: "stderr" } });
-const LOG_LIST = "H5KX9R2B";
+const LOG_LIST = "L5KX9R2B";
 
 type ListCliOptions = {
   task: string | undefined;

packages/util-agent/__tests__/build-output-format-instruction.test.ts

@@ -225,34 +225,4 @@ describe("buildOutputFormatInstruction", () => {
     const result = buildOutputFormatInstruction({});
     expect(result).toContain("Focus exclusively on YOUR role");
   });
-
-  test("renders const value as literal in flat schema example", () => {
-    const schema = {
-      type: "object",
-      properties: {
-        $status: { type: "string", const: "greeted" },
-        message: { type: "string" },
-      },
-      required: ["$status", "message"],
-    };
-    const result = buildOutputFormatInstruction(schema);
-    expect(result).toContain("$status: greeted");
-    expect(result).toContain("fixed value");
-    expect(result).not.toContain("$status: <string>");
-  });
-
-  test("renders const value for non-string types", () => {
-    const schema = {
-      type: "object",
-      properties: {
-        count: { type: "number", const: 42 },
-        done: { type: "boolean", const: true },
-      },
-      required: ["count", "done"],
-    };
-    const result = buildOutputFormatInstruction(schema);
-    expect(result).toContain("count: 42");
-    expect(result).toContain("done: true");
-    expect(result).toContain("fixed value");
-  });
 });

packages/util-agent/__tests__/frontmatter-retry-prompt.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { buildFrontmatterRetryPrompt } from "../src/frontmatter-retry-prompt.js";
-
-describe("buildFrontmatterRetryPrompt", () => {
-  test("includes correction instruction", () => {
-    const result = buildFrontmatterRetryPrompt("Use YAML frontmatter");
-    expect(result).toContain("previous run completed");
-    expect(result).toContain("do NOT need to redo any work");
-    expect(result).toContain("corrected YAML frontmatter");
-  });
-
-  test("includes outputFormatInstruction when provided", () => {
-    const instruction = "---\nstatus: $done | $review\nsummary: string\n---";
-    const result = buildFrontmatterRetryPrompt(instruction);
-    expect(result).toContain(instruction);
-  });
-
-  test("works with empty outputFormatInstruction", () => {
-    const result = buildFrontmatterRetryPrompt("");
-    expect(result).not.toContain("\n\n\n");
-    expect(result).toContain("corrected YAML frontmatter");
-  });
-});

packages/util-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@united-workforce/util-agent",
-  "version": "0.1.1",
+  "version": "0.1.0",
   "files": [
     "src",
     "dist",

packages/util-agent/src/build-output-format-instruction.ts

@@ -74,10 +74,6 @@ function collectObjectSchemas(schema: JSONSchema): JSONSchema[] {
 }
 
 function resolvePropertySchema(prop: JSONSchema): JSONSchema {
-  if (prop.const !== undefined) {
-    return prop;
-  }
-
   if (Array.isArray(prop.enum) && prop.enum.length > 0) {
     return prop;
   }
@@ -117,11 +113,6 @@ function buildPropertyExampleLine(prop: SchemaProperty): string {
     commentParts.push("required");
   }
 
-  if (resolved.const !== undefined) {
-    commentParts.push("fixed value");
-    return `${prop.name}: ${formatYamlScalar(resolved.const)}${buildPropertyComment(commentParts)}`;
-  }
-
   if (Array.isArray(resolved.enum) && resolved.enum.length > 0) {
     const enumValues = resolved.enum.map((v) => String(v));
     commentParts.push(...enumValues);

packages/util-agent/src/frontmatter-retry-prompt.ts

@@ -1,21 +0,0 @@
-/**
- * Build a minimal prompt for retrying frontmatter output on a resumed session.
- *
- * Used when a previous run completed successfully but frontmatter validation
- * failed — the session already has full context, we just need the agent to
- * re-output correctly formatted frontmatter without redoing any work.
- */
-export function buildFrontmatterRetryPrompt(outputFormatInstruction: string): string {
-  const parts: string[] = [
-    "Your previous run completed all work successfully, but the output format was incorrect.",
-    "You do NOT need to redo any work — all changes are already in place.",
-    "",
-  ];
-  if (outputFormatInstruction !== "") {
-    parts.push(outputFormatInstruction, "");
-  }
-  parts.push(
-    "Please output ONLY the corrected YAML frontmatter block (--- delimited) followed by a brief summary of the work you completed.",
-  );
-  return parts.join("\n");
-}

packages/util-agent/src/index.ts

@@ -12,7 +12,6 @@ export {
 } from "./extract.js";
 export type { FrontmatterFastPathResult } from "./frontmatter.js";
 export { tryFrontmatterFastPath } from "./frontmatter.js";
-export { buildFrontmatterRetryPrompt } from "./frontmatter-retry-prompt.js";
 export { createAgent, parseArgv } from "./run.js";
 export { getCachedSessionId, getCachePath, setCachedSessionId } from "./session-cache.js";
 export { getConfigPath, getEnvPath, loadWorkflowConfig, resolveStorageRoot } from "./storage.js";

packages/util/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@united-workforce/util",
-  "version": "0.1.4",
+  "version": "0.1.3",
   "files": [
     "src",
     "dist",

workflows/solve-issue.yaml

@@ -0,0 +1,329 @@
+name: solve-issue
+description: TDD-driven issue resolution adapted for the workflow monorepo with bun + vitest
+roles:
+  planner:
+    description: Analyzes issue and outputs a TDD test spec
+    goal: You are a planning agent. You analyze Gitea issues and produce a TDD test specification that downstream roles will implement and verify.
+    capabilities:
+    - issue-analysis
+    - planning
+    procedure: 'On first run (no previous steps):
+
+      1. Read the issue and all comments from Gitea using `tea issues <number> -r <owner/repo>`
+
+      2. Look for project conventions files (CLAUDE.md, CONTRIBUTING.md) in the repo
+
+      3. Assess whether the issue has enough information to produce a test spec
+
+      4. If insufficient info: comment on the issue via `echo "..." | tea comment <number> -r <owner/repo>` (skip if you already commented), then output $status=insufficient_info
+
+      5. If sufficient: produce a detailed TDD test spec in markdown covering all scenarios
+
+
+      On subsequent runs (bounced back by tester with fix_spec):
+
+      1. Read the tester''s output from the previous step to understand what''s wrong with the spec
+
+      2. Revise the test spec accordingly
+
+
+      After producing the test spec:
+
+      1. The test spec is stored in CAS automatically by the uwf pipeline (agents do not need to call `ocas put` directly)
+
+      2. Put the hash in frontmatter.plan (required when $status=ready)
+
+      3. Set repoPath to the absolute path of the repository root
+
+
+
+      IMPORTANT: Extract the repo remote (owner/repo) from git:
+
+      ```bash
+
+      git remote get-url origin | sed ''s|.*[:/]\([^/]*/[^.]*\).*|\1|''
+
+      ```
+
+      Store the result as repoRemote in your frontmatter output so downstream roles can use it for tea/API calls.'
+    output: Output a brief summary of the test spec. Set $status to ready (with plan hash and repoPath) or insufficient_info.
+    frontmatter:
+      oneOf:
+      - properties:
+          $status:
+            const: ready
+          plan:
+            type: string
+          repoPath:
+            type: string
+          repoRemote:
+            type: string
+        required:
+        - $status
+        - plan
+        - repoPath
+      - properties:
+          $status:
+            const: insufficient_info
+          reason:
+            type: string
+        required:
+        - $status
+        - reason
+  developer:
+    description: TDD implementation per test spec
+    goal: You are a developer agent. You implement code changes following TDD — write tests first, then implementation.
+    capabilities:
+    - coding
+    procedure: "IMPORTANT: Always work in a git worktree, NEVER modify the main working directory directly.\nThe repo path and other details are provided in your task prompt.\n\nBefore starting any work,\
+      \ set up an isolated worktree:\n1. cd into the repo path provided in your task prompt\n2. `git fetch origin` to get latest refs\n3. First time (no existing branch):\n   - `git worktree add .worktrees/fix/<issue-number>-<short-slug>\
+      \ -b fix/<issue-number>-<short-slug> origin/main`\n   - `cd .worktrees/fix/<issue-number>-<short-slug> && bun install`\n4. If bounced back from reviewer or tester (branch already exists):\n   - cd\
+      \ into the existing worktree under `.worktrees/fix/<issue-number>-<short-slug>`\n   - `git fetch origin && git rebase origin/main`\n5. ALL subsequent work must happen inside the worktree directory.\n\
+      \nThen implement TDD:\n6. Read the test spec from CAS: `ocas get <plan hash>` (find the hash from the planner's output in your task prompt)\n7. If bounced back from reviewer or tester: read the\
+      \ previous role's feedback in your task prompt\n8. Write tests first based on the spec (use vitest)\n9. Implement the code to make tests pass\n10. Ensure `bun run build` passes with no errors\n11.\
+      \ Run `bun test` to verify all tests pass\n\nIf you cannot complete the implementation (e.g. the issue is too complex, blocked by external factors,\nor repeated attempts fail), set $status=failed\
+      \ with a reason.\n"
+    output: List all files changed and provide a summary. Set $status to done (with branch/worktree), or failed (with reason).
+    frontmatter:
+      oneOf:
+      - properties:
+          $status:
+            const: done
+          branch:
+            type: string
+          worktree:
+            type: string
+          repoRemote:
+            type: string
+        required:
+        - $status
+        - branch
+        - worktree
+      - properties:
+          $status:
+            const: failed
+          reason:
+            type: string
+          repoRemote:
+            type: string
+        required:
+        - $status
+        - reason
+  reviewer:
+    description: Code standards compliance check
+    goal: You are a code reviewer. You verify code standards compliance — NOT functionality (that's the tester's job).
+    capabilities:
+    - code-review
+    - static-analysis
+    procedure: 'The worktree path is provided in your task prompt. cd into it first.
+
+
+      Before reviewing, verify the git branch:
+
+      1. Run `git branch --show-current` — confirm the branch name references the issue number being worked on
+
+      2. If the branch doesn''t correspond to the issue, flag it in your output and reject
+
+
+      Then perform code review:
+
+      Hard checks (must all pass):
+
+      3. `bun run build` — no build errors
+
+      4. `bunx biome check` — no lint violations
+
+      5. TypeScript strict mode — no type errors
+
+
+      Soft checks (review against project conventions from CLAUDE.md):
+
+      - Functional-first: functions + types, no classes (except for errors or third-party requirements)
+
+      - Named exports only, no default exports
+
+      - No optional properties (use `T | null` instead of `?:`)
+
+      - Folder module discipline: index.ts only re-exports, types in types.ts
+
+      - Crockford Base32 log tags (8-char, unique per call site)
+
+      - No `console.log` in production code (use createLogger from @united-workforce/util)
+
+      - No dynamic imports in production code
+
+
+      Only review standards compliance. Do NOT test functionality.
+
+      If rejecting, you MUST explain the specific reason in your output.
+
+      '
+    output: Explain your decision with specific file/line references. Set $status to approved (with branch/worktree) or rejected (with comments).
+    frontmatter:
+      oneOf:
+      - properties:
+          $status:
+            const: approved
+          branch:
+            type: string
+          worktree:
+            type: string
+          repoRemote:
+            type: string
+        required:
+        - $status
+        - branch
+        - worktree
+      - properties:
+          $status:
+            const: rejected
+          comments:
+            type: string
+          worktree:
+            type: string
+          repoRemote:
+            type: string
+        required:
+        - $status
+        - comments
+        - worktree
+  tester:
+    description: Functional correctness verification
+    goal: You are a tester agent. You verify that the implementation correctly satisfies every scenario in the test spec.
+    capabilities:
+    - testing
+    procedure: "The worktree path is provided in your task prompt. cd into it first.\n\n1. Run `bun test` for automated test verification\n2. Read the test spec from CAS: `ocas get <plan hash>` (find\
+      \ the hash from the planner step in the thread history)\n3. Verify each scenario in the spec is covered and passing\n4. Determine outcome:\n   - passed: all scenarios verified, tests pass\n   - fix_code:\
+      \ tests fail or implementation doesn't match spec → send back to developer\n   - fix_spec: the spec itself is wrong or incomplete → send back to planner\n"
+    output: Report test results per scenario. Set $status to passed (with branch/worktree), fix_code (with report), or fix_spec (with report).
+    frontmatter:
+      oneOf:
+      - properties:
+          $status:
+            const: passed
+          branch:
+            type: string
+          worktree:
+            type: string
+          repoRemote:
+            type: string
+        required:
+        - $status
+        - branch
+        - worktree
+      - properties:
+          $status:
+            const: fix_code
+          report:
+            type: string
+          repoRemote:
+            type: string
+          worktree:
+            type: string
+          branch:
+            type: string
+        required:
+        - $status
+        - report
+      - properties:
+          $status:
+            const: fix_spec
+          report:
+            type: string
+          repoRemote:
+            type: string
+          worktree:
+            type: string
+          branch:
+            type: string
+        required:
+        - $status
+        - report
+  committer:
+    description: Commits and creates PR
+    goal: You are a committer agent. You create a clean commit and push a PR linking the original issue.
+    capabilities: []
+    procedure: "The worktree path, branch name, and repo remote (owner/repo) are provided in your task prompt.\ncd into the worktree first.\n\nNote: You inherit the developer's worktree and branch. Do NOT\
+      \ create a new branch.\n1. Stage all changes: `git add -A`\n2. Commit with a descriptive message referencing the issue: `git commit -m \"type: description\\n\\nFixes #N\"`\n3. Push the branch: `git\
+      \ push -u origin <branch-name>`\n4. **Verify push succeeded** — run `git ls-remote origin <branch-name>` and confirm it prints a commit hash.\n   - If no output or push failed: capture the error, mark hook_failed\n\
+      5. Create a PR using the Gitea API (do NOT use `tea pr create` — it fails in worktrees):\n   ```bash\n   GITEA_TOKEN=$(cfg get GITEA_TOKEN)\n   curl -s -X POST -H \"Authorization: token $GITEA_TOKEN\" -H \"Content-Type: application/json\" \\\n\
+      \     \"https://git.shazhou.work/api/v1/repos/<owner>/<repo>/pulls\" \\\n     -d '{\"title\":\"...\",\"body\":\"...\",\"head\":\"<branch>\",\"base\":\"main\"}'\n   ```\n   - The repo remote (owner/repo format, e.g. \"shazhou/united-workforce\") is given in your task prompt — use it directly.\n\
+      \   - PR body must include: What / Why / Changes / Ref sections, with `Fixes #N` in Ref\n6. **Verify PR was created** — parse the curl response JSON: it must contain a `\"number\"` field. Print the PR URL.\n\
+      \   - If curl returns an error or no number field: capture the response, mark hook_failed\n7. After PR creation, clean up the worktree:\n   - cd to the repo root (parent of .worktrees)\n   - `git worktree remove <worktree-path>`"
+    output: Include PR URL on success or error log on failure. Set $status to committed (with prUrl) or hook_failed (with error).
+    frontmatter:
+      oneOf:
+      - properties:
+          $status:
+            const: committed
+          prUrl:
+            type: string
+          repoRemote:
+            type: string
+          worktree:
+            type: string
+          branch:
+            type: string
+        required:
+        - $status
+        - prUrl
+      - properties:
+          $status:
+            const: hook_failed
+          error:
+            type: string
+          repoRemote:
+            type: string
+          worktree:
+            type: string
+          branch:
+            type: string
+        required:
+        - $status
+        - error
+graph:
+  $START:
+    new:
+      role: planner
+      prompt: Analyze the issue and produce an implementation plan.
+    resume:
+      role: planner
+      prompt: Review the previous run output and continue the work.
+  planner:
+    insufficient_info:
+      role: $SUSPEND
+      prompt: "信息不足，需要补充：{{{reason}}}"
+    ready:
+      role: developer
+      prompt: 'Implement the TDD test spec (CAS hash: {{{plan}}}) in repo {{{repoPath}}}. Repo remote: {{{repoRemote}}}.'
+  developer:
+    done:
+      role: reviewer
+      prompt: 'Review branch {{{branch}}} at {{{worktree}}} for code standards compliance. Repo remote: {{{repoRemote}}}.'
+    failed:
+      role: $END
+      prompt: 'Developer failed: {{{reason}}}. Ending workflow.'
+  reviewer:
+    rejected:
+      role: developer
+      prompt: 'Reviewer rejected: {{{comments}}}. Fix the issues in repo {{{worktree}}}. Repo remote: {{{repoRemote}}}.'
+    approved:
+      role: tester
+      prompt: 'Review passed. Run tests on branch {{{branch}}} at {{{worktree}}}. Repo remote: {{{repoRemote}}}.'
+  tester:
+    fix_code:
+      role: developer
+      prompt: 'Tests found code issues: {{{report}}}. Fix and re-submit. Worktree: {{{worktree}}}. Repo remote: {{{repoRemote}}}.'
+    fix_spec:
+      role: planner
+      prompt: 'Tests found spec issues: {{{report}}}. Revise the test spec. Repo remote: {{{repoRemote}}}.'
+    passed:
+      role: committer
+      prompt: 'All tests passed. Commit and push branch {{{branch}}} from {{{worktree}}}. Repo remote (owner/repo): {{{repoRemote}}}.'
+  committer:
+    hook_failed:
+      role: developer
+      prompt: 'Push hook failed: {{{error}}}. Fix and re-submit. Worktree: {{{worktree}}}. Repo remote: {{{repoRemote}}}.'
+    committed:
+      role: $END
+      prompt: 'PR created: {{{prUrl}}}. Workflow complete.'