catui-agent 1.0.0-beta.0

package/dist/extensions/builtin/teach/teach-types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * [WHO]: TeachTypes - teaching-related type definitions
+ * [FROM]: No dependencies
+ * [TO]: Consumed by teach-runtime.ts, teach-prompts.ts, teach-format.ts
+ * [HERE]: extensions/builtin/teach/teach-types.ts - type definitions for teach extension
+ */
+export type TeachPhase = "mission_discovery" | "learning_style" | "teaching" | "progress_tracking";
+export type LearningStyle = "quick_overview" | "deep_dive" | "focused_skill" | "holistic";
+export type LearnerLevel = "L0" | "L1" | "L2" | "L3";
+export type LessonLevel = 0 | 1 | 2 | 3;
+export interface Mission {
+    why: string;
+    successCriteria: string[];
+    constraints: string[];
+    outOfScope: string[];
+}
+export interface Analogy {
+    concept: string;
+    analogy: string;
+    details: string;
+    confidence: "low" | "medium" | "high";
+}
+export interface Source {
+    name: string;
+    url: string;
+    confidence: 1 | 2 | 3 | 4 | 5;
+    verificationMethod: string;
+}
+export interface LearningRecord {
+    topic: string;
+    level: LessonLevel;
+    content: string;
+    timestamp: Date;
+    status: "active" | "superseded";
+}
+export interface TeachState {
+    phase: TeachPhase;
+    topic: string;
+    mission?: Mission;
+    learningStyle?: LearningStyle;
+    learnerLevel: LearnerLevel;
+    currentLevel: LessonLevel;
+    glossary: Map<string, string>;
+    sources: Source[];
+    learningRecords: LearningRecord[];
+    sessionId?: string;
+}
+export interface TeachResult {
+    type: "question" | "lesson" | "complete" | "error" | "info";
+    message: string;
+    content?: string;
+    level?: LessonLevel;
+    options?: string[];
+    nextAction?: "continue" | "ask" | "complete";
+    state?: Partial<TeachState>;
+}
+export interface TeachLessonOptions {
+    topic: string;
+    level: LessonLevel;
+    analogy: Analogy | null;
+    sources: Source[];
+    learnerLevel: LearnerLevel;
+    learningStyle: LearningStyle;
+}
+export interface AnalogyEntry {
+    concept: string;
+    analogies: Analogy[];
+}
+export interface LearningPath {
+    id: string;
+    name: string;
+    description: string;
+    targetLevel: LearnerLevel;
+    topics: LearningPathTopic[];
+}
+export interface LearningPathTopic {
+    order: number;
+    topic: string;
+    duration: string;
+    buildsOn: number[];
+}

package/dist/extensions/builtin/team/AGENT.md

@@ -0,0 +1,112 @@
+# extensions/builtin/team/
+
+> P2 | Parent: ../AGENT.md
+
+Member List
+- index.ts: AgentTeam extension entry, /team <task>, /team:spawn/:preset/:send/:status/:progress/:psyche/:dashboard/:task/:mail/:allow-path/:stop/:terminate/:approve/:mode commands, TEAM_MESSAGE_TYPE speaker-stream renderer, realtime status/dashboard updates
+- team-types.ts: TeammateRole/TeammateMode/TeammateStatus/TeamTask/HarnessState/PsycheWeights/TeamUtterance/Handoff/LeaderPlan/AgentLiveView/TeammateIdentity/PersistedTeammate/TeamSpawnSpec/TeamSendResult types
+- team-state-store.ts: TeamStateStore class - durable teammate persistence via JSON files in <agentDir>/teams/
+- team-parser.ts: Team command parser - parseTeamCommand/buildTeamHelp for /team:* subcommands
+- team-runtime.ts: TeamRuntime class - teammate registry, stable internal labels plus visible teammate names, per-teammate send queue, lifecycle, durable tasks, mailbox + permission + transcript wiring; uses SubAgentRuntime for agent spawning
+- team-runtime-helpers.ts: TeamRuntime helper boundary - teammate prompt construction, harness turn preparation, live event projection, tool selection, path guards, label/role/text helpers
+- team-ui.ts: Team message renderer, list/status/task formatting, dashboard visibility/timer ownership, realtime observer, and speaker-stream emission helpers used by index.ts
+- team-orchestrator.ts: Leader orchestration helpers - plan building, speaker utterance creation, @mention parsing, and handoff execution
+- team-task-store.ts: TeamTaskStore class - durable shared task list in <storageDir>/tasks.json with claim/status updates
+- team-harness.ts: Harness protocol helpers - context files, phase instructions, checkpoint/revert, feature validation
+- team-presets.ts: Preset definitions and executor - solo/duo/squad spawning, model-assisted auto team selection, heuristic fallback
+- team-dashboard.ts: Text dashboard/status rendering - teammate workbench cards, current task, last utterance, progress bars, footer summary
+- team-psyche.ts: Psyche prompt layer - role/phase weighted Id/Ego/Superego prompt construction
+- team-permissions.ts: PermissionStore - pending permission request queue, approve/deny, path allowlists (B.4)
+- team-mailbox.ts: TeamMailbox - typed JSONL-backed append-only message log for leader↔teammate and teammate↔teammate routing (B.3)
+- team-transcript.ts: TeamTranscriptWriter - per-teammate JSONL transcripts under <storageDir>/transcripts/ (B.7)
+- TESTING.md: Manual & smoke-test guide for the Phase B AgentTeam extension
+
+Rule: Members complete, one item per line, parent links valid, precise terms first
+
+[COVENANT]: Update this file header on changes and verify against parent AGENT.md
+
+---
+
+## Phase B: AgentTeam Architecture
+
+This extension implements the Phase B "true AgentTeam" per the refactor plan and the next-step conversational team UI:
+- Persistent teammates with durable state (survive across main session restarts)
+- Each teammate has identity, stable short label, mode, status, worktree, and message history
+- Teammates run in isolated worktrees (for implementers)
+- Uses core/sub-agent/ infrastructure for actual agent spawning
+- Main chat renders a speaker stream (`catui`, `Mason`, `Ada`, `Theo`, `Iris`, `Quinn`, ...) instead of raw status events
+- Leader orchestration can auto-split `/team <task>` into teammate assignments and follow `@mention` handoffs
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/team` | List all teammates |
+| `/team:spawn <role> [--name <id>]` | Create a persistent teammate |
+| `/team:send <name> <message>` | Send message to a teammate |
+| `/team:status [<name>]` | Show team or teammate status |
+| `/team:stop <name>` | Stop teammate's current turn |
+| `/team:terminate <name>` | Destroy a teammate |
+| `/team:approve <request-id>` | Approve a permission request |
+| `/team:mode <name> <plan\|execute\|review>` | Switch teammate mode |
+| `/team:task list` | Show shared team tasks |
+| `/team:task add <title>` | Add a shared task |
+| `/team:task claim <id> <name>` | Assign/claim a task for a teammate |
+| `/team:task done\|block\|cancel <id>` | Update task status |
+| `/team:mail <from> <to> <message>` | Route teammate-to-teammate mailbox message |
+| `/team:allow-path <name> <path>` | Grant teammate write access to a path prefix |
+
+## Roles
+
+- `researcher`: Read-only exploration
+- `reviewer`: Read-only review/audit
+- `implementer`: Sandboxed write in isolated worktree
+- `planner`: Read-only plan production
+- `generic`: Read-only by default
+
+## Modes
+
+- `research`: Read-only exploration
+- `plan`: Read-only plan production; execute requires leader approval
+- `execute`: Sandboxed write in worktree
+- `review`: Read-only review
+
+## State Persistence
+
+Teammate state is stored in `~/.catui/agent/teams/<uuid>.json`:
+- Identity (id, name, role, createdAt)
+- Mode and status
+- Working directory and worktree info
+- Message history
+- Last activity timestamp
+
+Shared team coordination state is also stored under `~/.catui/agent/teams/`:
+- `tasks.json`: durable task list with status, owner, dependencies, and artifact paths
+- `mailbox.jsonl`: replayable mailbox events for leader↔teammate and teammate↔teammate routing
+
+TeamStateStore is deliberately independent of core SessionManager per the refactor plan:
+> "team-state-store 自己负责 teammate 历史 ... SessionManager 只负责主会话"
+
+## Core Dependencies
+
+- `core/sub-agent/`: SubAgentRuntime for spawning agents
+- `core/workspace/`: WorktreeManager for isolated worktrees
+- `core/tools/`: Tool creation with sandboxed bash
+
+## Phase B status
+
+Shipped in this iteration:
+- Permission request/response (`team-permissions.ts`, wired into `/team:mode` execute escalation and `/team:approve`)
+- Durable shared task list (`team-task-store.ts`, wired into `/team:task`)
+- Mailbox protocol (`team-mailbox.ts`, posts on send/result/mode_change/permission_request/permission_response/task_update/task_claim/teammate_message and replays across restarts)
+- Prompt context injection: each teammate receives claimed tasks, blocked/open task cues, and recent mailbox messages before every turn
+- Path-scoped write allowlist exposed through `/team:allow-path`; execute-mode edit/write tools and simple bash write commands enforce teammate cwd or approved path prefixes
+- Per-teammate send queue: concurrent `/team:send` calls for the same teammate run sequentially instead of failing while the teammate is running
+- Per-teammate JSONL transcripts (`team-transcript.ts`)
+- Structured speaker-stream utterances with `speaker/role/kind/mentions`
+- Stable internal labels and mention-aware handoff parsing for leader-visible routing
+- Subprocess SubAgent backend harness (`core/sub-agent/subprocess-backend.ts` + `subprocess-worker.ts`) — interface complete, worker LLM loop deferred (see backend doc).
+
+Future work:
+- Worker-side full LLM agent loop for the subprocess backend
+- Broaden bash write parsing beyond simple single-command forms while keeping complex shell syntax rejected by default

package/dist/extensions/builtin/team/TESTING.md

@@ -0,0 +1,299 @@
+# Testing the AgentTeam Extension (Phase B)
+
+> Manual & smoke-test guide for `extensions/builtin/team/`.
+> Owner: AgentTeam Phase B. Last updated: 2026-04-08.
+
+This document describes how to verify the Phase B AgentTeam runtime end to end. It covers persistence, the permission model, the mailbox, transcripts, and the subprocess SubAgent backend.
+
+---
+
+## 0. Prerequisites
+
+```bash
+npm install
+npm run build         # or run via tsx for fast iteration
+```
+
+Run Catui in interactive mode for the manual scenarios:
+
+```bash
+npx tsx cli.ts
+```
+
+All teammate state lives under:
+
+- `${CATUI_AGENT_DIR:-~/.catui/agent}/teams/<id>.json`        — durable state
+- `${CATUI_AGENT_DIR:-~/.catui/agent}/teams/tasks.json`       — shared task list
+- `${CATUI_AGENT_DIR:-~/.catui/agent}/teams/mailbox.jsonl`    — replayable mailbox log
+- `${CATUI_AGENT_DIR:-~/.catui/agent}/teams/transcripts/<id>.jsonl` — per-teammate transcripts
+
+You can wipe state between runs with:
+
+```bash
+rm -rf ~/.catui/agent/teams
+```
+
+---
+
+## 1. Type & lint sanity
+
+```bash
+npx tsc --noEmit
+```
+
+The team extension must report **zero** errors. Pre-existing `presence/index.ts` errors related to `catui-mem` are unrelated and may remain until that extension is rebundled.
+
+---
+
+## 2. Manual smoke test — happy path
+
+In an interactive session:
+
+```text
+/team                                    # → "No teammates."
+/team:spawn researcher --name scout      # spawns read-only researcher
+/team                                    # lists scout (○ idle)
+/team:status scout                       # full record incl. cwd
+/team:send scout "What does core/sub-agent/ do?"
+/team:status scout                       # messages = 2
+/team:terminate scout                    # ⊗ teammate gone
+/team                                    # → "No teammates."
+```
+
+Pass criteria:
+
+- `scout`'s state file appears under `~/.catui/agent/teams/` after spawn.
+- The state file is removed after `terminate`.
+- `~/.catui/agent/teams/transcripts/<id>.jsonl` contains one `leader` line and one `teammate` line per send, then is removed on terminate.
+
+---
+
+## 3. Persistence across restarts
+
+```text
+/team:spawn researcher --name scout
+/team:send scout "Summarize README.md"
+```
+
+Quit Catui (`/exit` or Ctrl+C). Restart with `npx tsx cli.ts`. Then:
+
+```text
+/team
+/team:status scout
+```
+
+Pass criteria:
+
+- `scout` is still listed.
+- The previous message history is intact.
+- `scout`'s status is `idle` (any in-flight `running` is downgraded to `idle` on load — see `team-runtime.ts` `load()`).
+
+---
+
+## 4. Worktree isolation for implementers
+
+```text
+/team:spawn implementer --name builder
+/team:status builder
+```
+
+Pass criteria:
+
+- `builder.cwd` and `worktreePath` point at a fresh git worktree under
+  `~/.catui/agent/...` (or `WorktreeManager`'s default location).
+- `git worktree list` from the project shows the new worktree.
+- Default mode is `plan` (read-only), **not** `execute`.
+
+---
+
+## 5. Permission model — execute escalation
+
+```text
+/team:mode builder execute
+```
+
+Pass criteria:
+
+- The response says **"requires approval"** and prints a request id.
+- `/team:approve` (no args) lists the pending request with action
+  `mode_change_to_execute`.
+- `/team:approve <id>` flips `builder` to `execute` mode.
+- A second `/team:approve <id>` returns "not found or already resolved".
+- `/team:status builder` now reports `mode: execute`.
+- `/team:terminate builder` cancels any still-pending requests cleanly.
+
+Negative test — denial path:
+
+```text
+/team:spawn implementer --name builder2
+/team:mode builder2 execute       # pending
+/team:terminate builder2          # cancels the request as denied
+```
+
+Pass criteria: terminate succeeds, no dangling promise warnings in stderr.
+
+---
+
+## 6. Mailbox observation
+
+The mailbox is currently consumed by `team-runtime` itself; programmatic observers can subscribe via `runtime.getMailbox().subscribe(...)`. To verify mailbox traffic from a test harness:
+
+```ts
+import { TeamRuntime } from "./team-runtime.js";
+const rt = new TeamRuntime({ storageDir: "/tmp/team-test" });
+rt.getMailbox().subscribe((m) => console.log(m.type, m.direction));
+await rt.spawn({ role: "researcher", baseCwd: process.cwd() });
+await rt.send("researcher-1", "ping");
+```
+
+Expected message sequence: `task_request` → `task_result`.
+After `setMode("..." , "execute")` on an implementer: `permission_request`, then on approval `permission_response` and `mode_change`.
+
+Shared task and teammate mail smoke:
+
+```text
+/team:spawn researcher --name scout
+/team:spawn reviewer --name reviewer
+/team:task add Map team implementation
+/team:task claim T-1 scout
+/team:mail scout reviewer "Please review T-1 when ready"
+/team:task list
+```
+
+Pass criteria:
+
+- `tasks.json` contains `T-1` with `status: "claimed"` and `ownerName: "scout"`.
+- `mailbox.jsonl` contains `task_update`, `task_claim`, and `teammate_message`.
+- Restarting Catui preserves `/team:task list` output and the teammate mailbox context shown to each teammate.
+- The next `/team:send scout ...` prompt includes `Shared team tasks`, the claimed task, and recent mailbox lines targeting `scout`.
+
+---
+
+## 6.1 Path-scoped write access
+
+```text
+/team:spawn implementer --name builder
+/team:mode builder execute
+/team:approve <request-id>
+```
+
+Pass criteria:
+
+- In execute mode, `edit`, `write`, and simple bash write commands can mutate files inside `builder.cwd`.
+- Attempts to mutate an absolute path outside `builder.cwd` fail with `Write denied` or the team bash sandbox message.
+- `/team:allow-path builder ../shared-output` grants that path prefix; subsequent `edit`, `write`, and simple bash writes under the approved path succeed.
+- Complex shell write syntax with `&&`, pipes, command substitution, or subshells remains blocked by default.
+
+---
+
+## 7. Transcripts
+
+After any `/team:send`:
+
+```bash
+ls ~/.catui/agent/teams/transcripts/
+cat ~/.catui/agent/teams/transcripts/<id>.jsonl
+```
+
+Pass criteria:
+
+- One JSON object per line.
+- Each line has `timestamp`, `kind` (`leader` | `teammate` | `event`), and `content`.
+- Transcript file is removed when the teammate is terminated.
+
+---
+
+## 8. Stop in flight
+
+Spawn a teammate, send a long task, then immediately stop:
+
+```text
+/team:spawn researcher --name slow
+/team:send slow "Read every file under core/ and summarize"
+# while running:
+/team:stop slow
+/team:status slow
+```
+
+Pass criteria:
+
+- The send call returns within ~15 seconds with `aborted: true` or an error.
+- `slow` ends up in `stopped` status.
+- A subsequent `/team:send slow "ping"` works (status returns to `running` then `idle`).
+
+Concurrent send queue check:
+
+```text
+/team:spawn researcher --name scout
+/team:send scout "First long read"
+# while running:
+/team:send scout "Second follow-up"
+```
+
+Pass criteria:
+
+- The second send is queued instead of rejected.
+- Mailbox contains a `task_progress` event with `status: "queued"`.
+- The teammate receives and records both leader messages in order.
+
+---
+
+## 9. Subprocess SubAgent backend (smoke)
+
+The subprocess backend is exercised via `SubprocessSubAgentBackend` directly. Quick Node smoke from the repo root:
+
+```bash
+npx tsx -e "
+import { SubprocessSubAgentBackend } from './core/sub-agent/subprocess-backend.js';
+const backend = new SubprocessSubAgentBackend();
+const ctrl = new AbortController();
+const handle = await backend.spawn({
+  prompt: 'hello',
+  cwd: process.cwd(),
+  tools: [],
+  signal: ctrl.signal,
+});
+console.log(await handle.result());
+"
+```
+
+Pass criteria:
+
+- The script prints `{ success: true, response: '[subprocess-worker:...] received prompt of 5 chars in cwd ...' }`.
+- Aborting before the worker posts: replace `await handle.result()` with `ctrl.abort(); await handle.result();` — should print `{ success: false, error: 'Aborted' }` and the worker thread is terminated.
+
+> **Scope note.** The subprocess backend ships the harness (worker_threads channel, abort wiring, lifecycle) but does **not** run the full LLM agent loop inside the worker yet. Callers that need real LLM execution should keep using the in-process backend; this backend is the foundation for future crash isolation.
+
+---
+
+## 10. Recovery (corrupt state file)
+
+Touch a malformed state file to confirm `loadAll()` skips it gracefully:
+
+```bash
+echo "not-json" > ~/.catui/agent/teams/garbage.json
+npx tsx cli.ts
+/team
+```
+
+Pass criteria: Catui starts normally, `/team` lists only valid teammates, no crash.
+
+---
+
+## 11. Coverage matrix
+
+| §B item                          | Covered by section |
+|----------------------------------|--------------------|
+| B.1 Persistent teammates         | §2, §3             |
+| B.2 State store independence     | §3, §10            |
+| B.3 Mailbox protocol             | §6                 |
+| B.4 Permission model             | §5                 |
+| B.5 Worktree isolation           | §4                 |
+| B.6 Multi-backend (subprocess)   | §9                 |
+| B.7 Transcripts                  | §7                 |
+| B.8 Recovery                     | §3, §10            |
+| AbortSignal closure (Phase A.2)  | §8                 |
+
+---
+
+**Covenant**: When you add a new `/team:*` command or change the permission/mailbox surface, update this file in the same commit.

package/dist/extensions/builtin/team/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * [WHO]: AgentTeam extension, registers /team commands for persistent teammates, harness status, psyche status, dashboard widget
+ * [FROM]: Depends on @catui/tui, core/extensions-host/types, ./team-runtime, ./team-parser, ./team-types, ./team-harness, ./team-presets, ./team-dashboard
+ * [TO]: Consumed by builtin-extensions.ts as default extension
+ * [HERE]: extensions/builtin/team/index.ts - AgentTeam extension entry point
+ *
+ * Commands:
+ *   /team                      - List teammates
+ *   /team <task>               - Auto-select team size/roles and start the task
+ *   /team:spawn <role> [--name <id>] [--harness] - Create teammate
+ *   /team:preset <solo|duo|squad> <task> - Create preset team
+ *   /team:send <name> <message>      - Send message to teammate
+ *   /team:status [<name>]            - Show status
+ *   /team:progress [<name>]          - Show harness progress
+ *   /team:psyche [<name>]            - Show psyche weights
+ *   /team:dashboard                  - Toggle dashboard widget
+ *   /team:task <add|claim|done|block|cancel|list> ... - Manage shared task list
+ *   /team:mail <from> <to> <message> - Route teammate-to-teammate mailbox messages
+ *   /team:allow-path <name> <path>   - Grant teammate write access to a path prefix
+ *   /team:stop <name>                - Stop teammate turn
+ *   /team:terminate <name>           - Destroy teammate
+ *   /team:approve <request-id>       - Approve permission request
+ *   /team:mode <name> <plan|execute|review> - Switch mode
+ */
+import type { ExtensionAPI } from "../../../core/extensions-host/types.js";
+export default function teamExtension(api: ExtensionAPI): Promise<void>;

package/dist/extensions/builtin/team/index.js

@@ -0,0 +1,11 @@
+var U=Object.defineProperty;var p=(r,s)=>U(r,"name",{value:s,configurable:!0});import{TeamRuntime as N}from"./team-runtime.js";import{buildTeamHelp as E,getTeamArgumentCompletions as I,parseTeamCommand as C}from"./team-parser.js";import{executePreset as P,formatPresetResult as q}from"./team-presets.js";import{formatHarnessProgress as R}from"./team-harness.js";import{formatPsycheWeights as D}from"./team-psyche.js";import{createTeamUtterance as k,parseTeamMentions as j,runLeaderOrchestration as F}from"./team-orchestrator.js";import{TEAM_MESSAGE_TYPE as m,clearTeamDashboardTimer as W,createTeamMessageRenderer as _,createTeamObserver as w,emitTeamUtterance as y,formatSpeakerName as T,formatTaskList as L,formatTeammateList as v,formatTeammateStatus as H,setTeamActivity as b,toggleTeamDashboard as G,truncateForStatus as S,updateTeamUi as d}from"./team-ui.js";let M=null;function B(){return M||(M=new N),M}p(B,"getRuntime");async function K(r){const s=B();await s.load(),r.on("session_shutdown",async()=>{W(),await s.dispose()}),r.on("session_ready",(c,u)=>{s.setSoulManager(u.getSoulManager()),d(u,s)}),r.on("session_start",(c,u)=>{u.ui.setWidget("team-dashboard",void 0)}),r.on("session_switch",(c,u)=>{u.ui.setWidget("team-dashboard",void 0)}),r.registerMessageRenderer(m,_());const A=["team","team:spawn","team:send","team:status","team:stop","team:terminate","team:approve","team:mode","team:preset","team:dashboard","team:progress","team:psyche","team:task","team:mail","team:allow-path"];for(const c of A)r.registerCommand(c,{description:O(c),getArgumentCompletions:p((u,t)=>I(c,u,t),"getArgumentCompletions"),handler:p(async(u,t)=>{const e=C(c,u);if(!e){t.ui.notify("Invalid /team command. Use /team for usage.","error");return}switch(e.command){case"help":{r.sendMessage({customType:m,content:E(),display:!0});break}case"list":{const a=s.getAllTeammates(),o=v(a);r.sendMessage({customType:m,content:o.join(`
+`),display:!0});break}case"auto":{if(!e.taskDescription){t.ui.notify("Usage: /team <task>","error");return}b(t,["Team: planning multi-agent work...",`Task: ${S(e.taskDescription)}`]);try{const a=w(r,t,s);await F(s,{taskDescription:e.taskDescription,baseCwd:t.cwd,model:t.model,onRuntimeEvent:a.onEvent,completeSimple:t.completeSimple,emitUtterance:p((o,n)=>y(r,o,n),"emitUtterance")}),a.flush(),d(t,s)}catch(a){const o=a instanceof Error?a.message:String(a);t.ui.notify(`Failed to auto-select team: ${o}`,"error"),r.sendMessage({customType:m,content:`Failed to auto-select team: ${o}`,display:!0}),d(t,s)}finally{t.ui.setWorkingMessage()}break}case"spawn":{if(!e.role){t.ui.notify("Usage: /team:spawn <role> [--name <name>]","error");return}r.sendMessage({customType:m,content:`Spawning ${e.role} teammate${e.name?` named "${e.name}"`:""}...`,display:!0}),t.ui.setWorkingMessage(`Team: spawning ${e.role} teammate...`);try{const a=await s.spawn({role:e.role,name:e.name,baseCwd:t.cwd,harnessEnabled:e.harnessEnabled}),o=["Teammate spawned successfully:",`  Name: ${a.identity.name}`,`  Role: ${a.identity.role}`,`  Mode: ${a.mode}`,`  Status: ${a.status}`,...a.harness?.enabled?[`  Harness: ${a.harness.phase}`]:[],...a.worktreePath?[`  Worktree: ${a.worktreePath}`]:[]];r.sendMessage({customType:m,content:o.join(`
+`),display:!0}),d(t,s)}catch(a){const o=a instanceof Error?a.message:String(a);t.ui.notify(`Failed to spawn teammate: ${o}`,"error"),r.sendMessage({customType:m,content:`Failed to spawn teammate: ${o}`,display:!0})}finally{t.ui.setWorkingMessage()}break}case"send":{if(!e.target||!e.message){t.ui.notify("Usage: /team:send <name> <message>","error");return}const a=t.model;b(t,[`Team: sending task to ${e.target}...`]);const o=s.getTeammate(e.target);y(r,k({speakerId:"leader",speakerLabel:"catui",role:"leader",kind:"work",text:o?`@${o.identity.name} ${e.message}`:`${e.target} ${e.message}`}));try{const n=w(r,t,s),i=await s.send(e.target,e.message,a,{onEvent:n.onEvent});if(n.flush(),d(t,s),i.success){const l=s.getTeammate(i.teammateName),$=j(i.response,s.getAllTeammates());y(r,k({speakerId:l?.identity.id??i.teammateName,speakerLabel:l?T(l):i.teammateName,role:l?.identity.role??"generic",kind:$.length>0?"handoff":"result",text:i.response,mentions:$}),l?{streamKey:`team-stream:${l.identity.id}`,replace:!0}:void 0);for(const f of $){const g=s.getTeammate(f.targetLabel)??s.getTeammate(f.targetName);if(!g)continue;y(r,k({speakerId:"leader",speakerLabel:"catui",role:"leader",kind:"handoff",text:`@${g.identity.name} take the handoff from ${l?T(l):i.teammateName}: ${f.task}`,mentions:[f]}));const h=await s.send(g.identity.name,`Handoff from ${l?T(l):i.teammateName}: ${f.task}`,a,{onEvent:n.onEvent});y(r,k({speakerId:g.identity.id,speakerLabel:T(g),role:g.identity.role,kind:h.success?"result":"work",text:h.response||h.error||"No response."}),{streamKey:`team-stream:${g.identity.id}`,replace:!0})}}else t.ui.notify(`Teammate ${i.teammateName} failed: ${i.error??"Unknown error"}`,"error"),r.sendMessage({customType:m,content:`Teammate ${i.teammateName} failed: ${i.error??"Unknown error"}`,display:!0})}catch(n){const i=n instanceof Error?n.message:String(n);t.ui.notify(`Failed to send message: ${i}`,"error"),r.sendMessage({customType:m,content:`Failed to send message: ${i}`,display:!0}),d(t,s)}finally{t.ui.setWorkingMessage()}break}case"status":{if(e.target){const a=s.getTeammate(e.target);if(!a){t.ui.notify(`Teammate "${e.target}" not found`,"error");return}const o=H(a);r.sendMessage({customType:m,content:o.join(`
+`),display:!0})}else{const a=s.getAllTeammates(),o=v(a);r.sendMessage({customType:m,content:o.join(`
+`),display:!0})}break}case"stop":{if(!e.target){t.ui.notify("Usage: /team:stop <name>","error");return}const a=await s.stop(e.target);d(t,s),a?r.sendMessage({customType:m,content:`Stopped ${e.target}'s current turn.`,display:!0}):t.ui.notify(`Teammate "${e.target}" not found`,"error");break}case"terminate":{if(!e.target){t.ui.notify("Usage: /team:terminate <name>","error");return}const a=await s.terminate(e.target);d(t,s),a?r.sendMessage({customType:m,content:`Terminated teammate "${e.target}".`,display:!0}):t.ui.notify(`Teammate "${e.target}" not found`,"error");break}case"mode":{if(!e.target||!e.mode){t.ui.notify("Usage: /team:mode <name> <plan|execute|review>","error");return}const a=await s.setMode(e.target,e.mode);if(d(t,s),!a.ok){t.ui.notify(`Teammate "${e.target}" not found`,"error");break}a.pending?r.sendMessage({customType:m,content:`Mode change for ${e.target} \u2192 ${e.mode} requires approval.
+Approve with: /team:approve ${a.pending.requestId}`,display:!0}):r.sendMessage({customType:m,content:`Changed ${e.target}'s mode to "${e.mode}".`,display:!0});break}case"approve":{if(!e.requestId){const o=s.getPermissionStore().listPending();if(o.length===0)r.sendMessage({customType:m,content:"No pending permission requests.",display:!0});else{const n=["Pending permission requests:",""];for(const i of o)n.push(`  ${i.id}`),n.push(`    teammate: ${i.teammateName}`),n.push(`    action:   ${i.action}`),n.push(`    detail:   ${i.detail}`);n.push("","Approve with: /team:approve <id>"),r.sendMessage({customType:m,content:n.join(`
+`),display:!0})}break}s.approvePermission(e.requestId)?r.sendMessage({customType:m,content:`Approved request ${e.requestId}.`,display:!0}):t.ui.notify(`Permission request "${e.requestId}" not found or already resolved.`,"error");break}case"preset":{if(!e.presetName||!e.taskDescription){t.ui.notify("Usage: /team:preset <solo|duo|squad> <task>","error");return}r.sendMessage({customType:m,content:`Creating "${e.presetName}" preset...`,display:!0}),b(t,[`Team: creating "${e.presetName}" preset...`,`Task: ${S(e.taskDescription)}`]);try{const a=w(r,t,s),o=await P(s,e.presetName,e.taskDescription,t.cwd,t.model,a.onEvent);a.flush(),r.sendMessage({customType:m,content:q(o).join(`
+`),display:!0}),d(t,s)}catch(a){const o=a instanceof Error?a.message:String(a);t.ui.notify(`Failed to execute preset: ${o}`,"error"),r.sendMessage({customType:m,content:`Failed to execute preset: ${o}`,display:!0}),d(t,s)}finally{t.ui.setWorkingMessage()}break}case"progress":{const a=e.target?[s.getTeammate(e.target)].filter(n=>!!n):s.getAllTeammates();if(e.target&&a.length===0){t.ui.notify(`Teammate "${e.target}" not found`,"error");return}const o=a.flatMap(n=>[`Teammate: ${n.identity.name}`,...R(n.harness),""]);r.sendMessage({customType:m,content:o.join(`
+`).trimEnd(),display:!0});break}case"psyche":{const a=e.target?[s.getTeammate(e.target)].filter(n=>!!n):s.getAllTeammates();if(e.target&&a.length===0){t.ui.notify(`Teammate "${e.target}" not found`,"error");return}const o=a.map(n=>`${n.identity.name}: ${D(n.psyche)}`);r.sendMessage({customType:m,content:o.join(`
+`),display:!0});break}case"dashboard":{const a=G(t,s);r.sendMessage({customType:m,content:`Team dashboard ${a?"enabled":"disabled"}.`,display:!0});break}case"task":{if(!e.taskAction){t.ui.notify("Usage: /team:task <list|add|claim|done|block|cancel> ...","error");return}if(e.taskAction==="list"){const n=await s.listTasks();r.sendMessage({customType:m,content:L(n).join(`
+`),display:!0});break}if(e.taskAction==="add"){if(!e.taskTitle){t.ui.notify("Usage: /team:task add <title>","error");return}const n=await s.addTask(e.taskTitle);r.sendMessage({customType:m,content:`Added task ${n.id}: ${n.title}`,display:!0});break}if(e.taskAction==="claim"){if(!e.taskId||!e.target){t.ui.notify("Usage: /team:task claim <id> <name>","error");return}const n=await s.claimTask(e.taskId,e.target);if(!n){t.ui.notify(`Task or teammate not found: ${e.taskId}`,"error");return}r.sendMessage({customType:m,content:`Claimed ${n.id} for ${n.ownerName}: ${n.title}`,display:!0});break}if(!e.taskId){t.ui.notify(`Usage: /team:task ${e.taskAction} <id>`,"error");return}const a=e.taskAction==="done"?"done":e.taskAction==="block"?"blocked":"cancelled",o=await s.updateTaskStatus(e.taskId,a);if(!o){t.ui.notify(`Task not found: ${e.taskId}`,"error");return}r.sendMessage({customType:m,content:`Updated ${o.id} to ${o.status}: ${o.title}`,display:!0});break}case"mail":{if(!e.from||!e.to||!e.message){t.ui.notify("Usage: /team:mail <from> <to> <message>","error");return}if(!await s.sendTeammateMail(e.from,e.to,e.message)){t.ui.notify(`Could not route mail from ${e.from} to ${e.to}`,"error");return}r.sendMessage({customType:m,content:`Routed mail ${e.from} -> ${e.to}.`,display:!0});break}case"allow-path":{if(!e.target||!e.path){t.ui.notify("Usage: /team:allow-path <name> <path>","error");return}const a=await s.allowPath(e.target,e.path);if(!a){t.ui.notify(`Teammate "${e.target}" not found`,"error");return}r.sendMessage({customType:m,content:`Granted ${e.target} write access to ${a}`,display:!0});break}}},"handler")})}p(K,"teamExtension");function O(r){switch(r){case"team:spawn":return"Create a persistent teammate (/team:spawn <role> [--name <name>])";case"team:send":return"Send work or a note to a teammate (/team:send <name> <message>)";case"team:status":return"Show team or teammate status";case"team:stop":return"Stop teammate's current turn";case"team:terminate":return"Remove a teammate";case"team:approve":return"Approve a teammate request";case"team:mode":return"Change how a teammate works (/team:mode <name> <plan|execute|review>)";case"team:preset":return"Create teammates from a preset";case"team:dashboard":return"Toggle the team dashboard";case"team:progress":return"Show teammate progress";case"team:psyche":return"Show teammate decision settings";case"team:task":return"Manage shared team tasks";case"team:mail":return"Send a note from one teammate to another";case"team:allow-path":return"Grant a teammate write access to a path prefix";default:return"Create or manage teammates"}}p(O,"getCommandDescription");export{K as default};

package/dist/extensions/builtin/team/team-dashboard.d.ts

@@ -0,0 +1,13 @@
+/**
+ * [WHO]: Provides renderTeamDashboard(), renderTeamFooterStatus()
+ * [FROM]: Depends on ./team-types and ./team-psyche formatting helpers
+ * [TO]: Consumed by index.ts to render /team:dashboard widget and footer status text
+ * [HERE]: extensions/builtin/team/team-dashboard.ts - lightweight team workbench dashboard
+ */
+import type { PersistedTeammate } from "./team-types.js";
+interface TeamDashboardOptions {
+    expanded?: boolean;
+}
+export declare function renderTeamDashboard(teammates: PersistedTeammate[], width?: number, options?: TeamDashboardOptions): string[];
+export declare function renderTeamFooterStatus(teammates: PersistedTeammate[]): string | undefined;
+export {};

package/dist/extensions/builtin/team/team-dashboard.js

@@ -0,0 +1 @@
+var v=Object.defineProperty;var i=(n,r)=>v(n,"name",{value:r,configurable:!0});function T(n,r=80,e={}){if(n.length===0)return["Team: no agents"];const t=Math.max(58,Math.min(r,100)),c=n.filter(s=>s.status==="running").length,h=n.filter(s=>s.liveView?.blockedOn||s.status==="error").length,f=e.expanded?6:4,g=k(n).slice(0,f),p=Math.max(0,n.length-g.length),o=t-2,l=[`+${u(` Team Workbench  ${n.length} agents | ${c} running | ${h} blocked `,o,"-")}+`];for(const s of g)l.push(`|${u(a(s,o),o)}|`);p>0&&l.push(`|${u(`+ ${p} more agents`,o)}|`);const $=x(n,e.expanded?2:1);for(const s of $)l.push(`|${u(`${s.name}: ${s.text}`,o)}|`);return l.push(`+${"-".repeat(o)}+`),l}i(T,"renderTeamDashboard");function W(n){if(n.length===0)return;const r=n.filter(t=>t.status==="running").length,e=n.slice(0,3).map(t=>{const c=t.liveView?.progress?` ${t.liveView.progress}`:"";return`${t.identity.name}:${t.status}${c}`}).join(" | ");return`team: ${n.length} agents${r?` (${r} running)`:""} | ${e}`}i(W,"renderTeamFooterStatus");function a(n,r){const e=n.liveView,t=11,c=12,h=13,f=Math.max(12,r-t-c-h-8),g=V(n.status),p=u(d(n.identity.name,t),t),o=u(d(n.identity.role,c),c),l=u(d(w(n),h),h),$=d(e?.currentTask??e?.lastUtterance??"-",f);return`${g} ${p} ${o} ${l} ${$}`}i(a,"renderAgentLine");function w(n){return n.liveView?.blockedOn?`blocked:${n.liveView.blockedOn}`:n.liveView?.progress?n.liveView.progress:n.live?.phase?n.live.toolName?`${n.live.phase}:${n.live.toolName}`:n.live.phase:n.status}i(w,"formatState");function x(n,r){return n.map(e=>({name:e.identity.name,text:b(e.liveView?.lastUtterance??e.live?.preview??""),timestamp:e.lastActiveAt})).filter(e=>e.text.length>0).sort((e,t)=>t.timestamp-e.timestamp).slice(0,r).map(e=>({...e,text:d(e.text,74)}))}i(x,"latestUtterances");function k(n){const r=i(e=>e.status==="running"?0:e.liveView?.blockedOn||e.status==="error"?1:e.liveView?.progress&&e.liveView.progress!=="done"?2:3,"rank");return[...n].sort((e,t)=>r(e)-r(t)||t.lastActiveAt-e.lastActiveAt)}i(k,"prioritizeTeammates");function V(n){switch(n){case"idle":return"o";case"running":return"*";case"stopped":return"!";case"error":return"x";case"terminated":return"-"}}i(V,"statusIcon");function d(n,r){return n.length<=r?n:`${n.slice(0,Math.max(0,r-3))}...`}i(d,"truncate");function b(n){return n.replace(/\s+/g," ").trim()}i(b,"singleLine");function u(n,r,e=" "){const t=d(n,r);return t+e.repeat(Math.max(0,r-t.length))}i(u,"pad");export{T as renderTeamDashboard,W as renderTeamFooterStatus};

package/dist/extensions/builtin/team/team-harness.d.ts

@@ -0,0 +1,35 @@
+/**
+ * [WHO]: Provides createInitialHarnessState(), beginHarnessTurn(), buildHarnessInstructions(), prepareContextFiles(), inspectHarnessExit()
+ * [FROM]: Depends on node fs/path and ./team-types for harness state and feature contracts
+ * [TO]: Consumed by team-runtime.ts, team-presets.ts, index.ts to coordinate long-running AgentTeam work
+ * [HERE]: extensions/builtin/team/team-harness.ts - Anthropic-style harness protocol helpers for /team teammates
+ */
+import type { HarnessFeature, HarnessPhase, HarnessState } from "./team-types.js";
+import type { SubAgentResult } from "../../../core/sub-agent/index.js";
+export interface HarnessFeatureList {
+    version: 1;
+    generatedAt: string;
+    taskDescription: string;
+    features: HarnessFeature[];
+}
+export interface HarnessExitResult {
+    harness: HarnessState;
+    violations: string[];
+    event: string;
+}
+export declare function createInitialHarnessState(): HarnessState;
+export declare function ensureHarnessFiles(harness: HarnessState, cwd: string, taskDescription: string): Promise<void>;
+export declare function beginHarnessTurn(harness: HarnessState, cwd: string): Promise<HarnessState>;
+export declare function buildHarnessInstructions(harness: HarnessState, cwd: string, taskDescription: string): Promise<string>;
+export declare function buildInitPhaseInstructions(harness: HarnessState, taskDescription: string, cwd: string): string;
+export declare function buildCodingPhaseInstructions(harness: HarnessState, featureListContent: string, progressContent: string): string;
+export declare function buildVerifyPhaseInstructions(harness: HarnessState, featureListContent: string): string;
+export declare function buildFixPhaseInstructions(harness: HarnessState, verifyReport: string | null, featureListContent: string): string;
+export declare function buildCompletePhaseInstructions(harness: HarnessState, featureListContent: string): string;
+export declare function prepareContextFiles(harness: HarnessState): string[];
+export declare function inspectHarnessExit(harness: HarnessState, cwd: string, result: SubAgentResult): Promise<HarnessExitResult>;
+export declare function validateFeatureList(original: Omit<HarnessFeature, "passes">[], current: HarnessFeature[]): string[];
+export declare function resolveNextPhase(harness: Pick<HarnessState, "phase" | "totalFeatures" | "passedFeatures">, previousPhase?: HarnessPhase, violations?: string[]): HarnessPhase;
+export declare function formatHarnessProgress(harness: HarnessState | undefined): string[];
+export declare function createHarnessCheckpoint(cwd: string, message: string): Promise<string | null>;
+export declare function revertHarnessChanges(cwd: string, preTurnCommit: string | null, violations: string[]): Promise<string | null>;

package/dist/extensions/builtin/team/team-harness.js

@@ -0,0 +1,18 @@
+var C=Object.defineProperty;var a=(t,e)=>C(t,"name",{value:e,configurable:!0});import{execFile as P}from"node:child_process";import{mkdir as x,readFile as m,writeFile as w}from"node:fs/promises";import{dirname as k,isAbsolute as S,resolve as H}from"node:path";import{promisify as b}from"node:util";const R=".catui-harness/feature_list.json",A=".catui-harness/progress.txt",L=".catui-harness/init.sh",E=b(P);function X(){return{enabled:!0,phase:"init",featureListPath:R,progressPath:A,initScriptPath:L,totalFeatures:0,passedFeatures:0,currentFeature:null,lastVerifyReport:null,cycleCount:0,featureSnapshot:[],preTurnCommit:null,lastCheckpointCommit:null,lastRevertCommit:null,lastEvent:"Harness initialized"}}a(X,"createInitialHarnessState");async function Y(t,e,r){await h(e,t.featureListPath),await h(e,t.progressPath),await h(e,t.initScriptPath),await g(e,t.progressPath,["=== Session 0 ===",`Date: ${new Date().toISOString()}`,`Phase: ${t.phase}`,"Status: initialized",`Task: ${r}`,"Notes: Harness files were prepared by TeamRuntime.",""].join(`
+`)),await g(e,t.initScriptPath,["#!/usr/bin/env bash","set -euo pipefail","# Add reproducible setup commands here.",""].join(`
+`))}a(Y,"ensureHarnessFiles");async function Z(t,e){const r={...t};return r.preTurnCommit=await d(e),r}a(Z,"beginHarnessTurn");async function tt(t,e,r){const i=await p(e,t.featureListPath),n=await p(e,t.progressPath);switch(t.phase){case"init":return T(t,r,e);case"coding":return I(t,i,n);case"verify":return j(t,i);case"fix":return _(t,t.lastVerifyReport,i);case"complete":return D(t,i)}}a(tt,"buildHarnessInstructions");function T(t,e,r){return["## Harness Phase: init","",`Task: ${e}`,`Working directory: ${r}`,"","Create or update the harness files before doing implementation work:",`- ${t.featureListPath}: JSON matching { version: 1, generatedAt, taskDescription, features[] }`,`- ${t.progressPath}: human-readable progress log`,`- ${t.initScriptPath}: reproducible setup/check script if useful`,"","Feature rules:","- Use stable feature ids such as F001, F002.","- Each feature needs category, description, steps, passes=false, and priority.","- Do not implement features during init. Stop after the harness plan is written."].join(`
+`)}a(T,"buildInitPhaseInstructions");function I(t,e,r){return["## Harness Phase: coding","","Read the injected feature list and progress. Choose exactly one feature with passes=false, implement it, run its verification steps, then update progress.",`Current progress: ${t.passedFeatures}/${t.totalFeatures}`,"","Feature list snapshot:",l(e),"","Progress snapshot:",l(r)].join(`
+`)}a(I,"buildCodingPhaseInstructions");function j(t,e){return["## Harness Phase: verify","","Act as a strict verifier. Re-run or reason through every feature marked passes=true.","If a feature is not actually verified, set passes=false and record the reason in progress.txt.",`Current claimed progress: ${t.passedFeatures}/${t.totalFeatures}`,"","Feature list snapshot:",l(e)].join(`
+`)}a(j,"buildVerifyPhaseInstructions");function _(t,e,r){return["## Harness Phase: fix","","Fix only the failed or downgraded features from the previous verify phase, then re-run their verification steps.",e?`Last verify report:
+${e}`:"No verify report was captured; inspect feature_list.json for passes=false items.","","Feature list snapshot:",l(r)].join(`
+`)}a(_,"buildFixPhaseInstructions");function D(t,e){return["## Harness Phase: complete","","All tracked features are currently passing. Summarize the verification evidence and avoid new implementation work unless the leader asks for more.",`Final progress: ${t.passedFeatures}/${t.totalFeatures}`,"","Feature list snapshot:",l(e)].join(`
+`)}a(D,"buildCompletePhaseInstructions");function et(t){const e=[t.progressPath,t.initScriptPath];return(t.phase!=="init"||t.totalFeatures>0)&&e.unshift(t.featureListPath),e}a(et,"prepareContextFiles");async function rt(t,e,r){const i={...t},n=t.phase,s=await V(e,t.featureListPath),u=s?N(t.featureSnapshot,s.features):[],v=u.length>0;s&&(i.totalFeatures=s.features.length,i.passedFeatures=s.features.filter(c=>c.passes).length,i.currentFeature=s.features.find(c=>!c.passes)?.description??null,i.featureSnapshot.length===0&&s.features.length>0&&(i.featureSnapshot=z(s.features)));const $=await p(e,t.progressPath);if((n==="verify"||!r.success)&&(i.lastVerifyReport=r.response??r.error??$.slice(-2e3)),i.phase=U(i,n,u),v){const c=await O(e,t.preTurnCommit,u);i.lastRevertCommit=c??i.lastRevertCommit}else{const c=await G(e,J(n,i));i.lastCheckpointCommit=c??i.lastCheckpointCommit}return n==="init"&&i.phase==="coding"&&(i.cycleCount+=1),i.lastEvent=M(n,i.phase,i,u),{harness:i,violations:u,event:i.lastEvent}}a(rt,"inspectHarnessExit");function N(t,e){if(t.length===0)return[];const r=[];t.length!==e.length&&r.push(`feature count changed: ${t.length} -> ${e.length}`);for(const[i,n]of t.entries()){const s=e[i];s&&(s.id!==n.id&&r.push(`feature ${i+1} id changed`),s.category!==n.category&&r.push(`feature ${n.id} category changed`),s.description!==n.description&&r.push(`feature ${n.id} description changed`),s.priority!==n.priority&&r.push(`feature ${n.id} priority changed`),s.steps.join(`
+`)!==n.steps.join(`
+`)&&r.push(`feature ${n.id} steps changed`))}return r}a(N,"validateFeatureList");function U(t,e=t.phase,r=[]){return r.length>0?"fix":t.totalFeatures===0?"init":t.passedFeatures>=t.totalFeatures?e==="verify"||e==="complete"?"complete":"verify":e==="verify"?"fix":"coding"}a(U,"resolveNextPhase");function it(t){if(!t?.enabled)return["Harness: disabled"];const e=t.totalFeatures>0?Math.round(t.passedFeatures/t.totalFeatures*100):0;return[`Harness: ${t.phase}`,`  Progress: ${t.passedFeatures}/${t.totalFeatures} (${e}%)`,`  Current: ${t.currentFeature??"none"}`,`  Cycle: ${t.cycleCount}`,...t.lastCheckpointCommit?[`  Last Checkpoint: ${t.lastCheckpointCommit.slice(0,12)}`]:[],...t.lastRevertCommit?[`  Last Revert: ${t.lastRevertCommit.slice(0,12)}`]:[],`  Files: ${t.featureListPath}, ${t.progressPath}`,...t.lastEvent?[`  Last Event: ${t.lastEvent}`]:[]]}a(it,"formatHarnessProgress");async function G(t,e){if(!await y(t))return null;if(!await F(t))return await d(t);try{return await o(t,["add","-A"]),await o(t,["commit","-m",e]),await d(t)}catch{return null}}a(G,"createHarnessCheckpoint");async function O(t,e,r){if(!e||!await y(t)||!await F(t))return null;try{return(await o(t,["status","--porcelain"])).stdout.trim()?(await o(t,["add","-A"]),await o(t,["commit","-m",`harness: quarantine invalid turn
+
+${r.join(`
+`)}`]),await o(t,["revert","--no-edit","HEAD"]),await d(t)):null}catch{return null}}a(O,"revertHarnessChanges");async function V(t,e){const r=await p(t,e);if(r.trim())try{const i=JSON.parse(r);return i.version!==1||!Array.isArray(i.features)?void 0:i}catch{return}}a(V,"readFeatureList");function z(t){return t.map(({passes:e,...r})=>r)}a(z,"snapshotFeatures");async function p(t,e){try{return await m(f(t,e),"utf8")}catch{return""}}a(p,"readRelativeFile");async function g(t,e,r){try{await m(f(t,e),"utf8")}catch{await w(f(t,e),r,"utf8")}}a(g,"writeIfMissing");async function h(t,e){await x(k(f(t,e)),{recursive:!0})}a(h,"ensureParent");function f(t,e){return S(e)?e:H(t,e)}a(f,"resolvePath");function l(t){return t.trim()?t.length>6e3?`${t.slice(0,6e3)}
+... (truncated)`:t:"(empty or unavailable)"}a(l,"truncateForPrompt");function M(t,e,r,i){const n=i.length>0?` with ${i.length} feature-list violation(s)`:"",s=r.lastCheckpointCommit?`; checkpoint ${r.lastCheckpointCommit.slice(0,12)}`:"",u=r.lastRevertCommit?`; revert ${r.lastRevertCommit.slice(0,12)}`:"";return`Phase ${t} -> ${e}; progress ${r.passedFeatures}/${r.totalFeatures}${n}${s}${u}`}a(M,"buildHarnessEvent");function J(t,e){return`harness: ${t} checkpoint
+
+Progress: ${e.passedFeatures}/${e.totalFeatures}
+Next phase: ${e.phase}`}a(J,"buildCheckpointMessage");async function y(t){try{return await o(t,["rev-parse","--is-inside-work-tree"]),!0}catch{return!1}}a(y,"isGitRepository");async function F(t){try{return(await o(t,["status","--porcelain"])).stdout.trim().length>0}catch{return!1}}a(F,"hasGitChanges");async function d(t){try{return(await o(t,["rev-parse","HEAD"])).stdout.trim()||null}catch{return null}}a(d,"getGitHead");async function o(t,e){const r=await E("git",e,{cwd:t,encoding:"utf8",maxBuffer:1048576});return{stdout:String(r.stdout??""),stderr:String(r.stderr??"")}}a(o,"git");export{Z as beginHarnessTurn,I as buildCodingPhaseInstructions,D as buildCompletePhaseInstructions,_ as buildFixPhaseInstructions,tt as buildHarnessInstructions,T as buildInitPhaseInstructions,j as buildVerifyPhaseInstructions,G as createHarnessCheckpoint,X as createInitialHarnessState,Y as ensureHarnessFiles,it as formatHarnessProgress,rt as inspectHarnessExit,et as prepareContextFiles,U as resolveNextPhase,O as revertHarnessChanges,N as validateFeatureList};