@difflab/pi 0.4.0 → 0.5.0-rc.202609231313.eaf7fa0

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;AAsBlF,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;AAoBlF,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;AAElF,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;AAGlF,OAAO,KAAK,EAAe,cAAc,EAAE,MAAM,UAAU,CAAC;AAiB5D,wBAAgB,eAAe,CAAC,UAAU,EAAE,cAAc,GAAG,SAAS,cAAc,EAAE,CAiErF"}

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

@@ -0,0 +1,211 @@
+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

@@ -0,0 +1 @@
+{"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/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 PlanController } from '../plan';
+import { type PlanStore } from '../plan/store';
 export type PlanToolRuntime = Pick<ExtensionAPI, 'events' | 'sendUserMessage'> & Partial<Pick<ExtensionAPI, 'sendMessage'>>;
-export declare function createPlanTools(pi: PlanToolRuntime, modes: ModeController, store?: PlanController): readonly ToolDefinition[];
+export declare function createPlanTools(_pi: PlanToolRuntime, _modes: ModeController, store?: PlanStore): 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,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"}
+{"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"}

package/dist/tools/review.d.ts

@@ -1,34 +1,4 @@
 import { type ToolDefinition } from '@earendil-works/pi-coding-agent';
-import { type ReviewComment, type ReviewThreadRecord } from '../review';
-export declare function hasReviewDraft(comments: readonly ReviewComment[], body: string): boolean;
-export declare function partitionReviewComments(comments: readonly ReviewComment[], knownFingerprints: ReadonlySet<string>, model: string): {
-    checkpointed: {
-        source: ReviewComment;
-        published: {
-            body: string;
-            file: string;
-            line?: number;
-            side?: import("..").ReviewSide;
-            author?: string;
-            sourceCommentId?: string;
-        };
-        fingerprint: string;
-    }[];
-    candidates: {
-        source: ReviewComment;
-        published: {
-            body: string;
-            file: string;
-            line?: number;
-            side?: import("..").ReviewSide;
-            author?: string;
-            sourceCommentId?: string;
-        };
-        fingerprint: string;
-    }[];
-};
-export declare function resolveReviewThread(comment: ReviewComment, threads: readonly ReviewThreadRecord[]): ReviewThreadRecord | undefined;
 export declare function workingTreeDiff(cwd: string): Promise<string>;
 export declare function createReviewTools(): readonly ToolDefinition[];
-export declare function syncLocalThreadArtifact(path: string, title: string, sessionSlug: string, threads: readonly ReviewThreadRecord[]): Promise<ReviewThreadRecord[]>;
 //# sourceMappingURL=review.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"review.d.ts","sourceRoot":"","sources":["../../src/tools/review.ts"],"names":[],"mappings":"AAGA,OAAO,EAAqC,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAMzG,OAAO,EAwBL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACxB,MAAM,WAAW,CAAC;AAwEnB,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAExF;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,SAAS,aAAa,EAAE,EAClC,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,EACtC,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;EAUd;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,SAAS,kBAAkB,EAAE,GACrC,kBAAkB,GAAG,SAAS,CAmBhC;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAalE;AAID,wBAAgB,iBAAiB,IAAI,SAAS,cAAc,EAAE,CAyc7D;AAID,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,SAAS,kBAAkB,EAAE,GACrC,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAwB/B"}
+{"version":3,"file":"review.d.ts","sourceRoot":"","sources":["../../src/tools/review.ts"],"names":[],"mappings":"AAGA,OAAO,EAAqC,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AA2EzG,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAalE;AAID,wBAAgB,iBAAiB,IAAI,SAAS,cAAc,EAAE,CAma7D"}

package/dist/workflow.d.ts

@@ -0,0 +1,80 @@
+export type PlanWorkflowName = 'init' | 'new' | 'update' | 'annotate' | 'finalize' | 'go' | 'help';
+export type ReviewWorkflowName = 'auto' | 'new' | 'edit' | 'address' | 'publish' | 'complete' | 'merge' | '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 type ReviewWorkflowArguments = {
+    auto: {
+        target?: string;
+        local: boolean;
+        background: boolean;
+    };
+    new: {
+        title?: string;
+        intent?: string;
+        base?: string;
+        local: boolean;
+        background: boolean;
+    };
+    edit: {
+        target?: string;
+        local: boolean;
+        background: boolean;
+    };
+    address: {
+        target?: string;
+        local: boolean;
+        background: boolean;
+    };
+    publish: {
+        target?: string;
+        comment: boolean;
+        approve: boolean;
+        requestChanges: boolean;
+        close: boolean;
+        background: boolean;
+    };
+    complete: {
+        target?: string;
+        local: boolean;
+        approve: boolean;
+        reject: boolean;
+        abandon: boolean;
+        background: boolean;
+    };
+    merge: {
+        target?: string;
+        background: boolean;
+    };
+    help: Record<string, never>;
+};
+export declare function loadPlanWorkflow<Name extends PlanWorkflowName>(name: Name, args: PlanWorkflowArguments[Name]): Promise<string>;
+export declare function loadReviewWorkflow<Name extends ReviewWorkflowName>(name: Name, args: ReviewWorkflowArguments[Name]): Promise<string>;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@difflab/pi",
-  "version": "0.4.0",
+  "version": "0.5.0-rc.202609231313.eaf7fa0",
   "description": "Tools and skills for the pi coding agent",
   "repository": {
     "type": "git",
@@ -34,7 +34,8 @@
     "agents/",
     "dist/",
     "skills/",
-    "templates/"
+    "templates/",
+    "workflows/"
   ],
   "pi": {
     "extensions": [
@@ -57,6 +58,7 @@
   },
   "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,15 +1,23 @@
 ---
 name: plan
-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
+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
 ---
 
-# plan
+# Plan Command Guide
 
-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`.
+Use `/plan` commands as the execution boundary. Do not reproduce their workflows, call `plan_*` tools directly, or edit managed plan files.
 
-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.
+## Natural-language routing
 
-`--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.
+Map the user's intent to one command:
 
-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.
+- 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.

package/skills/review/SKILL.md

@@ -1,17 +1,15 @@
 ---
 name: review
-description: Code review workflows over GitHub, GitLab, or the local tuicr backend. Use for auto reviews, review opening and editing, addressing, publishing, completing, merging, or local review requests.
-allowed-tools: ask_user_question review_context review_new review_edit review_diff review_gates review_submit review_add_comment review_comments review_respond review_publish review_complete review_merge review_launch_ui diffpi_template
+description: Code review workflows over GitHub, GitLab, or local tuicr revision dumps. Use for auto reviews, review opening and editing, addressing, publishing, completing, merging, or local review requests.
+allowed-tools: ask_user_question review_context review_new review_edit review_diff review_gates review_submit review_add_comment review_comments review_dump review_respond review_publish review_complete review_merge review_launch_ui
 ---
 
 # review
 
-Treat `--local` as a backend selector. It always uses the local `tuicr` working-tree backend; without it, the detected GitHub or GitLab forge owns the remote target. Treat `--bg` as an execution selector handled by the `/review` command; it is removed before workflow parsing. Target selection, storage, provenance, templates, comment staging, replies, publication, and forge calls belong to the tools.
+Use the exact package workflow supplied by the `/review` command. Do not look for workflow files inside this skill.
 
-Parse the first non-flag argument as VERB and preserve remaining flags. Normalize `open`, `create`, and `draft` to `new`; normalize `launch` to `auto`, `ready` to `publish`, `close` to `complete`, and `land` to `merge`. An empty or unknown verb uses `references/workflows/help.md`.
+Call `review_context` first. Treat `--local` as a working-tree tuicr flow. A completed local session becomes one immutable review dump; applying feedback starts a new revision. Local reviews have no thread ledger, replies, resolution state, or remote promotion.
 
-Read and follow `references/workflows/{VERB}.md`. Call `review_context` first in every workflow. Use `ask_user_question` for choices that cannot be derived from the request. Never ask those questions as plain chat text.
+Without `--local`, use the detected GitHub or GitLab target directly. Stage findings, read forge threads, post replies, publish status, and perform lifecycle actions through the remote review tools.
 
-For inline execution, `/review auto` and `/review address` activate the reviewer profile on Sol; lifecycle verbs activate the orchestrator profile on Luna. The reviewer coordinates `address`, classifies every thread, and delegates bounded implementation to lightweight worker agents. With `--bg`, the command leaves the current chat mode unchanged and launches one named background orchestrator through the pi-subagents cross-extension RPC. Do not add an extra model turn or use recursive Pi or `/bg --agent` for this dispatch. For further delegation, use `Agent`, `get_subagent_result`, and `steer_subagent`; use `SubagentWorkflow` for deterministic multi-stage orchestration. Reserve pi-background-tasks for ordinary long-running shell commands, tests, builds, and servers.
-
-Workflow index: `auto` generates findings and leaves remote comments pending; `new` creates a local review or remote draft PR/MR; `edit` opens an existing local or remote review for the user; `address` fixes local or remote comments, commits remote fixes through `/git`, and records or posts replies; `publish` promotes pending review work; `complete` approves, rejects, abandons, or archives a review without merging; `merge` is the separate GitHub-only merge action; `help` prints the reference.
+Use `ask_user_question` only for decisions that cannot be derived. Inline `auto` and `address` run under Reviewer; lifecycle workflows run under Orchestrator. Background execution is already routed by the command and must not change the foreground mode.

package/templates/plan/PLAN.md

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

package/workflows/plan/annotate.md

@@ -0,0 +1,13 @@
+# 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

@@ -0,0 +1,15 @@
+# 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

@@ -0,0 +1,20 @@
+# 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.

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

@@ -1,13 +1,20 @@
 # help
 
-Use these commands:
+## Arguments
+
+- **Invocation:** `/plan help`
+- This workflow accepts no arguments.
+
+## Instructions
+
+Show 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 pending annotations before other instructions.
-- `/plan annotate [short-slug]` opens `PLAN.md` with `tuicr --file`.
+- `/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 finalize [short-slug]` validates and marks a plan ready.
-- `/plan go <short-slug> [--commit|--no-commit] [--bg]` starts execution.
+- `/plan go <short-slug> [--mode <no-commit|commit|push>] [--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/workflows/plan/init.md

@@ -0,0 +1,13 @@
+# init
+
+## Arguments
+
+- **Invocation:** `/plan init <short-slug> [--branch <name>]`
+- `<short-slug>` (required): Short, stable name used to identify the plan.
+- `--branch <name>` (optional): Branch metadata to record on the plan. It does not create or switch branches.
+
+## Instructions
+
+1. Call `plan_init` with the supplied slug and branch metadata. Include explicit intent, title and issue tracker id/url when available. The tool creates only `PLAN.md`.
+2. Open `PLAN.md` in supported IDEs/terminals/multiplexers in a new or available chat-adjacent tab. Skip to next step if IDE/terminal/mux is unsupported.
+3. Report the plan ID and path (clickable link so users can click to open in their environment). Explain that `/plan annotate` records a plan review and `/plan update` applies that plan review or direct chat instructions until `/plan finalize` is called.

package/workflows/plan/new.md

@@ -0,0 +1,20 @@
+# new
+
+## Arguments
+
+- **Invocation:** `/plan new <short-slug> [--branch <name>] [--bg] [prompt...]`
+- `<short-slug>` (required): Short, stable name used to identify the plan.
+- `--branch <name>` (optional): Branch metadata to record on the plan. It does not create or switch branches.
+- `--bg` (optional): Whether this is a background agent, or running in chat thread
+- `[prompt...]` (optional): Natural-language scope, requirements, or constraints for the plan.
+
+## Instructions
+
+1. Call `plan_context`, then `plan_init` if the supplied plan does not exist.
+2. In foreground mode, if `prompt` is not provided, ask the user "What would you like to plan?". If its clear from recent chat or branch name what is going to be worked on, provide options for the user to choose from along with a free text entry option. Use `ask_user_question` only for decisions that materially change scope.
+3. In background mode, never ask; record safe assumptions and stop with a blocker if ambiguity cannot be resolved.
+4. Once goal is understood, ground the plan in repository files and the supplied prompt if chat has not established this context..
+5. 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.
+6. 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, preferably one. The only exception is when scaffolding structures for new projects/modules/libraries/etc.
+7. Keep Design near 300 words and call `plan_validate` in the background.
+8. After validation, if in foreground mode, notify the user that you will continue updating the plan with continued conversation. In background mode, finish planning and notify the user that they can explicitly call `/plan update` if they want to make updates and re-enter plan mode. Also notify them to use `/plan finalize` when ready for implementation.

package/workflows/plan/update.md

@@ -0,0 +1,18 @@
+# update
+
+## Arguments
+
+- **Invocation:** `/plan update [short-slug] [--branch <name>] [--bg] [instructions...]`
+- `[short-slug]` (optional): Plan to update. Omit it only when exactly one plan candidate is selected.
+- `--branch <name>` (optional): Branch metadata used to select or update the plan. It does not create or switch branches.
+- `--bg` (optional): Whether workflow is running in a bacground agent or main chat thread.
+- `[instructions...]` (optional): Natural-language changes to apply after the current plan review.
+
+## Instructions
+
+1. Call `plan_context` with the supplied slug and branch metadata. Infer slug based on recency/chat if not provided.
+2. Call `plan_review` before interpreting the supplied instructions. It returns the latest immutable tuicr review dump for the current plan revision. If no review exists, continue with the supplied instructions alone.
+3. Apply the review feedback and then the explicit instructions through `plan_update_overview`, `plan_add_phase`, `plan_remove_phase`, or `plan_update_phase`. Updating the plan advances its revision, so the review dump will not be applied again.
+4. In foreground mode, use `ask_user_question` for requests which need further discussion. In background mode, do not ask; address with best effort.
+5. Call `plan_validate` and address any issues.
+6. Tell the user they can continue updating the plan through chat, run `/plan annotate` for another review, finalize with `/plan finalize`, or proceed to implementation.

package/workflows/review/address.md

@@ -0,0 +1,8 @@
+# address
+
+1. Read `Arguments.target` and `Arguments.local`.
+2. Call `review_context`.
+3. In local mode, call `review_dump`. This saves one immutable review revision and removes the completed tuicr session. Apply its feedback to the working tree, run relevant checks, then call `review_launch_ui` with `local: true` to begin the next revision. Local reviews have no replies or resolution state.
+4. In remote mode, call `review_comments`. Classify every thread and apply only justified changes. Run relevant checks and commit fixes through `/git commit --no-push` when code changes.
+5. For remote threads, call `review_respond` with a concise outcome. Leave the thread open unless the user explicitly requested resolution.
+6. Report changed, answered, skipped, and remaining items. Do not publish, complete, or merge.

package/workflows/review/auto.md

@@ -0,0 +1,8 @@
+# auto
+
+1. Read `Arguments.target` and `Arguments.local`.
+2. Call `review_context` with the selected target and backend.
+3. Create or open the review with `review_new` or `review_edit`.
+4. Run `review_gates`, then call `review_diff` and review only that change.
+5. Produce grounded findings and call `review_submit`. Local findings stay in tuicr. Remote findings stay pending until `/review publish`.
+6. Report the backend, findings, gate results, artifact, and launch instruction. Do not publish, complete, or merge.