improve: committer — check git status before staging (from retrospect PR #578)

Developer already commits changes, so committer's git add -A is redundant.
Now checks git status first and skips to push if tree is clean.

.gitea/workflows/ci.yml

@@ -18,8 +18,11 @@ jobs:
       - name: Install dependencies
         run: bun install
 
-      - name: Check
-        run: bun run check
+      - name: Lint
+        run: bun run lint
+
+      - name: Type check
+        run: bun run typecheck
 
       - name: Test
         run: bun test

.gitignore

@@ -12,5 +12,4 @@ packages/workflow-template-develop/develop.esm.js
 .DS_Store
 *.py
 .claude
-tmp.worktrees/
-.worktrees/
+tmp

.workflows/retrospect-workflow.yaml

@@ -0,0 +1,220 @@
+name: "retrospect-workflow"
+description: "Post-execution retrospective: analyze a completed thread, find inefficiencies, and improve the workflow definition."
+roles:
+  analyst:
+    description: "Scans thread execution for anomalies and produces a findings report"
+    goal: "You are a workflow execution analyst. You review completed thread data to find inefficiencies, wasted effort, and procedure gaps."
+    capabilities:
+      - data-analysis
+    procedure: |
+      You receive a completed thread ID in your task prompt.
+
+      Phase 0 — Validation (must pass before any analysis):
+      1. Run `uwf step list <thread-id>` to get thread metadata including the workflow hash
+      2. Run `uwf workflow show <workflow-hash>` to get the workflow name
+      3. Verify the workflow exists locally: check `.workflows/<name>.yaml` in the current repo
+         - If NOT found: output $status=wrong_project with the workflow name. Do NOT proceed.
+      4. Compare the thread's workflow hash against the current registered version:
+         - Run `uwf workflow show <name>` to get the current hash
+         - If hashes differ: the thread ran on an older version. Note this — you will need to diff versions after analysis.
+
+      Phase 1 — Overview scan:
+      5. From the step list, compute a health signal for each step:
+         - Duration: flag if >2x the median of other steps
+         - Output tokens: flag if >2x the median
+         - Status flow: flag non-happy-path transitions (rejected, fix_code, fix_spec, hook_failed)
+         - Step count: flag if the same role appears more than expected (indicates loops)
+      6. If no anomalies found AND versions match: output $status=clean
+      7. If no anomalies found BUT versions differ:
+         - Diff the two workflow versions to check if any procedure changes are relevant
+         - If the current version already addresses potential concerns: output $status=clean with a note
+         - Otherwise: proceed to Phase 2
+
+      Phase 2 — Targeted deep-dive (only for flagged steps):
+      8. For each flagged step, run `uwf step show <hash>` to get the detail with turns
+      9. Analyze the turn sequence for:
+         - Repeated tool calls with the same or similar input (blind retries)
+         - Tool errors followed by no strategy change (same approach retried)
+         - Unnecessary exploration (reading files or running commands unrelated to the task)
+         - Hallucinated commands or flags (commands that don't exist or wrong syntax)
+         - Excessive turns before reaching the goal
+      10. For each finding, record:
+          - Which role and step hash
+          - What happened (specific turn indices and commands)
+          - Root cause hypothesis (procedure gap, missing pitfall, unclear instruction)
+          - Suggested fix (what to add/change in the procedure)
+      11. If versions differ: compare findings against the version diff.
+          Mark any finding that is already fixed in the current version as "resolved_in_current".
+          Only report findings that are NOT yet addressed.
+
+      Output a structured findings report. Set $status=clean if nothing actionable, $status=findings if unresolved issues exist, or $status=wrong_project if the workflow doesn't belong here.
+    output: "A findings report with per-issue root cause and suggested procedure fixes. Set $status to clean or findings (with report hash)."
+    frontmatter:
+      oneOf:
+        - properties:
+            $status: { const: "clean" }
+            summary: { type: string }
+          required: [$status, summary]
+        - properties:
+            $status: { const: "findings" }
+            report: { type: string }
+            targetWorkflow: { type: string }
+          required: [$status, report, targetWorkflow]
+        - properties:
+            $status: { const: "wrong_project" }
+            workflowName: { type: string }
+          required: [$status, workflowName]
+  proposer:
+    description: "Translates findings into concrete workflow edits"
+    goal: "You are a workflow improvement proposer. You read the analyst's findings and produce specific, minimal edits to the workflow YAML."
+    capabilities:
+      - planning
+    procedure: |
+      1. Read the analyst's findings report from your task prompt
+      2. Locate the target workflow YAML:
+         - Workflow definitions live in the WORKFLOW ENGINE repo (where `uwf` is developed), NOT in the repo that was analyzed.
+         - Find it via: `uwf workflow show <targetWorkflow> --format yaml` to read the current definition
+         - The physical file is `.workflows/<targetWorkflow>.yaml` in the workflow engine repo
+         - Use `git rev-parse --show-toplevel` in the current directory to find the workflow engine repo root
+      3. Read the current workflow YAML to understand existing procedures
+      4. For each finding, draft a minimal edit:
+         - Prefer adding a pitfall note or clarifying instruction over restructuring
+         - If a procedure step is ambiguous, make it explicit
+         - If a tool usage pattern is wrong, add a "Do NOT" or "IMPORTANT" note
+         - Keep edits surgical — don't rewrite procedures that work fine
+      5. Check if existing tests need updating (search for test files referencing the workflow)
+      6. Produce a change plan as CAS text node via `uwf cas put-text "<plan>"`
+
+      The plan should list each edit with:
+      - File path
+      - What to change (old text → new text, or addition)
+      - Why (linked to which finding)
+      - Any test updates needed
+    output: "A change plan stored in CAS. Set $status to ready (with plan hash and repoPath) or no_action (if findings don't warrant changes)."
+    frontmatter:
+      oneOf:
+        - properties:
+            $status: { const: "ready" }
+            plan: { type: string }
+            repoPath: { type: string }
+          required: [$status, plan, repoPath]
+        - properties:
+            $status: { const: "no_action" }
+            reason: { type: string }
+          required: [$status, reason]
+  developer:
+    description: "Applies the proposed workflow edits"
+    goal: "You are a developer agent. You apply workflow YAML edits and update related tests."
+    capabilities:
+      - coding
+    procedure: |
+      IMPORTANT: Always work in a git worktree, NEVER modify the main working directory directly.
+      The workflow definitions live in THIS repo (the workflow engine), not the repo that was analyzed.
+
+      Before starting any work, set up an isolated worktree:
+      1. Use `git rev-parse --show-toplevel` to find the repo root (do NOT use repoPath from proposer — that's the analyzed repo)
+      2. `git fetch origin` to get latest refs
+      3. `git worktree add .worktrees/retrospect/<short-slug> -b retrospect/<short-slug> origin/main`
+      4. `cd .worktrees/retrospect/<short-slug> && bun install`
+      5. ALL subsequent work must happen inside the worktree directory.
+
+      Then apply changes:
+      6. Read the change plan from CAS: `uwf cas get <plan hash>`
+      7. Apply each edit from the plan to the workflow YAML
+      8. Update or add tests as specified in the plan
+      9. Run `bun run build` and `bun test` to verify
+      10. Run `bun run check` for lint
+      11. Commit with message: `improve: <workflow-name> — <brief summary>`
+    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 }
+          required: [$status, branch, worktree]
+        - properties:
+            $status: { const: "failed" }
+            reason: { type: string }
+          required: [$status, reason]
+  reviewer:
+    description: "Reviews the workflow edits for correctness"
+    goal: "You are a reviewer. You verify that workflow edits are minimal, correct, and actually address the findings."
+    capabilities:
+      - code-review
+    procedure: |
+      The worktree path is provided in your task prompt. cd into it first.
+
+      Review criteria:
+      1. Each edit must trace back to a specific finding — no drive-by changes
+      2. Edits should be minimal — don't rewrite working procedures
+      3. New pitfall notes or instructions must be clear and actionable
+      4. Tests must be updated if assertions changed
+      5. `bun run build` and `bun test` must pass
+      6. `bunx biome check` must pass
+
+      IMPORTANT: `tea pr create` must run from the MAIN repo directory (not a worktree), because tea cannot detect the repo from worktree `.git` files.
+    output: "Explain your decision. Set $status to approved (with branch/worktree) or rejected (with comments)."
+    frontmatter:
+      oneOf:
+        - properties:
+            $status: { const: "approved" }
+            branch: { type: string }
+            worktree: { type: string }
+          required: [$status, branch, worktree]
+        - properties:
+            $status: { const: "rejected" }
+            comments: { type: string }
+            worktree: { type: string }
+          required: [$status, comments, worktree]
+  committer:
+    description: "Commits and creates PR"
+    goal: "You are a committer agent. You create a clean commit and push a PR."
+    capabilities: []
+    procedure: |
+      The worktree path, branch name, and repo info 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. Stage all changes: `git add -A`
+      2. Commit with a descriptive message: `git commit -m "improve: <workflow> — <summary>"`
+      3. Push the branch: `git push -u origin <branch-name>`
+         - If push hook fails: capture the error log in your output, mark hook_failed
+      4. On push success: create a PR via `tea pr create --title "..." --description "..."`
+         - IMPORTANT: `tea pr create` must run from the MAIN repo directory (not a worktree), because tea cannot detect the repo from worktree `.git` files. cd to the repo root first.
+         - Do NOT pass `--repo` — let tea auto-detect from the main repo's git remote.
+         - PR description must include: What / Why / Findings / Changes sections
+         - On tea failure: capture stderr/stdout, include PR details for manual creation, mark hook_failed
+      5. 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 }
+          required: [$status, prUrl]
+        - properties:
+            $status: { const: "hook_failed" }
+            error: { type: string }
+          required: [$status, error]
+graph:
+  $START:
+    _: { role: "analyst", prompt: "Analyze completed thread {{{threadId}}} for execution anomalies." }
+  analyst:
+    clean: { role: "$END", prompt: "No issues found. Thread executed cleanly." }
+    findings: { role: "proposer", prompt: "Findings report: {{{report}}}. Target workflow: {{{targetWorkflow}}}. Propose minimal edits." }
+    wrong_project: { role: "$END", prompt: "Thread uses workflow '{{{workflowName}}}' which does not exist in this project. Run retrospect from the correct repo." }
+  proposer:
+    no_action: { role: "$END", prompt: "No actionable changes needed: {{{reason}}}." }
+    ready: { role: "developer", prompt: "Apply the change plan (CAS hash: {{{plan}}}) to the workflow definitions in this repo." }
+  developer:
+    done: { role: "reviewer", prompt: "Review workflow edits on branch {{{branch}}} at {{{worktree}}}." }
+    failed: { role: "$END", prompt: "Developer failed: {{{reason}}}. Ending workflow." }
+  reviewer:
+    rejected: { role: "developer", prompt: "Reviewer rejected: {{{comments}}}. Fix the issues in {{{worktree}}}." }
+    approved: { role: "committer", prompt: "Approved. Commit and push branch {{{branch}}} from {{{worktree}}}." }
+  committer:
+    hook_failed: { role: "developer", prompt: "Push hook failed: {{{error}}}. Fix and re-submit." }
+    committed: { role: "$END", prompt: "PR created: {{{prUrl}}}. Workflow improved." }

.workflows/solve-issue.yaml

@@ -155,12 +155,13 @@ roles:
       cd into the worktree first.
 
       Note: You inherit the developer's worktree and branch. Do NOT create a new branch.
-      1. Stage all changes: `git add -A`
-      2. Commit with a descriptive message referencing the issue: `git commit -m "type: description\n\nFixes #N"`
+      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>`
          - If push hook fails: capture the error log in your output, mark hook_failed
-      4. On push success: create a PR via `tea pr create --repo <owner/repo> --title "..." --description "..."`
-         - Extract owner/repo from: `git remote get-url origin | sed 's/.*[:/]\([^/]*\/[^.]*\).*/\1/'`
+      4. On push success: create a PR via `tea pr create --title "..." --description "..."`
+         - IMPORTANT: `tea pr create` must run from the MAIN repo directory (not a worktree), because tea cannot detect the repo from worktree `.git` files. cd to the repo root first.
+         - Do NOT pass `--repo` — let tea auto-detect from the main repo's git remote.
          - PR description must include: What / Why / Changes / Ref sections, with `Fixes #N` in Ref
          - On tea failure: capture stderr/stdout, include PR details for manual creation, mark hook_failed
       5. After PR creation, clean up the worktree:

biome.json

@@ -4,7 +4,6 @@
     "includes": [
       "**",
       "!**/dist",
-      "!.worktrees",
       "!**/node_modules",
       "!**/legacy-packages",
       "!scripts",

docs/architecture.md

@@ -391,7 +391,7 @@ Everything else is immutable CAS content.
 providers:
   openrouter:
     baseUrl: "https://openrouter.ai/api/v1"
-    apiKey: "sk-..."
+    apiKeyEnv: "OPENROUTER_API_KEY"
 
 models:
   sonnet:

docs/builtin-agent-research.md

@@ -402,7 +402,7 @@ workflow 怎么配置和使用 model？
 ```136:160:packages/workflow-protocol/src/types.ts
 export type ProviderConfig = {
   baseUrl: string;
-  apiKey: string;
+  apiKeyEnv: string;
 };
 
 export type ModelConfig = {
@@ -429,7 +429,7 @@ export type WorkflowConfig = {
 export function resolveModel(config: WorkflowConfig, alias: ModelAlias): ResolvedLlmProvider {
   const modelEntry = config.models[alias];
   const providerEntry = config.providers[modelEntry.provider];
-  const apiKey = providerEntry.apiKey;
+  const apiKey = process.env[providerEntry.apiKeyEnv];
   return { baseUrl: providerEntry.baseUrl, apiKey, model: modelEntry.name };
 }
 ```

docs/wf-stateless-design.md

@@ -280,13 +280,13 @@ threads.yaml: { "01J7K9M2XNPQR5VWBCDF8G3H4T": "8FWKR3TN5V1QA" }
 providers:
   openai:
     baseUrl: "https://api.openai.com/v1"
-    apiKey: "sk-..."
+    apiKeyEnv: "OPENAI_API_KEY"
   anthropic:
     baseUrl: "https://api.anthropic.com/v1"
-    apiKey: "sk-ant-..."
+    apiKeyEnv: "ANTHROPIC_API_KEY"
   openrouter:
     baseUrl: "https://openrouter.ai/api/v1"
-    apiKey: "sk-or-..."
+    apiKeyEnv: "OPENROUTER_API_KEY"
 
 models:
   sonnet:
@@ -465,7 +465,7 @@ type Scenario = string;              // e.g. "extract"
 
 type ProviderConfig = {
   baseUrl: string;
-  apiKey: string;                    // API key stored directly
+  apiKeyEnv: string;                 // env var name to read API key from
 };
 
 type ModelConfig = {

packages/cli-workflow/README.md

@@ -119,7 +119,7 @@ uwf setup --provider openai --base-url https://api.openai.com/v1 \
   --api-key sk-... --model gpt-4o --agent hermes
 ```
 
-Config: `~/.uncaged/workflow/config.yaml` (includes API keys).
+Config: `~/.uncaged/workflow/config.yaml`. API keys: `~/.uncaged/workflow/.env`.
 
 ### Skill
 

packages/cli-workflow/package.json

@@ -8,7 +8,7 @@
   ],
   "type": "module",
   "bin": {
-    "uwf": "./dist/cli.js"
+    "uwf": "./src/cli.ts"
   },
   "dependencies": {
     "@uncaged/json-cas": "^0.5.3",

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

@@ -1,622 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, test } from "vitest";
-import {
-  cmdConfigGet,
-  cmdConfigList,
-  cmdConfigSet,
-  getConfigPath,
-  getNestedValue,
-  maskApiKeys,
-  parseDotPath,
-  setNestedValue,
-} from "../commands/config.js";
-
-describe("config command", () => {
-  // Helper function to create a test config
-  function createTestConfig(tempDir: string, content: string): string {
-    const configPath = getConfigPath(tempDir);
-    writeFileSync(configPath, content, "utf8");
-    return configPath;
-  }
-
-  // Sample test config
-  const sampleConfig = `providers:
-  dashscope:
-    baseUrl: https://dashscope.aliyuncs.com/compatible-mode/v1
-    apiKey: sk-test-dashscope-key
-  openai:
-    baseUrl: https://api.openai.com/v1
-    apiKey: sk-test-openai-key
-models:
-  default:
-    provider: dashscope
-    name: qwen-max
-  gpt4:
-    provider: openai
-    name: gpt-4
-agents:
-  hermes:
-    command: uwf-hermes
-    args:
-      - --provider
-      - dashscope
-  claude-code:
-    command: claude-code
-    args:
-      - --profile
-      - work
-defaultAgent: hermes
-defaultModel: default
-`;
-
-  describe("helper functions", () => {
-    describe("parseDotPath", () => {
-      test("splits dot notation correctly", () => {
-        expect(parseDotPath("a.b.c")).toEqual(["a", "b", "c"]);
-        expect(parseDotPath("defaultAgent")).toEqual(["defaultAgent"]);
-        expect(parseDotPath("providers.dashscope.baseUrl")).toEqual([
-          "providers",
-          "dashscope",
-          "baseUrl",
-        ]);
-      });
-    });
-
-    describe("getNestedValue", () => {
-      test("traverses nested objects", () => {
-        const obj = {
-          a: { b: { c: "value" } },
-          x: "simple",
-        };
-        expect(getNestedValue(obj, ["a", "b", "c"])).toBe("value");
-        expect(getNestedValue(obj, ["x"])).toBe("simple");
-      });
-
-      test("returns undefined for non-existent paths", () => {
-        const obj = { a: { b: "value" } };
-        expect(getNestedValue(obj, ["a", "c"])).toBeUndefined();
-        expect(getNestedValue(obj, ["x", "y"])).toBeUndefined();
-      });
-    });
-
-    describe("setNestedValue", () => {
-      test("creates intermediate objects and sets value", () => {
-        const obj: Record<string, unknown> = {};
-        setNestedValue(obj, ["a", "b", "c"], "value");
-        expect(obj).toEqual({ a: { b: { c: "value" } } });
-      });
-
-      test("preserves existing values", () => {
-        const obj: Record<string, unknown> = { a: { x: "keep" } };
-        setNestedValue(obj, ["a", "b"], "new");
-        expect(obj).toEqual({ a: { x: "keep", b: "new" } });
-      });
-
-      test("overwrites existing value at path", () => {
-        const obj: Record<string, unknown> = { a: { b: "old" } };
-        setNestedValue(obj, ["a", "b"], "new");
-        expect(obj).toEqual({ a: { b: "new" } });
-      });
-    });
-
-    describe("maskApiKeys", () => {
-      test("deep clones and masks all apiKey values in providers", () => {
-        const config = {
-          providers: {
-            dashscope: {
-              baseUrl: "https://example.com",
-              apiKey: "sk-test-key-12345",
-            },
-            openai: {
-              baseUrl: "https://api.openai.com",
-              apiKey: "sk-another-secret",
-            },
-          },
-          models: {
-            default: { provider: "dashscope" },
-          },
-        };
-        const masked = maskApiKeys(config);
-        expect(masked).toEqual({
-          providers: {
-            dashscope: {
-              baseUrl: "https://example.com",
-              apiKey: "***MASKED***",
-            },
-            openai: {
-              baseUrl: "https://api.openai.com",
-              apiKey: "***MASKED***",
-            },
-          },
-          models: {
-            default: { provider: "dashscope" },
-          },
-        });
-        // Ensure it's a deep clone
-        expect(masked).not.toBe(config);
-      });
-
-      test("handles config without providers", () => {
-        const config = { models: { default: { provider: "test" } } };
-        const masked = maskApiKeys(config);
-        expect(masked).toEqual(config);
-      });
-    });
-  });
-
-  describe("cmdConfigList", () => {
-    test("returns full config when file exists", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigList(tempDir);
-        expect(result).toBeDefined();
-        expect(typeof result).toBe("object");
-        expect(result).toHaveProperty("providers");
-        expect(result).toHaveProperty("models");
-        expect(result).toHaveProperty("agents");
-        expect(result).toHaveProperty("defaultAgent");
-        expect(result).toHaveProperty("defaultModel");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("masks all apiKey values in providers section", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = (await cmdConfigList(tempDir)) as Record<string, unknown>;
-        const providers = result.providers as Record<string, unknown>;
-        const dashscope = providers.dashscope as Record<string, unknown>;
-        const openai = providers.openai as Record<string, unknown>;
-        expect(dashscope.apiKey).toBe("***MASKED***");
-        expect(openai.apiKey).toBe("***MASKED***");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("throws error when config file doesn't exist", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        await expect(cmdConfigList(tempDir)).rejects.toThrow();
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("returns empty object when config file is empty", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, "");
-        const result = await cmdConfigList(tempDir);
-        expect(result).toEqual({});
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("throws error when config file is invalid YAML", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, "invalid: yaml: [broken");
-        await expect(cmdConfigList(tempDir)).rejects.toThrow();
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-  });
-
-  describe("cmdConfigGet", () => {
-    test("retrieves top-level string value (defaultAgent)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigGet(tempDir, "defaultAgent");
-        expect(result).toBe("hermes");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("retrieves top-level string value (defaultModel)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigGet(tempDir, "defaultModel");
-        expect(result).toBe("default");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("retrieves nested object (providers.dashscope)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigGet(tempDir, "providers.dashscope");
-        expect(result).toEqual({
-          baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
-          apiKey: "sk-test-dashscope-key",
-        });
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("retrieves deeply nested string (providers.dashscope.baseUrl)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigGet(tempDir, "providers.dashscope.baseUrl");
-        expect(result).toBe("https://dashscope.aliyuncs.com/compatible-mode/v1");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("retrieves nested string in models (models.default.provider)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigGet(tempDir, "models.default.provider");
-        expect(result).toBe("dashscope");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("retrieves array value (agents.hermes.args)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigGet(tempDir, "agents.hermes.args");
-        expect(result).toEqual(["--provider", "dashscope"]);
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("throws error when key doesn't exist", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigGet(tempDir, "nonexistent.key")).rejects.toThrow(/Key not found/);
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("throws error when config file doesn't exist", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        await expect(cmdConfigGet(tempDir, "defaultAgent")).rejects.toThrow();
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("throws error when accessing property on non-object", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigGet(tempDir, "defaultAgent.foo")).rejects.toThrow();
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-  });
-
-  describe("cmdConfigSet", () => {
-    test("sets top-level string value (defaultAgent)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigSet(tempDir, "defaultAgent", "claude-code");
-        expect(result).toEqual({ key: "defaultAgent", value: "claude-code" });
-        // Verify it was written
-        const updated = await cmdConfigGet(tempDir, "defaultAgent");
-        expect(updated).toBe("claude-code");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("sets nested string value (providers.dashscope.baseUrl)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const newUrl = "https://new-api.example.com/v1";
-        const result = await cmdConfigSet(tempDir, "providers.dashscope.baseUrl", newUrl);
-        expect(result).toEqual({
-          key: "providers.dashscope.baseUrl",
-          value: newUrl,
-        });
-        // Verify it was written
-        const updated = await cmdConfigGet(tempDir, "providers.dashscope.baseUrl");
-        expect(updated).toBe(newUrl);
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("creates new nested path (providers.newprovider.baseUrl)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const newUrl = "https://new-provider.com/v1";
-        const result = await cmdConfigSet(tempDir, "providers.newprovider.baseUrl", newUrl);
-        expect(result).toEqual({
-          key: "providers.newprovider.baseUrl",
-          value: newUrl,
-        });
-        // Verify it was created
-        const updated = await cmdConfigGet(tempDir, "providers.newprovider.baseUrl");
-        expect(updated).toBe(newUrl);
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("sets array value for args key with valid JSON array", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const newArgs = '["--new", "--flags"]';
-        const result = await cmdConfigSet(tempDir, "agents.hermes.args", newArgs);
-        expect(result).toEqual({
-          key: "agents.hermes.args",
-          value: ["--new", "--flags"],
-        });
-        // Verify it was written
-        const updated = await cmdConfigGet(tempDir, "agents.hermes.args");
-        expect(updated).toEqual(["--new", "--flags"]);
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("preserves existing config values when updating one key", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await cmdConfigSet(tempDir, "defaultAgent", "claude-code");
-        // Verify other values are preserved
-        const defaultModel = await cmdConfigGet(tempDir, "defaultModel");
-        expect(defaultModel).toBe("default");
-        const dashscopeUrl = await cmdConfigGet(tempDir, "providers.dashscope.baseUrl");
-        expect(dashscopeUrl).toBe("https://dashscope.aliyuncs.com/compatible-mode/v1");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("creates config file if it doesn't exist", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        const result = await cmdConfigSet(tempDir, "defaultAgent", "hermes");
-        expect(result).toEqual({ key: "defaultAgent", value: "hermes" });
-        // Verify file was created
-        const configPath = getConfigPath(tempDir);
-        const content = readFileSync(configPath, "utf8");
-        expect(content).toContain("defaultAgent: hermes");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("throws error when setting property on non-object", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigSet(tempDir, "defaultAgent.foo", "bar")).rejects.toThrow();
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("throws error when array value is invalid JSON for args key", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(
-          cmdConfigSet(tempDir, "agents.hermes.args", "[invalid json"),
-        ).rejects.toThrow();
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("sets deeply nested model config (models.gpt4.provider)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigSet(tempDir, "models.gpt4.provider", "new-provider");
-        expect(result).toEqual({
-          key: "models.gpt4.provider",
-          value: "new-provider",
-        });
-        // Verify it was written
-        const updated = await cmdConfigGet(tempDir, "models.gpt4.provider");
-        expect(updated).toBe("new-provider");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("sets agent command (agents.claude-code.command)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        const result = await cmdConfigSet(tempDir, "agents.claude-code.command", "new-command");
-        expect(result).toEqual({
-          key: "agents.claude-code.command",
-          value: "new-command",
-        });
-        // Verify it was written
-        const updated = await cmdConfigGet(tempDir, "agents.claude-code.command");
-        expect(updated).toBe("new-command");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-  });
-
-  describe("cmdConfigSet validation", () => {
-    test("rejects unknown top-level key", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigSet(tempDir, "unknownKey", "value")).rejects.toThrow(
-          /Unknown config key.*unknownKey/,
-        );
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("rejects unknown nested key in providers", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(
-          cmdConfigSet(tempDir, "providers.myProvider.unknownField", "value"),
-        ).rejects.toThrow(/Unknown field.*unknownField.*providers/);
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("rejects unknown nested key in models", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigSet(tempDir, "models.default.invalidField", "value")).rejects.toThrow(
-          /Unknown field.*invalidField.*models/,
-        );
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("rejects unknown nested key in agents", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigSet(tempDir, "agents.hermes.badField", "value")).rejects.toThrow(
-          /Unknown field.*badField.*agents/,
-        );
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("rejects nested path on scalar key (defaultAgent)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigSet(tempDir, "defaultAgent.foo", "value")).rejects.toThrow(
-          /defaultAgent.*scalar|Cannot set property/i,
-        );
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("rejects nested path on scalar key (defaultModel)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigSet(tempDir, "defaultModel.bar", "value")).rejects.toThrow(
-          /defaultModel.*scalar|Cannot set property/i,
-        );
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("rejects incomplete nested path (providers without field)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigSet(tempDir, "providers.myProvider", "value")).rejects.toThrow(
-          /incomplete path|must specify a field/i,
-        );
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("rejects incomplete nested path (models without field)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigSet(tempDir, "models.myModel", "value")).rejects.toThrow(
-          /incomplete path|must specify a field/i,
-        );
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("rejects incomplete nested path (agents without field)", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await expect(cmdConfigSet(tempDir, "agents.myAgent", "value")).rejects.toThrow(
-          /incomplete path|must specify a field/i,
-        );
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("allows valid nested keys in providers", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await cmdConfigSet(tempDir, "providers.newprovider.baseUrl", "https://example.com");
-        await cmdConfigSet(tempDir, "providers.newprovider.apiKey", "sk-test");
-        const baseUrl = await cmdConfigGet(tempDir, "providers.newprovider.baseUrl");
-        const apiKey = await cmdConfigGet(tempDir, "providers.newprovider.apiKey");
-        expect(baseUrl).toBe("https://example.com");
-        expect(apiKey).toBe("sk-test");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("allows valid nested keys in models", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await cmdConfigSet(tempDir, "models.gpt4.provider", "openai");
-        await cmdConfigSet(tempDir, "models.gpt4.name", "gpt-4o");
-        const provider = await cmdConfigGet(tempDir, "models.gpt4.provider");
-        const name = await cmdConfigGet(tempDir, "models.gpt4.name");
-        expect(provider).toBe("openai");
-        expect(name).toBe("gpt-4o");
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-
-    test("allows valid nested keys in agents", async () => {
-      const tempDir = mkdtempSync(join(tmpdir(), "test-config-"));
-      try {
-        createTestConfig(tempDir, sampleConfig);
-        await cmdConfigSet(tempDir, "agents.hermes.command", "uwf-hermes");
-        await cmdConfigSet(tempDir, "agents.hermes.args", '["--flag"]');
-        const command = await cmdConfigGet(tempDir, "agents.hermes.command");
-        const args = await cmdConfigGet(tempDir, "agents.hermes.args");
-        expect(command).toBe("uwf-hermes");
-        expect(args).toEqual(["--flag"]);
-      } finally {
-        rmSync(tempDir, { recursive: true, force: true });
-      }
-    });
-  });
-});

packages/cli-workflow/src/__tests__/resolve-head-hash.test.ts

@@ -40,7 +40,6 @@ describe("resolveHeadHash", () => {
       workflow: workflowHash,
       head: headHash,
       completedAt: Date.now(),
-      reason: null,
     });
 
     const result = await resolveHeadHash(tmpDir, threadId);
@@ -65,7 +64,6 @@ describe("resolveHeadHash", () => {
       workflow: workflowHash,
       head: historicalHash,
       completedAt: Date.now(),
-      reason: null,
     });
 
     const result = await resolveHeadHash(tmpDir, threadId);
@@ -89,21 +87,18 @@ describe("resolveHeadHash", () => {
       workflow: workflowHash,
       head: hash1,
       completedAt: Date.now() - 2000,
-      reason: null,
     });
     await appendThreadHistory(tmpDir, {
       thread: threadId2,
       workflow: workflowHash,
       head: hash2,
       completedAt: Date.now() - 1000,
-      reason: null,
     });
     await appendThreadHistory(tmpDir, {
       thread: threadId3,
       workflow: workflowHash,
       head: hash3,
       completedAt: Date.now(),
-      reason: null,
     });
 
     const result = await resolveHeadHash(tmpDir, threadId2);

packages/cli-workflow/src/__tests__/setup-agent-discovery.test.ts

@@ -134,34 +134,4 @@ describe("cmdSetup agent configuration", () => {
     const config2 = parse(readFileSync(join(storageRoot, "config.yaml"), "utf8"));
     expect(config2.defaultAgent).toBe("builtin");
   });
-
-  test("normalizes agent name with uwf- prefix to bare name", async () => {
-    vi.spyOn(globalThis, "fetch").mockResolvedValue(
-      new Response(JSON.stringify({}), { status: 200 }),
-    );
-
-    const result = await cmdSetup({ ...baseArgs(), agent: "uwf-hermes" });
-
-    expect(result.defaultAgent).toBe("hermes");
-    const config = parse(readFileSync(join(storageRoot, "config.yaml"), "utf8"));
-    expect(config.agents.hermes).toEqual({ command: "uwf-hermes", args: [] });
-    expect(config.defaultAgent).toBe("hermes");
-    // Verify no duplicate uwf- prefix
-    expect(config.agents["uwf-hermes"]).toBeUndefined();
-  });
-
-  test("normalizes uwf-claude-code to claude-code", async () => {
-    vi.spyOn(globalThis, "fetch").mockResolvedValue(
-      new Response(JSON.stringify({}), { status: 200 }),
-    );
-
-    const result = await cmdSetup({ ...baseArgs(), agent: "uwf-claude-code" });
-
-    expect(result.defaultAgent).toBe("claude-code");
-    const config = parse(readFileSync(join(storageRoot, "config.yaml"), "utf8"));
-    expect(config.agents["claude-code"]).toEqual({ command: "uwf-claude-code", args: [] });
-    expect(config.defaultAgent).toBe("claude-code");
-    // Verify no duplicate uwf- prefix
-    expect(config.agents["uwf-claude-code"]).toBeUndefined();
-  });
 });

packages/cli-workflow/src/__tests__/setup-validate.test.ts

@@ -129,8 +129,9 @@ describe("cmdSetup with validation", () => {
     const result = await cmdSetup(setupArgs());
 
     expect(result.validation).toEqual({ ok: true, value: undefined });
-    // Config file should still be written
+    // Config files should still be written
     expect(result.configPath).toBeTruthy();
+    expect(result.envPath).toBeTruthy();
   });
 
   test("includes validation failure — config still saved", async () => {
@@ -142,7 +143,8 @@ describe("cmdSetup with validation", () => {
 
     expect(result.validation).toBeDefined();
     expect((result.validation as { ok: boolean }).ok).toBe(false);
-    // Config file should still be written despite validation failure
+    // Config files should still be written despite validation failure
     expect(result.configPath).toBeTruthy();
+    expect(result.envPath).toBeTruthy();
   });
 });

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

@@ -24,7 +24,7 @@ describe("solve-issue workflow: tea pr create worktree fix", () => {
     "solve-issue.yaml",
   );
 
-  test("committer procedure should include --repo flag in tea pr create command", async () => {
+  test("committer procedure should require running tea pr create from main repo directory", async () => {
     const yamlContent = await readFile(workflowPath, "utf-8");
     const workflow = parse(yamlContent) as WorkflowPayload;
 
@@ -32,19 +32,12 @@ describe("solve-issue workflow: tea pr create worktree fix", () => {
     const committerProcedure = workflow.roles.committer?.procedure;
     expect(committerProcedure).toBeDefined();
 
-    // Verify the procedure includes tea pr create with --repo flag
+    // Verify the procedure includes tea pr create
     expect(committerProcedure).toContain("tea pr create");
-    expect(committerProcedure).toContain("--repo");
 
-    // Verify the --repo flag appears before or together with tea pr create
-    // This ensures the command is: tea pr create --repo <owner/repo> ...
-    const teaPrCreateMatch = committerProcedure?.match(/tea pr create[^\n]*/);
-    expect(teaPrCreateMatch).not.toBeNull();
-
-    if (teaPrCreateMatch) {
-      const teaCommandLine = teaPrCreateMatch[0];
-      expect(teaCommandLine).toContain("--repo");
-    }
+    // Verify the procedure warns about running from main repo dir (not worktree)
+    expect(committerProcedure).toMatch(/main repo directory/i);
+    expect(committerProcedure).toMatch(/not a worktree/i);
   });
 
   test("committer procedure should mention repo extraction from git remote", async () => {

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

@@ -1,85 +0,0 @@
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { CasRef, ThreadId } from "@uncaged/workflow-protocol";
-import { describe, expect, test } from "vitest";
-import { appendThreadHistory, loadThreadHistory } from "../store.js";
-
-describe("thread cancel status", () => {
-  test("cancelled history entry has reason 'cancelled'", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
-    const threadId = "01JTEST000000000000CANCEL1" as ThreadId;
-
-    await appendThreadHistory(tmpDir, {
-      thread: threadId,
-      workflow: "test-workflow",
-      head: "test-head-hash" as CasRef,
-      completedAt: Date.now(),
-      reason: "cancelled",
-    });
-
-    const history = await loadThreadHistory(tmpDir);
-    expect(history).toHaveLength(1);
-    expect(history[0]?.reason).toBe("cancelled");
-  });
-
-  test("completed history entry has reason 'completed'", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
-    const threadId = "01JTEST000000000000CANCEL2" as ThreadId;
-
-    await appendThreadHistory(tmpDir, {
-      thread: threadId,
-      workflow: "test-workflow",
-      head: "test-head-hash" as CasRef,
-      completedAt: Date.now(),
-      reason: "completed",
-    });
-
-    const history = await loadThreadHistory(tmpDir);
-    expect(history).toHaveLength(1);
-    expect(history[0]?.reason).toBe("completed");
-  });
-
-  test("legacy history entry without reason parses as null", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
-    const threadId = "01JTEST000000000000CANCEL3" as ThreadId;
-
-    // Simulate legacy entry without reason field
-    await appendThreadHistory(tmpDir, {
-      thread: threadId,
-      workflow: "test-workflow",
-      head: "test-head-hash" as CasRef,
-      completedAt: Date.now(),
-      reason: null,
-    });
-
-    const history = await loadThreadHistory(tmpDir);
-    expect(history).toHaveLength(1);
-    expect(history[0]?.reason).toBeNull();
-  });
-
-  test("mixed completed and cancelled entries preserve distinct reasons", async () => {
-    const tmpDir = await mkdtemp(join(tmpdir(), "uwf-cancel-test-"));
-
-    await appendThreadHistory(tmpDir, {
-      thread: "01JTEST000000000000CANCEL4" as ThreadId,
-      workflow: "test-workflow",
-      head: "head1" as CasRef,
-      completedAt: Date.now(),
-      reason: "completed",
-    });
-
-    await appendThreadHistory(tmpDir, {
-      thread: "01JTEST000000000000CANCEL5" as ThreadId,
-      workflow: "test-workflow",
-      head: "head2" as CasRef,
-      completedAt: Date.now(),
-      reason: "cancelled",
-    });
-
-    const history = await loadThreadHistory(tmpDir);
-    expect(history).toHaveLength(2);
-    expect(history[0]?.reason).toBe("completed");
-    expect(history[1]?.reason).toBe("cancelled");
-  });
-});

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

@@ -74,7 +74,6 @@ async function completeThread(
     workflow: workflowHash,
     head: headHash,
     completedAt: Date.now(),
-    reason: null,
   });
 }
 

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

@@ -758,7 +758,6 @@ describe("cmdStepList with completed threads", () => {
       workflow: workflowHash,
       head: step2Hash,
       completedAt: Date.now(),
-      reason: null,
     });
 
     const result = await cmdStepList(tmpDir, threadId);
@@ -887,7 +886,6 @@ describe("cmdStepShow with completed threads", () => {
       workflow: workflowHash,
       head: stepHash,
       completedAt: Date.now(),
-      reason: null,
     });
 
     const result = await cmdStepShow(tmpDir, stepHash);
@@ -951,7 +949,6 @@ describe("cmdThreadRead with completed threads", () => {
       workflow: workflowHash,
       head: stepHash,
       completedAt: Date.now(),
-      reason: null,
     });
 
     const markdown = await cmdThreadRead(tmpDir, threadId, THREAD_READ_DEFAULT_QUOTA, null, false);
@@ -1014,7 +1011,6 @@ describe("cmdThreadRead with completed threads", () => {
       workflow: workflowHash,
       head: step3Hash,
       completedAt: Date.now(),
-      reason: null,
     });
 
     const markdown = await cmdThreadRead(

packages/cli-workflow/src/cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 import type { CasRef, ThreadId } from "@uncaged/workflow-protocol";
 import { Command } from "commander";
@@ -13,7 +13,6 @@ import {
   cmdCasSchemaList,
   cmdCasWalk,
 } from "./commands/cas.js";
-import { cmdConfigGet, cmdConfigList, cmdConfigSet } from "./commands/config.js";
 import { cmdLogClean, cmdLogList, cmdLogShow } from "./commands/log.js";
 import { cmdSetup, cmdSetupInteractive } from "./commands/setup.js";
 import {
@@ -182,11 +181,11 @@ function parseStatusFilter(status: string | undefined): ThreadStatus[] | null {
   if (raw === "active") return ["idle", "running"];
 
   const parts = raw.split(",").map((s) => s.trim());
-  const validStatuses: ThreadStatus[] = ["idle", "running", "completed", "cancelled"];
+  const validStatuses: ThreadStatus[] = ["idle", "running", "completed"];
   for (const part of parts) {
     if (!validStatuses.includes(part as ThreadStatus)) {
       process.stderr.write(
-        `Invalid status: ${part}. Must be one of: idle, running, completed, cancelled, active\n`,
+        `Invalid status: ${part}. Must be one of: idle, running, completed, active\n`,
       );
       process.exit(1);
     }
@@ -239,7 +238,7 @@ thread
   .description("List threads")
   .option(
     "--status <status>",
-    "Filter by status: idle, running, completed, cancelled, active (idle+running), or comma-separated values",
+    "Filter by status: idle, running, completed, active (idle+running), or comma-separated values",
   )
   .option("--after <date>", "Filter threads created after this date (ISO or relative like '7d')")
   .option("--before <date>", "Filter threads created before this date (ISO or relative like '7d')")
@@ -712,47 +711,6 @@ log
     });
   });
 
-const config = program.command("config").description("Configuration management");
-
-config
-  .command("list")
-  .description("Display all configuration values (masks API keys)")
-  .action(() => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const result = await cmdConfigList(storageRoot);
-      writeOutput(result);
-    });
-  });
-
-config
-  .command("get")
-  .description("Get a specific configuration value")
-  .argument(
-    "<key>",
-    "Dot-notation path to config value (e.g., defaultAgent, providers.dashscope.baseUrl)",
-  )
-  .action((key: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const result = await cmdConfigGet(storageRoot, key);
-      writeOutput({ value: result });
-    });
-  });
-
-config
-  .command("set")
-  .description("Set a specific configuration value")
-  .argument("<key>", "Dot-notation path to config value")
-  .argument("<value>", "New value (use JSON array for 'args' key, e.g., '[\"--flag\"]')")
-  .action((key: string, value: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const result = await cmdConfigSet(storageRoot, key, value);
-      writeOutput(result);
-    });
-  });
-
 program.parseAsync(process.argv).catch((e: unknown) => {
   const message = e instanceof Error ? e.message : String(e);
   process.stderr.write(`${message}\n`);

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

@@ -1,289 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { parse, stringify } from "yaml";
-
-/**
- * Valid configuration key schema
- */
-const VALID_CONFIG_KEYS: Record<string, { nested: boolean; knownFields?: string[] }> = {
-  providers: {
-    nested: true,
-    knownFields: ["baseUrl", "apiKey"],
-  },
-  models: {
-    nested: true,
-    knownFields: ["provider", "name"],
-  },
-  agents: {
-    nested: true,
-    knownFields: ["command", "args"],
-  },
-  defaultAgent: { nested: false },
-  defaultModel: { nested: false },
-};
-
-/**
- * Validate a config key path against the known schema
- */
-function validateConfigKey(path: string[]): void {
-  if (path.length === 0) {
-    throw new Error("Path cannot be empty");
-  }
-
-  const topLevel = path[0];
-  const schema = VALID_CONFIG_KEYS[topLevel];
-
-  if (!schema) {
-    const validKeys = Object.keys(VALID_CONFIG_KEYS).join(", ");
-    throw new Error(`Unknown config key: ${topLevel}. Valid top-level keys are: ${validKeys}`);
-  }
-
-  // Scalar keys cannot have nested paths
-  if (!schema.nested && path.length > 1) {
-    throw new Error(`${topLevel} is a scalar key and cannot have nested properties`);
-  }
-
-  // Nested keys must have at least 3 segments (e.g., providers.myProvider.baseUrl)
-  if (schema.nested && path.length < 3) {
-    const fields = schema.knownFields?.join(", ") ?? "";
-    throw new Error(
-      `Incomplete path for ${topLevel}. Must specify a field (e.g., ${topLevel}.<name>.<field>). Valid fields: ${fields}`,
-    );
-  }
-
-  // Validate the field name for nested keys
-  if (schema.nested && path.length >= 3 && schema.knownFields) {
-    const field = path[path.length - 1];
-    if (!schema.knownFields.includes(field)) {
-      throw new Error(
-        `Unknown field '${field}' in ${topLevel}. Valid fields are: ${schema.knownFields.join(", ")}`,
-      );
-    }
-  }
-}
-
-/**
- * Returns the path to the config.yaml file
- */
-export function getConfigPath(storageRoot: string): string {
-  return join(storageRoot, "config.yaml");
-}
-
-/**
- * Load and parse YAML config file
- */
-export function loadConfig(configPath: string): Record<string, unknown> {
-  if (!existsSync(configPath)) {
-    throw new Error(`Config file not found: ${configPath}`);
-  }
-  const content = readFileSync(configPath, "utf8");
-  if (!content.trim()) {
-    return {};
-  }
-  try {
-    const parsed = parse(content);
-    return (parsed ?? {}) as Record<string, unknown>;
-  } catch (error) {
-    throw new Error(
-      `Invalid YAML in config file: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-}
-
-/**
- * Save config as YAML
- */
-export function saveConfig(configPath: string, config: Record<string, unknown>): void {
-  const dir = join(configPath, "..");
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  const yaml = stringify(config);
-  writeFileSync(configPath, yaml, "utf8");
-}
-
-/**
- * Parse dot-notation key into path segments
- */
-export function parseDotPath(key: string): string[] {
-  return key.split(".");
-}
-
-/**
- * Get nested value from object using path array
- */
-export function getNestedValue(obj: Record<string, unknown>, path: string[]): unknown {
-  let current: unknown = obj;
-  for (const segment of path) {
-    if (current === null || current === undefined || typeof current !== "object") {
-      return undefined;
-    }
-    current = (current as Record<string, unknown>)[segment];
-  }
-  return current;
-}
-
-/**
- * Set nested value in object using path array (mutates obj)
- */
-export function setNestedValue(obj: Record<string, unknown>, path: string[], value: unknown): void {
-  if (path.length === 0) {
-    throw new Error("Path cannot be empty");
-  }
-
-  let current: Record<string, unknown> = obj;
-
-  // Navigate/create to the parent of the target
-  for (let i = 0; i < path.length - 1; i++) {
-    const segment = path[i];
-    const next = current[segment];
-
-    if (next === null || next === undefined) {
-      // Create intermediate object
-      const newObj: Record<string, unknown> = {};
-      current[segment] = newObj;
-      current = newObj;
-    } else if (typeof next === "object" && !Array.isArray(next)) {
-      // Navigate into existing object
-      current = next as Record<string, unknown>;
-    } else {
-      // Cannot navigate into non-object
-      throw new Error(
-        `Cannot set property '${path[i + 1]}' on non-object at path '${path.slice(0, i + 1).join(".")}'`,
-      );
-    }
-  }
-
-  // Set the final value
-  const lastSegment = path[path.length - 1];
-  current[lastSegment] = value;
-}
-
-/**
- * Deep clone and mask all apiKey values in providers section
- */
-export function maskApiKeys(config: Record<string, unknown>): Record<string, unknown> {
-  // Deep clone
-  const cloned = JSON.parse(JSON.stringify(config)) as Record<string, unknown>;
-
-  // Mask apiKey values in providers
-  if (cloned.providers && typeof cloned.providers === "object") {
-    const providers = cloned.providers as Record<string, unknown>;
-    for (const providerName of Object.keys(providers)) {
-      const provider = providers[providerName];
-      if (provider && typeof provider === "object") {
-        const providerObj = provider as Record<string, unknown>;
-        if ("apiKey" in providerObj) {
-          providerObj.apiKey = "***MASKED***";
-        }
-      }
-    }
-  }
-
-  return cloned;
-}
-
-/**
- * List all configuration values (masks API keys)
- */
-export async function cmdConfigList(storageRoot: string): Promise<unknown> {
-  const configPath = getConfigPath(storageRoot);
-  const config = loadConfig(configPath);
-  const masked = maskApiKeys(config);
-  return masked;
-}
-
-/**
- * Get a specific configuration value
- */
-export async function cmdConfigGet(storageRoot: string, key: string): Promise<unknown> {
-  const configPath = getConfigPath(storageRoot);
-  const config = loadConfig(configPath);
-  const path = parseDotPath(key);
-  const value = getNestedValue(config, path);
-
-  if (value === undefined) {
-    throw new Error(`Key not found: ${key}`);
-  }
-
-  return value;
-}
-
-/**
- * Parse value for args key (must be JSON array)
- */
-function parseArgsValue(value: string): unknown {
-  if (value.startsWith("[")) {
-    try {
-      const parsed = JSON.parse(value);
-      if (!Array.isArray(parsed)) {
-        throw new Error("Value must be an array");
-      }
-      return parsed;
-    } catch (error) {
-      throw new Error(
-        `Invalid JSON array for args key: ${error instanceof Error ? error.message : String(error)}`,
-      );
-    }
-  }
-  throw new Error("Value for 'args' key must be a JSON array starting with '['");
-}
-
-/**
- * Validate that we're not setting a property on a non-object
- */
-function validateParentPath(
-  config: Record<string, unknown>,
-  path: string[],
-  lastSegment: string,
-): void {
-  if (path.length > 1) {
-    const parentPath = path.slice(0, -1);
-    const parent = getNestedValue(config, parentPath);
-    if (parent !== null && parent !== undefined && typeof parent !== "object") {
-      throw new Error(
-        `Cannot set property '${lastSegment}' on non-object at path '${parentPath.join(".")}'`,
-      );
-    }
-  }
-}
-
-/**
- * Set a specific configuration value
- */
-export async function cmdConfigSet(
-  storageRoot: string,
-  key: string,
-  value: string,
-): Promise<unknown> {
-  const configPath = getConfigPath(storageRoot);
-
-  // Load existing config or create empty one
-  let config: Record<string, unknown>;
-  if (existsSync(configPath)) {
-    config = loadConfig(configPath);
-  } else {
-    config = {};
-  }
-
-  const path = parseDotPath(key);
-
-  // Validate the key path
-  validateConfigKey(path);
-
-  const lastSegment = path[path.length - 1];
-
-  // Parse value if it's for an array key (args)
-  let parsedValue: unknown = value;
-  if (lastSegment === "args") {
-    parsedValue = parseArgsValue(value);
-  }
-
-  // Validate we're not setting a property on a non-object
-  validateParentPath(config, path, lastSegment);
-
-  setNestedValue(config, path, parsedValue);
-  saveConfig(configPath, config);
-
-  return { key, value: parsedValue };
-}

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

@@ -85,6 +85,10 @@ function getConfigPath(root: string): string {
   return join(root, "config.yaml");
 }
 
+function getEnvPath(root: string): string {
+  return join(root, ".env");
+}
+
 /**
  * Load existing config.yaml or return empty structure.
  */
@@ -102,6 +106,37 @@ function loadExistingConfig(configPath: string): Record<string, unknown> {
   return {};
 }
 
+/**
+ * Load existing .env as key=value map.
+ */
+function loadEnvFile(envPath: string): Record<string, string> {
+  const env: Record<string, string> = {};
+  try {
+    if (existsSync(envPath)) {
+      for (const line of readFileSync(envPath, "utf8").split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed === "" || trimmed.startsWith("#")) continue;
+        const eq = trimmed.indexOf("=");
+        if (eq > 0) {
+          env[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
+        }
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return env;
+}
+
+function saveEnvFile(envPath: string, env: Record<string, string>): void {
+  const lines = Object.entries(env).map(([k, v]) => `${k}=${v}`);
+  writeFileSync(envPath, `${lines.join("\n")}\n`, "utf8");
+}
+
+function apiKeyEnvName(providerName: string): string {
+  return `${providerName.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
+}
+
 // ──────────────────────────────────────────────────────────────────────────────
 // Extracted helpers — _discoverAgents
 // ──────────────────────────────────────────────────────────────────────────────
@@ -362,7 +397,8 @@ function mergeConfig(existing: Record<string, unknown>, args: SetupArgs): Record
       : {}
   ) as Record<string, unknown>;
 
-  providers[args.provider] = { baseUrl: args.baseUrl, apiKey: args.apiKey };
+  const envName = apiKeyEnvName(args.provider);
+  providers[args.provider] = { baseUrl: args.baseUrl, apiKeyEnv: envName };
 
   const models = (
     typeof existing.models === "object" && existing.models !== null
@@ -377,7 +413,7 @@ function mergeConfig(existing: Record<string, unknown>, args: SetupArgs): Record
       : {}
   ) as Record<string, unknown>;
 
-  const agentName = _agentNameFromBinary(args.agent ?? "hermes");
+  const agentName = args.agent ?? "hermes";
   // Ensure the selected agent has an entry
   if (!agents[agentName]) {
     agents[agentName] = { command: `uwf-${agentName}`, args: [] };
@@ -401,17 +437,25 @@ export async function cmdSetup(args: SetupArgs): Promise<Record<string, unknown>
   mkdirSync(storageRoot, { recursive: true });
 
   const configPath = getConfigPath(storageRoot);
+  const envPath = getEnvPath(storageRoot);
 
   const existing = loadExistingConfig(configPath);
   const merged = mergeConfig(existing, args);
 
   writeFileSync(configPath, stringify(merged, { indent: 2 }), "utf8");
 
+  // Write API key to .env
+  const envName = apiKeyEnvName(args.provider);
+  const envData = loadEnvFile(envPath);
+  envData[envName] = args.apiKey;
+  saveEnvFile(envPath, envData);
+
   // Validate model connectivity
   const validation = await validateModel(args.baseUrl, args.apiKey, args.model);
 
   return {
     configPath,
+    envPath,
     provider: args.provider,
     model: args.model,
     defaultAgent: merged.defaultAgent,

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

@@ -331,7 +331,7 @@ export async function cmdThreadShow(storageRoot: string, threadId: ThreadId): Pr
   fail(`thread not found: ${threadId}`);
 }
 
-export type ThreadStatus = "idle" | "running" | "completed" | "cancelled";
+export type ThreadStatus = "idle" | "running" | "completed";
 
 export type ThreadListItemWithStatus = ThreadListItem & {
   status: ThreadStatus;
@@ -389,7 +389,7 @@ async function collectCompletedThreads(
         thread: entry.thread,
         workflow: entry.workflow,
         head: entry.head,
-        status: entry.reason === "cancelled" ? "cancelled" : "completed",
+        status: "completed",
       });
     }
   }
@@ -444,10 +444,7 @@ export async function cmdThreadList(
   let items = await collectActiveThreads(storageRoot, uwf, index);
 
   // Collect completed threads (if relevant for status filter)
-  const includeCompleted =
-    statusFilter === null ||
-    statusFilter.includes("completed") ||
-    statusFilter.includes("cancelled");
+  const includeCompleted = statusFilter === null || statusFilter.includes("completed");
   if (includeCompleted) {
     const activeIds = new Set(items.map((i) => i.thread));
     const completedItems = await collectCompletedThreads(storageRoot, activeIds);
@@ -814,7 +811,6 @@ async function archiveThread(
     workflow,
     head,
     completedAt: Date.now(),
-    reason: "completed",
   });
 }
 
@@ -1151,7 +1147,6 @@ export async function cmdThreadCancel(
     workflow,
     head,
     completedAt: Date.now(),
-    reason: "cancelled",
   };
   await appendThreadHistory(storageRoot, historyEntry);
 

packages/cli-workflow/src/store.ts

@@ -88,7 +88,6 @@ export function getHistoryPath(storageRoot: string): string {
 
 export type ThreadHistoryLine = ThreadListItem & {
   completedAt: number;
-  reason: "completed" | "cancelled" | null;
 };
 
 export type UwfStore = {
@@ -229,15 +228,7 @@ export async function loadThreadHistory(storageRoot: string): Promise<ThreadHist
         typeof head === "string" &&
         typeof completedAt === "number"
       ) {
-        const reason = rec.reason;
-        const parsedReason = reason === "completed" || reason === "cancelled" ? reason : null;
-        lines.push({
-          thread: thread as ThreadId,
-          workflow,
-          head,
-          completedAt,
-          reason: parsedReason,
-        });
+        lines.push({ thread: thread as ThreadId, workflow, head, completedAt });
       }
     }
     return lines;

packages/workflow-protocol/README.md

@@ -100,7 +100,7 @@ type ProviderAlias = string;
 type ModelAlias = string;
 type AgentAlias = string;
 
-type ProviderConfig = { baseUrl: string; apiKey: string };
+type ProviderConfig = { baseUrl: string; apiKeyEnv: string };
 type ModelConfig = {
   provider: ProviderAlias;
   name: string;

packages/workflow-protocol/src/types.ts

@@ -151,7 +151,7 @@ export type Scenario = string;
 
 export type ProviderConfig = {
   baseUrl: string;
-  apiKey: string;
+  apiKeyEnv: string;
 };
 
 export type ModelConfig = {

packages/workflow-util-agent/src/extract.ts

@@ -1,7 +1,8 @@
 import { getSchema, validate } from "@uncaged/json-cas";
 
 import type { CasRef, ModelAlias, WorkflowConfig } from "@uncaged/workflow-protocol";
-import { createAgentStore, resolveStorageRoot } from "./storage.js";
+import { config as loadDotenv } from "dotenv";
+import { createAgentStore, getEnvPath, resolveStorageRoot } from "./storage.js";
 
 export type ResolvedLlmProvider = {
   baseUrl: string;
@@ -37,9 +38,9 @@ export function resolveModel(config: WorkflowConfig, alias: ModelAlias): Resolve
   if (providerEntry === undefined) {
     throw new Error(`unknown provider "${modelEntry.provider}" for model "${alias}"`);
   }
-  const apiKey = providerEntry.apiKey;
+  const apiKey = process.env[providerEntry.apiKeyEnv];
   if (apiKey === undefined || apiKey === "") {
-    throw new Error(`missing API key for provider: ${modelEntry.provider}`);
+    throw new Error(`missing API key env var: ${providerEntry.apiKeyEnv}`);
   }
   return {
     baseUrl: providerEntry.baseUrl,
@@ -129,7 +130,7 @@ export type ExtractResult = {
 
 /**
  * Call an OpenAI-compatible LLM to extract structured output matching outputSchema.
- * Loads config.yaml from the workflow storage root.
+ * Loads config.yaml and .env from the workflow storage root.
  */
 export async function extract(
   rawOutput: string,
@@ -137,6 +138,7 @@ export async function extract(
   config: WorkflowConfig,
 ): Promise<ExtractResult> {
   const storageRoot = resolveStorageRoot();
+  loadDotenv({ path: getEnvPath(storageRoot) });
 
   const { store } = await createAgentStore(storageRoot);
   const schema = getSchema(store, outputSchema);

packages/workflow-util-agent/src/storage.ts

@@ -84,11 +84,11 @@ function normalizeProviders(raw: unknown): Record<ProviderAlias, ProviderConfig>
       throw new Error(`config.providers.${name} must be a mapping`);
     }
     const baseUrl = entry.baseUrl;
-    const apiKey = entry.apiKey;
-    if (typeof baseUrl !== "string" || typeof apiKey !== "string") {
-      throw new Error(`config.providers.${name} requires baseUrl and apiKey`);
+    const apiKeyEnv = entry.apiKeyEnv;
+    if (typeof baseUrl !== "string" || typeof apiKeyEnv !== "string") {
+      throw new Error(`config.providers.${name} requires baseUrl and apiKeyEnv`);
     }
-    providers[name] = { baseUrl, apiKey };
+    providers[name] = { baseUrl, apiKeyEnv };
   }
   return providers;
 }