@difflab/pi 0.4.0-rc.202609231106.845dbe5 → 0.4.0

package/dist/tools/log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../src/tools/log.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAoBlF,eAAO,MAAM,aAAa,EAAE,cA0B1B,CAAC"}
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../src/tools/log.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAsBlF,eAAO,MAAM,aAAa,EAAE,cA0B1B,CAAC"}

package/dist/tools/modes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../src/tools/modes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAGlF,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,UAAU,CAAC;AAiB5D,wBAAgB,eAAe,CAAC,UAAU,EAAE,cAAc,GAAG,SAAS,cAAc,EAAE,CAiErF"}
+{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../src/tools/modes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAElF,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,UAAU,CAAC;AAiB5D,wBAAgB,eAAe,CAAC,UAAU,EAAE,cAAc,GAAG,SAAS,cAAc,EAAE,CAiErF"}

package/dist/tools/plan.d.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ToolDefinition } from '@earendil-works/pi-coding-agent';
 import type { ModeController } from '../modes';
-import { type PlanStore } from '../plan/store';
+import { type PlanController } from '../plan';
 export type PlanToolRuntime = Pick<ExtensionAPI, 'events' | 'sendUserMessage'> & Partial<Pick<ExtensionAPI, 'sendMessage'>>;
-export declare function createPlanTools(_pi: PlanToolRuntime, _modes: ModeController, store?: PlanStore): readonly ToolDefinition[];
+export declare function createPlanTools(pi: PlanToolRuntime, modes: ModeController, store?: PlanController): readonly ToolDefinition[];
 //# sourceMappingURL=plan.d.ts.map

package/dist/tools/plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/tools/plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAQpF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAM/C,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAmBhE,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,iBAAiB,CAAC,GAC5E,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC;AAE7C,wBAAgB,eAAe,CAC7B,GAAG,EAAE,eAAe,EACpB,MAAM,EAAE,cAAc,EACtB,KAAK,GAAE,SAA6B,GACnC,SAAS,cAAc,EAAE,CA6W3B"}
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/tools/plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAoB,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAQtG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAML,KAAK,cAAc,EAEpB,MAAM,SAAS,CAAC;AAiCjB,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,iBAAiB,CAAC,GAC5E,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC,CAAC;AAE7C,wBAAgB,eAAe,CAC7B,EAAE,EAAE,eAAe,EACnB,KAAK,EAAE,cAAc,EACrB,KAAK,GAAE,cAAuC,GAC7C,SAAS,cAAc,EAAE,CAimB3B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@difflab/pi",
-  "version": "0.4.0-rc.202609231106.845dbe5",
+  "version": "0.4.0",
   "description": "Tools and skills for the pi coding agent",
   "repository": {
     "type": "git",
@@ -34,8 +34,7 @@
     "agents/",
     "dist/",
     "skills/",
-    "templates/",
-    "workflows/"
+    "templates/"
   ],
   "pi": {
     "extensions": [
@@ -58,7 +57,6 @@
   },
   "dependencies": {
     "@juicesharp/rpiv-ask-user-question": "^2.10.1",
-    "cmd-ts": "^0.15.0",
     "commander": "^14.0.0",
     "mdast-builder": "1.1.1",
     "pi-mcp-adapter": "^2.33.0",

package/skills/plan/SKILL.md

@@ -1,23 +1,15 @@
 ---
 name: plan
-description: Route natural-language planning requests to Diffpi's /plan commands. Use when a user wants to create, revise, annotate, finalize, or execute a durable plan, or asks which /plan command to run.
-allowed-tools: ask_user_question
+description: Create, annotate, validate, update, and execute durable Diffpi plans. Use for /plan workflows, implementation planning, plan annotations, and resumable plan execution.
+allowed-tools: Agent get_subagent_result steer_subagent ask_user_question plan_context plan_init plan_update_overview plan_add_phase plan_remove_phase plan_update_phase plan_validate plan_annotate plan_annotations plan_ack_annotations plan_log_progress plan_update_status plan_run_gates plan_watch_ci plan_start_execution diffpi_modes_set diffpi_modes_unset
 ---
 
-# Plan Command Guide
+# plan
 
-Use `/plan` commands as the execution boundary. Do not reproduce their workflows, call `plan_*` tools directly, or edit managed plan files.
+Parse the first argument as `init`, `new`, `update`, `annotate`, `finalize`, `go`, or `help`. An empty or unknown verb uses [help](references/workflows/help.md). Read and follow `references/workflows/<verb>.md`.
 
-## Natural-language routing
+Foreground `init`, `new`, and `update` run in Planner mode. Foreground `annotate`, `finalize`, `go`, and `help` run in Worker mode. Finalize exits to the default mode when implementation is deferred, and completed inline execution exits to the default mode automatically.
 
-Map the user's intent to one command:
+`--bg` is handled and removed by the `/plan` extension command. A simple background `new`, `update`, or `go` dispatch starts one named planner/orchestrator through the pi-subagents cross-extension RPC; do not add an extra model turn, invoke recursive Pi, or use `/bg --agent`. Background workflows never ask questions. They record safe assumptions and return an actionable blocker for unresolved decisions. For additional delegation, use `Agent`, `get_subagent_result`, and `steer_subagent`; use `SubagentWorkflow` when orchestration must be deterministic and multi-stage. Reserve pi-background-tasks for ordinary long-running shell commands, tests, builds, and servers. Foreground workflows use `ask_user_question` for every choice that cannot be derived from the request; never ask in plain chat.
 
-- Create an empty plan shell: `/plan init <short-slug> [--branch <name>]`
-- Research and author a complete plan: `/plan new <short-slug> [--branch <name>] [--bg] [prompt...]`
-- Revise a plan from chat instructions or its current plan review: `/plan update [short-slug] [--branch <name>] [--bg] [instructions...]`
-- Review a plan in tuicr and save the result: `/plan annotate [short-slug]`
-- Validate and mark a plan ready: `/plan finalize [short-slug]`
-- Execute a plan: `/plan go <short-slug> [--mode <no-commit|commit|push>] [--bg]`
-- Show command help: `/plan help`
-
-Infer the command, slug, branch, and free-text arguments from recent conversation when they are clear. If a required value cannot be inferred, use `ask_user_question`; do not ask in plain chat. Then give the user one exact, copyable `/plan` command. Explain defaults only when relevant: `go` uses `--mode no-commit` when `--mode` is omitted.
+Use plan tools for every `PLAN.md`, status, log, gate, and annotation mutation. Do not edit managed plan files directly. Validate after authoring. Preserve stable IDs, user prose, completed evidence, and annotation acknowledgement order.

package/skills/plan/references/workflows/annotate.md

@@ -0,0 +1,6 @@
+# annotate
+
+1. Call `plan_context` and require an exact selection.
+2. Call `plan_annotate`; it uses `tuicr --file PLAN.md`, never `-p` or `--path`.
+3. Report the selected plan, session slug, launch result, and copyable fallback command.
+4. Tell the user to run `/plan update <plan-id>` when comments are ready.

package/skills/plan/references/workflows/finalize.md

@@ -0,0 +1,7 @@
+# finalize
+
+1. Call `plan_context` and use the current persisted plan, including changes authored through chat. Call `plan_annotations` only to check for optional annotation feedback. If `pending` is non-empty, run the update workflow to apply and acknowledge those comments. If no annotation session exists or no comments are pending, skip update and continue directly.
+2. Call `plan_validate` with `strict: true`. Stop on errors, pending annotations, or Design above 800 words.
+3. Mark the draft ready with `plan_update_status`.
+4. Use one `ask_user_question` call to choose the next action and, when executing now, commit policy. Choices are inline execution, background execution, execute later, or continue planning; commit policy is commit per phase or no commits.
+5. For execute later or continue planning, do not ask for or apply a commit policy. Call `diffpi_modes_unset` before returning so finalization exits to the default inline mode. Otherwise call `plan_start_execution` with the selected mode and policy.

package/skills/plan/references/workflows/go.md

@@ -0,0 +1,8 @@
+# go
+
+1. Require a plan slug and call `plan_context`.
+2. Read explicit `--bg`, `--commit`, and `--no-commit` choices already parsed by the command.
+3. If mode or commit policy is missing in foreground mode, use one `ask_user_question` call for only the missing choices. Never silently default.
+4. Background mode never asks. If a required preference is missing, return a blocker with the exact complete command.
+5. Foreground execution runs in `WORKER` mode. Background execution uses Orchestrator and must preserve the foreground mode.
+6. Call `plan_start_execution` with inline/background mode and commit-per-phase/no-commit policy. For `/plan go --bg`, the already-spawned orchestrator must pass `coordinator: current`; normal callers omit it (default `spawn`). Commit-per-phase execution pushes each phase commit, records pending CI, and launches a bounded background Worker to call `plan_watch_ci` while the next phase executes. Collect that monitor before the next push and collect all monitors before completion; failed or timed-out CI blocks execution. When an inline execution marks the plan completed, `plan_update_status` exits to the default mode automatically. Report the execution ID and whether the foreground mode changed.

package/{workflows/plan → skills/plan/references/workflows}/help.md

@@ -1,20 +1,13 @@
 # help
 
-## Arguments
-
-- **Invocation:** `/plan help`
-- This workflow accepts no arguments.
-
-## Instructions
-
-Show these commands:
+Use these commands:
 
 - `/plan init <short-slug> [--branch <name>]` creates a phase-less draft.
 - `/plan new <short-slug> [--branch <name>] [--bg] [prompt...]` creates and populates a plan.
-- `/plan update [short-slug] [--branch <name>] [--bg] [instructions...]` applies the current plan review before other instructions.
-- `/plan annotate [short-slug]` reviews the plan with tuicr and saves an immutable review dump when tuicr closes.
+- `/plan update [short-slug] [--branch <name>] [--bg] [instructions...]` applies pending annotations before other instructions.
+- `/plan annotate [short-slug]` opens `PLAN.md` with `tuicr --file`.
 - `/plan finalize [short-slug]` validates and marks a plan ready.
-- `/plan go <short-slug> [--mode <no-commit|commit|push>] [--bg]` starts execution.
+- `/plan go <short-slug> [--commit|--no-commit] [--bg]` starts execution.
 - `/plan help` shows this reference.
 
 `--branch` records or filters a branch. It does not create or switch branches. Background workflows do not ask questions.

package/skills/plan/references/workflows/init.md

@@ -0,0 +1,6 @@
+# init
+
+1. Require one short slug and accept an optional `--branch`.
+2. Call `plan_init` with the explicit intent and title when supplied. The tool creates only `PLAN.md` and `logs.txt`.
+3. Call `plan_annotate` when the annotation launcher is available. Otherwise show its exact fallback command.
+4. Report the plan ID and explain that `/plan update <id>` imports annotations and populates the draft.

package/skills/plan/references/workflows/new.md

@@ -0,0 +1,8 @@
+# new
+
+1. Require a short slug. Call `plan_context`, then `plan_init` if the plan does not exist.
+2. Ground the plan in repository files and the explicit prompt. If no prompt was supplied, use the inherited conversation context supplied by the named Planner RPC dispatch.
+3. In foreground mode, use `ask_user_question` only for decisions that materially change scope. In background mode, never ask; record safe assumptions and stop with a blocker if ambiguity cannot be resolved.
+4. Use `plan_update_overview`, `plan_add_phase`, and `plan_update_phase` to create the plan. Use the planning tools to enforce the declared requirements, references, phase dependencies, file scopes, steps, and acceptance criteria; do not write PLAN.md by hand when a tool can make the change.
+5. Create one implementation file per phase at `.diffpi/plan/<plan-id>/implementation/phase-<phase-id>.md`. Fill in the implementation template with the phase summary, file tree, public APIs and data contracts, required libraries or algorithms, and implementation constraints. Keep each phase focused on one or two modules or libraries unless it is scaffolding.
+6. Keep Design near 300 words and call `plan_validate`. Leave the result as a draft for annotation or finalization.

package/skills/plan/references/workflows/update.md

@@ -0,0 +1,7 @@
+# update
+
+1. Call `plan_context`. Omit the slug only when exactly one candidate is selected.
+2. Call `plan_annotations` before interpreting prompt instructions. A missing annotation session means there is no annotation work.
+3. Apply each unambiguous pending comment, then the explicit instructions, through `plan_update_overview`, `plan_add_phase`, `plan_remove_phase`, or `plan_update_phase`. Preserve stable IDs and completed evidence.
+4. In foreground mode, use `ask_user_question` for unresolved product decisions. In background mode, do not ask; persist and return a blocker.
+5. Call `plan_validate`. Only after successful application, call `plan_ack_annotations` with exactly the applied comment IDs and a concise summary. Failed or partial updates leave unhandled IDs pending.

package/templates/plan/PLAN.md

@@ -4,8 +4,6 @@
 
 - **Plan ID:** {{id}}
 - **Branch:** {{branch}}
-- **Issue:** {{issue_id}}
-- **Issue URL:** {{issue_url}}
 - **Status:** draft
 - **Revision:** 0
 

package/dist/commands.d.ts

@@ -1,22 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
-import { type Runner } from 'cmd-ts';
-import type { ModeController } from './modes';
-import { type PlanWorkflowArguments, type PlanWorkflowName } from './workflow';
-export type WorkflowAgent = 'planner' | 'orchestrator' | 'reviewer' | 'worker';
-export type WorkflowRuntime = {
-    pi: ExtensionAPI;
-    ctx: ExtensionContext;
-    modes: ModeController;
-};
-export type WorkflowInvocation = {
-    [Name in PlanWorkflowName]: {
-        workflow: Name;
-        arguments: PlanWorkflowArguments[Name];
-        agent?: WorkflowAgent;
-        isBackground?: boolean;
-    };
-}[PlanWorkflowName];
-export declare function tokenizeCommandArgs(raw: string): string[];
-export declare function generateCommandHelp<Args, Result>(command: Runner<Args, Result>): Promise<string>;
-export declare function createWorkflowInvoker(runtime: WorkflowRuntime): (invocation: WorkflowInvocation) => Promise<void>;
-//# sourceMappingURL=commands.d.ts.map

package/dist/commands.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACtF,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAE7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAoB,KAAK,qBAAqB,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAIjG,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,cAAc,GAAG,UAAU,GAAG,QAAQ,CAAC;AAE/E,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,YAAY,CAAC;IACjB,GAAG,EAAE,gBAAgB,CAAC;IACtB,KAAK,EAAE,cAAc,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;KAC9B,IAAI,IAAI,gBAAgB,GAAG;QAC1B,QAAQ,EAAE,IAAI,CAAC;QACf,SAAS,EAAE,qBAAqB,CAAC,IAAI,CAAC,CAAC;QACvC,KAAK,CAAC,EAAE,aAAa,CAAC;QACtB,YAAY,CAAC,EAAE,OAAO,CAAC;KACxB;CACF,CAAC,gBAAgB,CAAC,CAAC;AAIpB,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAwBzD;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAItG;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,eAAe,IACvB,YAAY,kBAAkB,KAAG,OAAO,CAAC,IAAI,CAAC,CAwBpF"}

package/dist/extensions/zodx.d.ts

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-export declare const zx: {
-    cwd: z.ZodOptional<z.ZodString>;
-    id: z.ZodString;
-    revision: z.ZodNumber;
-    text: z.ZodString;
-};
-//# sourceMappingURL=zodx.d.ts.map

package/dist/extensions/zodx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zodx.d.ts","sourceRoot":"","sources":["../../src/extensions/zodx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,EAAE;;;;;CASd,CAAC"}

package/dist/plan/operations.d.ts

@@ -1,43 +0,0 @@
-import type { SubagentEscalation } from '../extensions/subagentx';
-import type { PlanStore } from './store';
-import type { PlanCiStatus, PlanCommit, PlanDocument, PlanPhaseStatus, PlanRecord, PlanStatus } from './types';
-export interface PlanStatusUpdate {
-    target: {
-        type: 'plan' | 'phase' | 'task';
-        id?: string;
-    };
-    expectedStatus: PlanStatus | PlanPhaseStatus;
-    status: PlanStatus | PlanPhaseStatus;
-    actor: string;
-    message: string;
-    executionId?: string;
-    evidence?: string[];
-    blockedReason?: string;
-    attempts?: string[];
-    needsUserDecision?: boolean;
-    commit?: PlanCommit;
-}
-export interface PlanStatusUpdateResult {
-    record: PlanRecord;
-    escalation?: SubagentEscalation;
-}
-export interface PlanCiUpdate {
-    phaseId: string;
-    sha: string;
-    status: Exclude<PlanCiStatus, 'pending'>;
-    actor: string;
-    executionId: string;
-    detail: string;
-}
-export interface PlanCiRetry {
-    phaseId: string;
-    sha: string;
-    actor: string;
-    executionId: string;
-    reason: string;
-}
-export declare function updatePlanStatus(store: PlanStore, cwd: string, query: string, input: PlanStatusUpdate): Promise<PlanStatusUpdateResult>;
-export declare function updatePlanCi(store: PlanStore, cwd: string, query: string, input: PlanCiUpdate): Promise<PlanRecord>;
-export declare function retryPlanCi(store: PlanStore, cwd: string, query: string, input: PlanCiRetry): Promise<PlanRecord>;
-export declare function assertPhasePushEligible(plan: PlanDocument, phaseId: string, executionId: string): void;
-//# sourceMappingURL=operations.d.ts.map

package/dist/plan/operations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../src/plan/operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,KAAK,EAEV,YAAY,EACZ,UAAU,EACV,YAAY,EAEZ,eAAe,EACf,UAAU,EACV,UAAU,EAGX,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACzD,cAAc,EAAE,UAAU,GAAG,eAAe,CAAC;IAC7C,MAAM,EAAE,UAAU,GAAG,eAAe,CAAC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,CAAC,EAAE,kBAAkB,CAAC;CACjC;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,sBAAsB,CAAC,CAkIjC;AAED,wBAAsB,YAAY,CAChC,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,YAAY,GAClB,OAAO,CAAC,UAAU,CAAC,CAwCrB;AAED,wBAAsB,WAAW,CAC/B,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC,UAAU,CAAC,CAoCrB;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAiBtG"}

package/dist/plan/reviews.d.ts

@@ -1,28 +0,0 @@
-import type { PlanRecord } from './types';
-interface PlanReviewDump {
-    schemaVersion: 1;
-    planId: string;
-    planRevision: number;
-    source: 'tuicr';
-    sourceId: string;
-    planSource: string;
-    content: string;
-}
-interface PlanReview {
-    path: string;
-    dump: PlanReviewDump;
-}
-interface PlanReviewRuntime {
-    execute?: (command: string, args: string[], cwd: string, interactive: boolean) => Promise<{
-        code: number;
-        stdout: string;
-        stderr: string;
-    }>;
-}
-export declare function createPlanReview(record: PlanRecord, runtime?: PlanReviewRuntime): Promise<{
-    code: number;
-    review: PlanReview;
-}>;
-export declare function readPlanReview(record: PlanRecord): Promise<PlanReview | undefined>;
-export {};
-//# sourceMappingURL=reviews.d.ts.map

package/dist/plan/reviews.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reviews.d.ts","sourceRoot":"","sources":["../../src/plan/reviews.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAI1C,UAAU,cAAc;IACtB,aAAa,EAAE,CAAC,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,cAAc,CAAC;CACtB;AAED,UAAU,iBAAiB;IACzB,OAAO,CAAC,EAAE,CACR,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,OAAO,KACjB,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChE;AAID,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC,CA4B/C;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAiBxF"}

package/dist/tools/ci.d.ts

@@ -1,6 +0,0 @@
-import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
-export declare const watchCiTool: ToolDefinition<import("typebox").TSchema, {
-    status: "skipped" | "passed" | "failed";
-    detail: string;
-}, any> & ToolDefinition<any, any, any>;
-//# sourceMappingURL=ci.d.ts.map

package/dist/tools/ci.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ci.d.ts","sourceRoot":"","sources":["../../src/tools/ci.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAgBtE,eAAO,MAAM,WAAW;;;uCAmCtB,CAAC"}

package/dist/tools/plan-schema.d.ts

@@ -1,211 +0,0 @@
-import { z } from 'zod';
-declare const planTaskDraftSchema: z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-    steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    fileScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    acceptanceCriteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-declare const planPhaseDraftSchema: z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-    objective: z.ZodString;
-    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    tasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        fileScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        acceptanceCriteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export declare const planContextParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodOptional<z.ZodString>;
-    branch: z.ZodOptional<z.ZodString>;
-    statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        draft: "draft";
-        ready: "ready";
-        in_progress: "in_progress";
-        blocked: "blocked";
-        completed: "completed";
-    }>>>;
-}, z.core.$strict>;
-export declare const planInitParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    shortSlug: z.ZodString;
-    branch: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-    intent: z.ZodOptional<z.ZodString>;
-    issueId: z.ZodOptional<z.ZodString>;
-    issueUrl: z.ZodOptional<z.ZodString>;
-    open: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const planUpdateOverviewParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodString;
-    expectedPlanRevision: z.ZodNumber;
-    intent: z.ZodOptional<z.ZodString>;
-    requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    design: z.ZodOptional<z.ZodObject<{
-        bigIdeas: z.ZodString;
-        keyApiUpdates: z.ZodString;
-        consequences: z.ZodString;
-    }, z.core.$strict>>;
-    references: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        value: z.ZodString;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export declare const planAddPhaseParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodString;
-    expectedPlanRevision: z.ZodNumber;
-    afterPhaseId: z.ZodOptional<z.ZodString>;
-    phase: z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        objective: z.ZodString;
-        dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        tasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            title: z.ZodString;
-            steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            fileScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            acceptanceCriteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const planRemovePhaseParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodString;
-    expectedPlanRevision: z.ZodNumber;
-    phaseId: z.ZodString;
-    reason: z.ZodString;
-}, z.core.$strict>;
-export declare const planUpdatePhaseParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodString;
-    expectedPlanRevision: z.ZodNumber;
-    phaseId: z.ZodString;
-    patch: z.ZodObject<{
-        title: z.ZodOptional<z.ZodString>;
-        objective: z.ZodOptional<z.ZodString>;
-        dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        tasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            title: z.ZodString;
-            steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            fileScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            acceptanceCriteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const planValidateParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodString;
-    strict: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const planLogProgressParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodString;
-    actor: z.ZodString;
-    message: z.ZodString;
-    executionId: z.ZodOptional<z.ZodString>;
-    phaseId: z.ZodOptional<z.ZodString>;
-    taskId: z.ZodOptional<z.ZodString>;
-    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strict>;
-export declare const planRunGatesParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodString;
-    phaseId: z.ZodString;
-    expectedPhaseRevision: z.ZodNumber;
-    executionId: z.ZodString;
-    actor: z.ZodString;
-}, z.core.$strict>;
-export declare const planRecordCiParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodString;
-    phaseId: z.ZodString;
-    sha: z.ZodString;
-    executionId: z.ZodString;
-    actor: z.ZodString;
-    status: z.ZodEnum<{
-        skipped: "skipped";
-        passed: "passed";
-        failed: "failed";
-    }>;
-    detail: z.ZodString;
-    retryReason: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const planLookupParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const planStartExecutionParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodString;
-    commitMode: z.ZodEnum<{
-        push: "push";
-        "no-commit": "no-commit";
-        commit: "commit";
-    }>;
-    actor: z.ZodString;
-}, z.core.$strict>;
-export declare const planUpdateStatusParametersSchema: z.ZodObject<{
-    cwd: z.ZodOptional<z.ZodString>;
-    plan: z.ZodString;
-    target: z.ZodObject<{
-        type: z.ZodEnum<{
-            phase: "phase";
-            task: "task";
-            plan: "plan";
-        }>;
-        id: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    expectedStatus: z.ZodEnum<{
-        draft: "draft";
-        ready: "ready";
-        in_progress: "in_progress";
-        blocked: "blocked";
-        completed: "completed";
-        pending: "pending";
-        skipped: "skipped";
-    }>;
-    status: z.ZodEnum<{
-        draft: "draft";
-        ready: "ready";
-        in_progress: "in_progress";
-        blocked: "blocked";
-        completed: "completed";
-        pending: "pending";
-        skipped: "skipped";
-    }>;
-    actor: z.ZodString;
-    message: z.ZodString;
-    executionId: z.ZodOptional<z.ZodString>;
-    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    blockedReason: z.ZodOptional<z.ZodString>;
-    attempts: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    needsUserDecision: z.ZodOptional<z.ZodBoolean>;
-    commit: z.ZodOptional<z.ZodObject<{
-        sha: z.ZodString;
-        subject: z.ZodString;
-        completedAt: z.ZodString;
-        pushedAt: z.ZodOptional<z.ZodString>;
-        ci: z.ZodOptional<z.ZodObject<{
-            status: z.ZodLiteral<"pending">;
-            startedAt: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type PlanTaskDraft = z.infer<typeof planTaskDraftSchema>;
-export type PlanPhaseDraft = z.infer<typeof planPhaseDraftSchema>;
-export {};
-//# sourceMappingURL=plan-schema.d.ts.map

package/dist/tools/plan-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan-schema.d.ts","sourceRoot":"","sources":["../../src/tools/plan-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,QAAA,MAAM,mBAAmB;;;;;;;kBASd,CAAC;AAEZ,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;kBAQf,CAAC;AAYZ,eAAO,MAAM,2BAA2B;;;;;;;;;;;kBAO7B,CAAC;AAEZ,eAAO,MAAM,wBAAwB;;;;;;;;;kBAW1B,CAAC;AAEZ,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;kBAa3C,CAAC;AAEL,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;kBAQ9B,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;kBAQjC,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;kBAejC,CAAC;AAEZ,eAAO,MAAM,4BAA4B;;;;kBAE9B,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;;;;;kBAYjC,CAAC;AAEZ,eAAO,MAAM,4BAA4B;;;;;;;kBAS9B,CAAC;AAEZ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;kBAY9B,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;kBAAkE,CAAC;AAE1G,eAAO,MAAM,kCAAkC;;;;;;;;;kBAOpC,CAAC;AAEZ,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+BlC,CAAC;AAEZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/workflow.d.ts

@@ -1,33 +0,0 @@
-export type PlanWorkflowName = 'init' | 'new' | 'update' | 'annotate' | 'finalize' | 'go' | 'help';
-export type PlanWorkflowArguments = {
-    init: {
-        plan: string;
-        branch?: string;
-    };
-    new: {
-        plan: string;
-        branch?: string;
-        background: boolean;
-        prompt?: string;
-    };
-    update: {
-        plan?: string;
-        branch?: string;
-        background: boolean;
-        instructions?: string;
-    };
-    annotate: {
-        plan?: string;
-    };
-    finalize: {
-        plan?: string;
-    };
-    go: {
-        plan: string;
-        commitMode: 'no-commit' | 'commit' | 'push';
-        background: boolean;
-    };
-    help: Record<string, never>;
-};
-export declare function loadPlanWorkflow<Name extends PlanWorkflowName>(name: Name, args: PlanWorkflowArguments[Name]): Promise<string>;
-//# sourceMappingURL=workflow.d.ts.map

package/dist/workflow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,IAAI,GAAG,MAAM,CAAC;AAEnG,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7E,MAAM,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACvF,QAAQ,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5B,QAAQ,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5B,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC;IACvF,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC7B,CAAC;AAIF,wBAAsB,gBAAgB,CAAC,IAAI,SAAS,gBAAgB,EAClE,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,qBAAqB,CAAC,IAAI,CAAC,GAChC,OAAO,CAAC,MAAM,CAAC,CAMjB"}

package/workflows/plan/annotate.md

@@ -1,13 +0,0 @@
-# annotate
-
-## Arguments
-
-- **Invocation:** `/plan annotate [short-slug]`
-- `[short-slug]` (optional): Plan to annotate. Omit it only when context resolves exactly one plan.
-
-## Instructions
-
-1. Call `plan_context` and infer planId from the provided short slug/conversation context. Fall back to looking at available active plan candidates, and ask user which to annotate listing available options.
-2. Call `plan_annotate`; it uses `tuicr --file .diffpi/plan/{planId}`, never `-p` or `--path`.
-3. Report the selected plan, launch result, and copyable fallback command. Closing tuicr saves one immutable plan review for the current plan revision.
-4. Tell the user to run `/plan update <plan-id>` after closing tuicr.

package/workflows/plan/finalize.md

@@ -1,15 +0,0 @@
-# finalize
-
-## Arguments
-
-- **Invocation:** `/plan finalize [short-slug]`
-- `[short-slug]` (optional): Plan to validate and mark ready. Omit it only when context resolves exactly one plan.
-
-## Instructions
-
-1. Call `plan_context` and use the current persisted plan, including changes authored through chat.
-2. Call `plan_review` once. If a review exists for the current plan revision, apply its feedback using the update workflow's mutation rules. If no review exists, continue directly.
-3. Call `plan_validate` with `strict: true`. Address validation issues and stop on unresolved errors or Design above 800 words.
-4. Mark the draft ready with `plan_update_status`.
-5. Use one `ask_user_question` call to choose the next action. Choices are foreground execution, background execution, execute later, or continue planning. When execution is selected, also ask for `no-commit`, `commit`, or `push` mode.
-6. Call `diffpi_modes_unset` before returning so finalization exits to the default inline mode. For execution, return the exact `/plan go <short-slug> --mode <mode>` command, adding `--bg` for background execution. Do not call `plan_start_execution`; `/plan go` routes execution to Orchestrator.

package/workflows/plan/go.md

@@ -1,20 +0,0 @@
-# go
-
-## Arguments
-
-- **Invocation:** `/plan go <short-slug> [--mode <no-commit|commit|push>] [--bg]`
-- `<short-slug>` (required): Plan to execute.
-- `--mode no-commit` (optional, default): Execute without creating commits.
-- `--mode commit` (optional): Create one local commit after each completed phase. Do not push or monitor remote CI.
-- `--mode push` (optional): Create and push one commit after each completed phase, then monitor remote CI before completion.
-- `--bg` (optional): Launch the execution Orchestrator in the background and preserve the current foreground mode.
-
-## Instructions
-
-1. Call `plan_context` with the supplied slug.
-2. Read the requested commit mode from `--mode`. Use `no-commit` when the flag is omitted. Do not ask the user to select a commit mode.
-3. Reject values other than `no-commit`, `commit`, or `push`. The command parser normally performs this validation before invoking the workflow.
-4. The command has already selected the foreground Orchestrator or launched the background Orchestrator. Continue as the current Orchestrator and launch implementation Workers as needed.
-5. Call `plan_start_execution` with the selected commit mode. This tool initializes durable execution state and returns the execution packet. It does not select a mode, send another turn, or launch an agent.
-6. In `no-commit` mode, do not create or push commits. In `commit` mode, create one local commit after each phase passes its gates, but do not push or monitor remote CI. In `push` mode, commit and push each phase, record pending CI, and launch a bounded background Worker to call `watch_ci` for the exact commit and then `plan_record_ci` for the phase while the next phase executes. Collect that monitor before the next push and collect all monitors before completion; failed or timed-out CI blocks execution.
-7. For foreground execution, call `diffpi_modes_unset` after the plan is completed. Background execution must not change the foreground mode. Report the execution ID and selected commit mode.