@difflab/pi 0.4.0-rc.202609231122.7b4400b → 0.4.0

package/dist/index.js

@@ -176,19 +176,10 @@ var require_extend = __commonJS(function(exports, module) {
 
 // src/config.ts
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { z as z2 } from "zod";
+import { z } from "zod";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-// src/extensions/zodx.ts
-import { z } from "zod";
-var zx = {
-  cwd: z.string().optional(),
-  id: z.string().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  revision: z.number().int().nonnegative(),
-  text: z.string().trim().min(1)
-};
-
 // src/fsx.ts
 import { readdir, readFile } from "node:fs/promises";
 async function readDirectoryIfExists(path) {
@@ -214,12 +205,12 @@ function isMissingPath(error) {
 }
 
 // src/config.ts
-var modelReferenceSchema = zx.text;
-var agentConfigSchema = z2.object({
-  models: z2.array(modelReferenceSchema).optional()
+var modelReferenceSchema = z.string().trim().min(1);
+var agentConfigSchema = z.object({
+  models: z.array(modelReferenceSchema).optional()
 }).strict();
-var diffpiConfigSchema = z2.object({
-  agents: z2.record(z2.string(), agentConfigSchema).optional()
+var diffpiConfigSchema = z.object({
+  agents: z.record(z.string(), agentConfigSchema).optional()
 }).strict();
 function diffpiConfigPaths(homeDir = homedir()) {
   const directory = join(homeDir, ".difflab", "diffpi");
@@ -329,11 +320,7 @@ function run(command, args, options = {}) {
     const child = spawn(command, args, {
       cwd: options.cwd,
       env: options.env ?? process.env,
-      stdio: [
-        options.interactive ? "inherit" : options.input === undefined ? "ignore" : "pipe",
-        options.interactive ? "inherit" : "pipe",
-        "pipe"
-      ],
+      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"],
       signal: options.signal
     });
     let stdout = "";
@@ -350,8 +337,6 @@ function run(command, args, options = {}) {
     });
     child.stderr?.on("data", (chunk) => {
       const text = chunk.toString();
-      if (options.interactive)
-        process.stderr.write(text);
       if (unbounded)
         stderrChunks.push(text);
       else
@@ -603,29 +588,6 @@ function parseRemote(remote) {
 function diffpiLaunchName(cwd, workflow) {
   return `diffpi: ${basename(cwd)} / ${workflow}`;
 }
-async function openFileAdjacent(path, opts) {
-  const env = opts.env ?? process.env;
-  const ide = detectIde(env);
-  if (ide !== "unknown") {
-    const ideCommand = { zed: "zed", vscode: "code", cursor: "cursor", windsurf: "windsurf", jetbrains: "idea" }[ide];
-    if (await findExecutable(ideCommand)) {
-      const result = await run(ideCommand, [path], { cwd: opts.cwd, env });
-      if (result.code === 0)
-        return { launched: true, via: ide, command: `${ideCommand} ${path}` };
-    }
-  }
-  const mux = detectMux(env);
-  if (mux !== "none") {
-    const editor = await resolveEditor(env);
-    if (editor) {
-      const command = [editor, path];
-      const opened = await openMuxTab(mux, command, opts.cwd, opts.name ?? "plan", command.join(" "));
-      if (opened)
-        return opened;
-    }
-  }
-  return { launched: false, via: "print", command: path, reason: "No supported IDE or multiplexer was available." };
-}
 async function openInNewTab(command, opts) {
   const env = opts.env ?? process.env;
   const name = opts.name ?? "review";
@@ -658,15 +620,6 @@ async function openInNewTab(command, opts) {
 function screenWindowArgs(command, cwd, name) {
   return ["-X", "screen", "-t", name, "sh", "-lc", 'cd -- "$1" && shift && exec "$@"', "sh", cwd, ...command];
 }
-async function resolveEditor(env) {
-  const configured = (env.VISUAL ?? env.EDITOR)?.trim().split(/\s+/)[0];
-  if (configured && await findExecutable(configured))
-    return configured;
-  for (const candidate of ["hx", "nvim", "vim"])
-    if (await findExecutable(candidate))
-      return candidate;
-  return;
-}
 async function packageVersion() {
   let value;
   try {
@@ -1279,16 +1232,16 @@ async function discoverMiseTasks(cwd) {
   return parseMiseTasks(result.stdout);
 }
 // src/review/types.ts
-import { z as z3 } from "zod";
-var severitySchema = z3.enum(["BLOCKING", "CONSIDER", "NOTE"]);
-var findingSchema = z3.object({
-  file: z3.string().min(1),
-  line: z3.number().int().nonnegative(),
+import { z as z2 } from "zod";
+var severitySchema = z2.enum(["BLOCKING", "CONSIDER", "NOTE"]);
+var findingSchema = z2.object({
+  file: z2.string().min(1),
+  line: z2.number().int().nonnegative(),
   severity: severitySchema,
-  body: z3.string().min(1),
-  reference: z3.string().optional().default("")
+  body: z2.string().min(1),
+  reference: z2.string().optional().default("")
 });
-var findingsSchema = z3.array(findingSchema);
+var findingsSchema = z2.array(findingSchema);
 function reviewSlug(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
 }
@@ -1349,17 +1302,17 @@ function renderCommentBody(finding) {
   return `${prefix}${finding.body}${reference}`;
 }
 // src/review/review-markdown.ts
-import { z as z4 } from "zod";
-var reviewThreadRecordSchema = z4.object({
-  id: z4.string().min(1),
-  file: z4.string().nullable().optional().transform((value) => value ?? undefined),
-  line: z4.number().int().positive().nullable().optional().transform((value) => value ?? undefined),
-  body: z4.string(),
-  author: z4.string().optional(),
-  resolved: z4.boolean(),
-  addressed: z4.boolean().optional(),
-  question: z4.boolean(),
-  replies: z4.array(z4.string()).optional()
+import { z as z3 } from "zod";
+var reviewThreadRecordSchema = z3.object({
+  id: z3.string().min(1),
+  file: z3.string().nullable().optional().transform((value) => value ?? undefined),
+  line: z3.number().int().positive().nullable().optional().transform((value) => value ?? undefined),
+  body: z3.string(),
+  author: z3.string().optional(),
+  resolved: z3.boolean(),
+  addressed: z3.boolean().optional(),
+  question: z3.boolean(),
+  replies: z3.array(z3.string()).optional()
 });
 function renderReviewDoc(input) {
   const anchored = dedupeFindings(input.findings).filter((finding) => finding.line > 0);
@@ -1446,7 +1399,7 @@ function parseThreadArtifact(content) {
   let threads;
   try {
     const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-    threads = z4.array(reviewThreadRecordSchema).parse(decoded);
+    threads = z3.array(reviewThreadRecordSchema).parse(decoded);
   } catch {
     throw new Error("Cannot parse the Diffpi thread artifact payload.");
   }
@@ -2082,7 +2035,7 @@ function createLocalReviewBackend(options) {
 import { createHash as createHash2 } from "node:crypto";
 import { readFile as readFile7, rename, writeFile as writeFile4 } from "node:fs/promises";
 import { join as join9 } from "node:path";
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
 // src/store.ts
 import { createHash } from "node:crypto";
@@ -2175,13 +2128,13 @@ function projectSlug(repository) {
 }
 
 // src/review/review-state.ts
-var reviewPublicationStateSchema = z5.object({
-  target: z5.string().optional(),
-  bodies: z5.array(z5.string()).default([]),
-  comments: z5.array(z5.string()).default([]),
-  stagedComments: z5.array(z5.string()).default([]),
-  replies: z5.array(z5.string()).default([]),
-  overlayPath: z5.string().optional()
+var reviewPublicationStateSchema = z4.object({
+  target: z4.string().optional(),
+  bodies: z4.array(z4.string()).default([]),
+  comments: z4.array(z4.string()).default([]),
+  stagedComments: z4.array(z4.string()).default([]),
+  replies: z4.array(z4.string()).default([]),
+  overlayPath: z4.string().optional()
 });
 function reviewBodyFingerprint(body) {
   return digest(body);
@@ -2205,7 +2158,7 @@ async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
     if (error.code === "ENOENT") {
       return { path, state: { target, bodies: [], comments: [], stagedComments: [], replies: [] } };
     }
-    if (error instanceof SyntaxError || error instanceof z5.ZodError) {
+    if (error instanceof SyntaxError || error instanceof z4.ZodError) {
       throw new Error(`Cannot parse review publication state: ${path}`);
     }
     throw error;
@@ -2628,93 +2581,271 @@ function parseJsonObject(content, path) {
   } catch {}
   throw new Error(`Expected valid JSON object in ${path}.`);
 }
-// src/plan/store.ts
-import { mkdir as mkdir7, readdir as readdir2, readFile as readFile12, realpath as realpath4, rm as rm2 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname8, join as join16, resolve as resolve4, sep } from "node:path";
+// src/extensions/subagentx.ts
+import { z as z5 } from "zod";
+var escalationSchema = z5.object({
+  correlation: z5.object({
+    workflow: z5.string().min(1),
+    executionId: z5.string().min(1).optional(),
+    unitId: z5.string().min(1).optional(),
+    parentUnitId: z5.string().min(1).optional(),
+    metadata: z5.record(z5.string(), z5.string()).optional()
+  }).strict(),
+  blocker: z5.string().min(1),
+  attempts: z5.array(z5.string()),
+  evidence: z5.array(z5.string()),
+  needsUserDecision: z5.boolean()
+}).strict();
+var ESCALATION_OPEN = "<diffpi-subagent-escalation>";
+var ESCALATION_CLOSE = "</diffpi-subagent-escalation>";
+function renderSubagentEscalation(value) {
+  return `${ESCALATION_OPEN}${JSON.stringify(escalationSchema.parse(value))}${ESCALATION_CLOSE}`;
+}
 
-// src/extensions/fsx.ts
-import { mkdir as mkdir6, rename as rename2, rm, writeFile as writeFile7 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname7, join as join13 } from "node:path";
-async function atomicWrite(path, content) {
-  const temp = join13(dirname7(path), `.${basename5(path)}.${crypto.randomUUID()}.tmp`);
-  await writeFile7(temp, content, { encoding: "utf8", mode: 384, flag: "wx" });
-  await rename2(temp, path);
+// src/plan/annotations.ts
+import { spawn as spawn2 } from "node:child_process";
+import { readFile as readFile12, rename as rename2, writeFile as writeFile8 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname7, join as join14 } from "node:path";
+import { z as z6 } from "zod";
+
+// src/log.ts
+import { randomUUID } from "node:crypto";
+import { appendFile, readFile as readFile10 } from "node:fs/promises";
+async function appendLogEntry(logPath, event) {
+  const entry = {
+    ...event,
+    version: 1,
+    eventId: event.eventId ?? randomUUID(),
+    timestamp: event.timestamp ?? new Date().toISOString()
+  };
+  await appendFile(logPath, `${JSON.stringify(entry)}
+`, { encoding: "utf8", mode: 384 });
+  return entry;
 }
-async function withDirectoryLock(lockDir, operation, options = {}) {
+
+// src/plan/log.ts
+async function appendPlanLog(logPath, event) {
+  return appendLogEntry(logPath, event);
+}
+
+// src/plan/lock.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir6, readFile as readFile11, rm, writeFile as writeFile7 } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join as join13 } from "node:path";
+async function withPlanLock(planDir, operation, options = {}) {
+  const lockDir = join13(planDir, ".lock");
   const waitMs = options.waitMs ?? 5000;
   const pollMs = options.pollMs ?? 25;
+  const owner = {
+    token: randomUUID2(),
+    pid: process.pid,
+    hostname: hostname(),
+    operation: options.operation ?? "plan mutation",
+    acquiredAt: new Date().toISOString()
+  };
   const started = Date.now();
   while (true) {
     try {
       await mkdir6(lockDir);
+      await writeFile7(join13(lockDir, "owner.json"), `${JSON.stringify(owner)}
+`, { mode: 384 });
       break;
     } catch (error) {
       if (error.code !== "EEXIST")
         throw error;
-      if (Date.now() - started >= waitMs)
-        throw new Error(`Timed out waiting to ${options.operation ?? "acquire lock"}: ${lockDir}`);
-      await sleep(pollMs);
+      if (Date.now() - started >= waitMs) {
+        let existing = "unknown owner";
+        try {
+          existing = (await readFile11(join13(lockDir, "owner.json"), "utf8")).trim();
+        } catch {}
+        throw new Error(`Timed out waiting for plan lock ${lockDir}; owner: ${existing}. Remove it only after confirming the owner is stale.`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollMs));
     }
   }
   try {
     return await operation();
   } finally {
-    await rm(lockDir, { recursive: true, force: true });
+    let current;
+    try {
+      current = JSON.parse(await readFile11(join13(lockDir, "owner.json"), "utf8"));
+    } catch {}
+    if (current?.token === owner.token)
+      await rm(lockDir, { recursive: true, force: true });
   }
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 
-// src/log.ts
-import { randomUUID } from "node:crypto";
-import { appendFile, readFile as readFile10 } from "node:fs/promises";
-async function appendLogEntry(logPath, event) {
-  const entry = {
-    ...event,
-    version: 1,
-    eventId: event.eventId ?? randomUUID(),
-    timestamp: event.timestamp ?? new Date().toISOString()
-  };
-  await appendFile(logPath, `${JSON.stringify(entry)}
-`, { encoding: "utf8", mode: 384 });
-  return entry;
+// src/plan/annotations.ts
+var commentSchema = z6.object({
+  id: z6.string(),
+  content: z6.string(),
+  path: z6.string().optional(),
+  start_line: z6.number().int().optional(),
+  line: z6.number().int().optional(),
+  end_line: z6.number().int().optional()
+}).loose();
+async function annotatePlan(record, runtime = {}) {
+  const execute = runtime.execute ?? executeProcess;
+  const result = await execute("tuicr", ["--file", record.planPath], dirname7(record.planPath), true);
+  const sessionSlug = [...result.stderr.matchAll(/^tuicr-session:\s*(\S+)\s*$/gm)].at(-1)?.[1];
+  if (result.code !== 0)
+    throw new Error(result.stderr.trim() || `tuicr exited with status ${result.code}.`);
+  if (!sessionSlug)
+    throw new Error("tuicr did not report a tuicr-session marker.");
+  const state = await withPlanLock(record.dir, async () => {
+    const previous = await readAnnotationState(record).catch((error) => {
+      if (error.code === "ENOENT")
+        return;
+      throw error;
+    });
+    const next = {
+      schemaVersion: 1,
+      sessionSlug,
+      updatedAt: new Date().toISOString(),
+      appliedCommentIds: previous?.appliedCommentIds ?? []
+    };
+    await atomicJson(annotationStatePath(record), next);
+    return next;
+  }, { operation: "save annotation session" });
+  return { sessionSlug, code: result.code, state };
 }
-
-// src/templates.ts
-import { readFile as readFile11 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { join as join14, normalize } from "node:path";
-async function loadTemplate(name, options = {}) {
-  const relative = templateRelativePath(name);
-  const userPath = join14(options.homeDir ?? homedir8(), ".difflab", "diffpi", "templates", relative);
-  const bundledPath = join14(options.bundledDir ?? resolveBundledTemplatesDir(), relative);
-  const user = await readOptionalFile(userPath);
-  if (user !== undefined)
-    return { name, path: userPath, source: "user", content: user };
-  const bundled = await readOptionalFile(bundledPath);
-  if (bundled !== undefined)
-    return { name, path: bundledPath, source: "bundled", content: bundled };
-  throw new Error(`Template "${name}" was not found at ${userPath} or ${bundledPath}.`);
+async function readPlanAnnotations(record, options = {}) {
+  const state = await readAnnotationState(record).catch((error) => {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  });
+  if (!state)
+    return { comments: [], pending: [] };
+  const execute = options.runtime?.execute ?? executeProcess;
+  const response = await execute("tuicr", ["review", "comments", "--session", state.sessionSlug], record.dir, false);
+  if (response.code !== 0) {
+    if (/not found|no session|deleted/i.test(response.stderr))
+      return { state, comments: [], pending: [] };
+    throw new Error(response.stderr.trim() || "Cannot read tuicr comments.");
+  }
+  let raw;
+  try {
+    raw = JSON.parse(response.stdout);
+  } catch {
+    throw new Error("tuicr returned malformed comment JSON.");
+  }
+  if (!Array.isArray(raw))
+    throw new Error("tuicr comment output must be a JSON array.");
+  const lines = record.source.split(`
+`);
+  const applied = new Set(state.appliedCommentIds);
+  const comments = raw.map((value, index) => normalizeComment(value, index, lines, applied));
+  const pending = comments.filter((comment) => !comment.applied);
+  return { state, comments: options.includeApplied ? comments : pending, pending };
+}
+async function acknowledgePlanAnnotations(record, commentIds, summary) {
+  if (!summary.trim())
+    throw new Error("Annotation acknowledgement summary is required.");
+  return withPlanLock(record.dir, async () => {
+    const state = await readAnnotationState(record);
+    const next = {
+      ...state,
+      updatedAt: new Date().toISOString(),
+      appliedCommentIds: [...new Set([...state.appliedCommentIds, ...commentIds])]
+    };
+    await atomicJson(annotationStatePath(record), next);
+    await appendPlanLog(record.logPath, {
+      planRevision: record.document.revision,
+      kind: "annotation",
+      actor: "planner",
+      message: summary,
+      data: { commentIds: [...commentIds], sessionSlug: state.sessionSlug }
+    });
+    return next;
+  }, { operation: "acknowledge annotations" });
 }
-function renderTemplate(content, variables) {
-  return content.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (match, key) => variables[key] ?? match);
+function annotationStatePath(record) {
+  return join14(record.dir, "annotations.json");
 }
-function templateRelativePath(name) {
-  const normalized = normalize(name.replaceAll("\\", "/")).replace(/^\.\//, "");
-  if (!normalized || normalized.startsWith("../") || normalized.includes("/../") || normalized.startsWith("/")) {
-    throw new Error(`Invalid template name: ${name}`);
+async function readAnnotationState(record) {
+  const source = await readFile12(annotationStatePath(record), "utf8");
+  let value;
+  try {
+    value = JSON.parse(source);
+  } catch {
+    throw new Error(`Malformed annotation state: ${annotationStatePath(record)}.`);
   }
-  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+  if (value.schemaVersion !== 1 || typeof value.sessionSlug !== "string" || !Array.isArray(value.appliedCommentIds)) {
+    throw new Error(`Malformed annotation state: ${annotationStatePath(record)}.`);
+  }
+  return value;
 }
-async function readOptionalFile(path) {
-  try {
-    return await readFile11(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return;
-    throw error;
+function normalizeComment(value, index, lines, applied) {
+  const parsed = commentSchema.safeParse(value);
+  if (!parsed.success)
+    throw new Error(`Malformed tuicr comment at index ${index}.`);
+  const raw = parsed.data;
+  const line = raw.start_line ?? raw.line;
+  const endLine = raw.end_line ?? line;
+  const targetPath = raw.path;
+  const appliesToPlan = !targetPath || basename5(targetPath) === basename5("PLAN.md");
+  const validAnchor = appliesToPlan && line !== undefined && line > 0 && line <= lines.length;
+  return {
+    id: raw.id,
+    body: raw.content,
+    file: targetPath,
+    line,
+    endLine,
+    context: validAnchor ? lines.slice(line - 1, Math.min(endLine ?? line, lines.length)).join(`
+`) : undefined,
+    stale: line !== undefined && !validAnchor,
+    applied: applied.has(raw.id)
+  };
+}
+async function executeProcess(command, args, cwd, interactive) {
+  if (!interactive) {
+    const result = await run(command, args, { cwd, capture: "unbounded" });
+    return { code: result.code, stdout: result.stdout, stderr: result.stderr };
   }
+  return new Promise((resolve, reject) => {
+    const child = spawn2(command, args, { cwd, stdio: ["inherit", "inherit", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      process.stderr.write(text);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ code: code ?? 1, stdout: "", stderr }));
+  });
+}
+async function atomicJson(path, value) {
+  const temp = join14(dirname7(path), `.${basename5(path)}.${crypto.randomUUID()}.tmp`);
+  await writeFile8(temp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384, flag: "wx" });
+  await rename2(temp, path);
+}
+
+// src/plan/execution.ts
+function createExecutionPacket(plan, coordinator) {
+  if (!plan.execution?.active)
+    throw new Error(`Plan ${plan.id} has no active execution.`);
+  return {
+    version: 1,
+    planId: plan.id,
+    executionId: plan.execution.id,
+    policy: plan.execution.policy,
+    cwd: plan.execution.cwd,
+    branch: plan.execution.branch,
+    coordinator
+  };
+}
+function renderExecutionPrompt(packet) {
+  return [
+    `Execute the durable Diffpi plan using this packet: ${JSON.stringify(packet)}.`,
+    "Call plan_context first and keep plan tools as the source of truth for eligibility, ownership, status, gates, and commits.",
+    "Use SubagentWorkflow for deterministic multi-task coordination: pipeline dependent work, parallelize only tasks with non-overlapping declared file scopes, and use structured schemas for worker outcomes.",
+    "The extension cannot launch workflow children over RPC, so the active orchestrator must invoke SubagentWorkflow itself.",
+    "Persist every transition, progress event, issue, and deviation. Do not edit PLAN.md directly. Delegated implementation workers never commit or restructure the plan.",
+    "For commit-per-phase execution, commit after local gates, push immediately, record pending CI on the completed phase, and launch a bounded background Worker to call plan_watch_ci for the exact SHA while the next phase executes. Collect that monitor before the next push and collect all monitors before plan completion; failed or timed-out CI blocks execution."
+  ].join(" ");
 }
 
 // src/plan/markdown.ts
@@ -7354,6 +7485,25 @@ function looksLikeAValue(value) {
 function isUint8Array2(value) {
   return Boolean(value && typeof value === "object" && "byteLength" in value && "byteOffset" in value);
 }
+// src/plan/ids.ts
+var STABLE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isStableId(value) {
+  return STABLE_ID.test(value) && value.length <= 80;
+}
+function assertStableId(value, label = "identifier") {
+  if (!isStableId(value))
+    throw new Error(`${label} must be a lowercase stable slug, not a path: ${value}`);
+}
+function assertUniqueIds(ids, label) {
+  const seen = new Set;
+  for (const id of ids) {
+    assertStableId(id, label);
+    if (seen.has(id))
+      throw new Error(`Duplicate ${label}: ${id}.`);
+    seen.add(id);
+  }
+}
+
 // src/plan/markdown.ts
 var PLAN_MARKER = /<!-- diffpi-plan: (\{[^\n]+\}) -->/;
 var PHASE_MARKER = /<!-- diffpi-phase: (\{[^\n]+\}) -->/g;
@@ -7401,6 +7551,8 @@ function validatePlanDocument(plan, options = {}) {
     add("design-too-long", "error", `Design is ${designWords} words; finalization allows at most 800.`);
   if (options.strict && plan.phases.length === 0)
     add("no-phases", "error", "Finalization requires at least one phase.");
+  if (options.strict && (options.pendingAnnotations ?? 0) > 0)
+    add("pending-annotations", "error", `${options.pendingAnnotations} annotations remain pending.`);
   return issues;
 }
 function renderPlanDocument(plan, previousSource) {
@@ -7742,19 +7894,6 @@ function parseCsv(value) {
     return [];
   return value.split(",").map((item) => item.trim()).filter(Boolean);
 }
-function assertStableId(value, label) {
-  if (!zx.id.safeParse(value).success)
-    throw new Error(`${label} must be a lowercase stable slug, not a path: ${value}`);
-}
-function assertUniqueIds(ids, label) {
-  const seen = new Set;
-  for (const id of ids) {
-    assertStableId(id, label);
-    if (seen.has(id))
-      throw new Error(`Duplicate ${label}: ${id}.`);
-    seen.add(id);
-  }
-}
 function cleanPlaceholder(value) {
   return value.replace(/<!--[^]*?-->/g, "").trim();
 }
@@ -7786,6 +7925,46 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/plan/store.ts
+import { open, mkdir as mkdir7, readdir as readdir2, readFile as readFile14, realpath as realpath4, rename as rename3, rm as rm2 } from "node:fs/promises";
+import { basename as basename6, dirname as dirname8, join as join17, resolve as resolve4, sep } from "node:path";
+
+// src/templates.ts
+import { readFile as readFile13 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { join as join16, normalize } from "node:path";
+async function loadTemplate(name, options = {}) {
+  const relative = templateRelativePath(name);
+  const userPath = join16(options.homeDir ?? homedir8(), ".difflab", "diffpi", "templates", relative);
+  const bundledPath = join16(options.bundledDir ?? resolveBundledTemplatesDir(), relative);
+  const user = await readOptionalFile(userPath);
+  if (user !== undefined)
+    return { name, path: userPath, source: "user", content: user };
+  const bundled = await readOptionalFile(bundledPath);
+  if (bundled !== undefined)
+    return { name, path: bundledPath, source: "bundled", content: bundled };
+  throw new Error(`Template "${name}" was not found at ${userPath} or ${bundledPath}.`);
+}
+function renderTemplate(content, variables) {
+  return content.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (match, key) => variables[key] ?? match);
+}
+function templateRelativePath(name) {
+  const normalized = normalize(name.replaceAll("\\", "/")).replace(/^\.\//, "");
+  if (!normalized || normalized.startsWith("../") || normalized.includes("/../") || normalized.startsWith("/")) {
+    throw new Error(`Invalid template name: ${name}`);
+  }
+  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile13(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+
 // src/plan/store.ts
 function planRecordName(shortSlug, date = new Date) {
   const slug = normalizeSlug(shortSlug);
@@ -7801,7 +7980,7 @@ async function resolvePlan(cwd, query, filters = {}, options = {}) {
       continue;
     if (normalizedQuery && entry.name !== normalizedQuery && stripDate(entry.name) !== normalizedQuery)
       continue;
-    const dir = join16(root, entry.name);
+    const dir = join17(root, entry.name);
     await assertContained(root, dir);
     try {
       const record = await readRecord(dir);
@@ -7827,7 +8006,7 @@ function createPlanStore(options = {}) {
     async init(input) {
       const root = await plansDir(input.cwd, options.homeDir);
       const id = planRecordName(input.shortSlug, now());
-      const dir = join16(root, id);
+      const dir = join17(root, id);
       await assertContained(root, dirname8(dir));
       try {
         await mkdir7(dir);
@@ -7847,19 +8026,25 @@ function createPlanStore(options = {}) {
           branch: input.branch,
           title: input.title?.trim() || titleFromSlug(input.shortSlug),
           intent: input.intent?.trim() || "<!-- Describe the intended outcome. -->",
-          issue_id: input.issueId?.trim() || "<!-- Add issue tracker ID. -->",
-          issue_url: input.issueUrl?.trim() || "<!-- Add issue tracker URL. -->",
           created_at: timestamp,
           updated_at: timestamp
         });
-        const document = parsePlanDocument(source, join16(dir, "PLAN.md"));
-        await atomicWrite(join16(dir, "PLAN.md"), source);
+        const document = parsePlanDocument(source, join17(dir, "PLAN.md"));
+        await atomicWrite(join17(dir, "PLAN.md"), source);
+        await ensureImplementationFiles(dir, document, options);
+        await atomicWrite(join17(dir, "logs.txt"), "");
+        await appendPlanLog(join17(dir, "logs.txt"), {
+          planRevision: document.revision,
+          kind: "created",
+          actor: "diffpi",
+          message: `Created plan ${id}.`
+        });
         return {
           id,
           dir,
-          planPath: join16(dir, "PLAN.md"),
-          logPath: join16(dir, "logs.txt"),
-          implementationDir: join16(dir, "implementation"),
+          planPath: join17(dir, "PLAN.md"),
+          logPath: join17(dir, "logs.txt"),
+          implementationDir: join17(dir, "implementation"),
           document,
           source
         };
@@ -7879,7 +8064,7 @@ function createPlanStore(options = {}) {
     },
     async mutate(cwd, query, operation, update) {
       const initial = await this.read(cwd, query);
-      return withDirectoryLock(join16(initial.dir, ".lock"), async () => {
+      return withPlanLock(initial.dir, async () => {
         const current = await readRecord(initial.dir);
         const next = await update(structuredClone(current.document));
         if (next.id !== current.id)
@@ -7893,41 +8078,41 @@ function createPlanStore(options = {}) {
         parsePlanDocument(source, current.planPath);
         await atomicWrite(current.planPath, source);
         await ensureImplementationFiles(current.dir, document, options);
-        return { ...current, document, source, implementationDir: join16(current.dir, "implementation") };
+        return { ...current, document, source, implementationDir: join17(current.dir, "implementation") };
       }, { operation });
     },
     async log(cwd, query, event) {
       const record = await this.read(cwd, query);
-      return appendLogEntry(record.logPath, event);
+      return withPlanLock(record.dir, () => appendPlanLog(record.logPath, event), { operation: "append log" });
     }
   };
 }
 async function readRecord(dir) {
-  const planPath = join16(dir, "PLAN.md");
-  const logPath = join16(dir, "logs.txt");
-  const source = await readFile12(planPath, "utf8");
+  const planPath = join17(dir, "PLAN.md");
+  const logPath = join17(dir, "logs.txt");
+  const source = await readFile14(planPath, "utf8");
   const document = parsePlanDocument(source, planPath);
   return {
     id: basename6(dir),
     dir,
     planPath,
     logPath,
-    implementationDir: join16(dir, "implementation"),
+    implementationDir: join17(dir, "implementation"),
     document,
     source
   };
 }
 async function ensureImplementationFiles(dir, document, options) {
-  const implementationDir = join16(dir, "implementation");
+  const implementationDir = join17(dir, "implementation");
   await mkdir7(implementationDir, { recursive: true });
   const template = await loadTemplate("plan/implementation", {
     homeDir: options.homeDir,
     bundledDir: options.bundledTemplatesDir
   });
   for (const phase of document.phases) {
-    const path = join16(implementationDir, `phase-${phase.id}.md`);
+    const path = join17(implementationDir, `phase-${phase.id}.md`);
     try {
-      await readFile12(path, "utf8");
+      await readFile14(path, "utf8");
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
@@ -7941,6 +8126,25 @@ async function ensureImplementationFiles(dir, document, options) {
     }
   }
 }
+async function atomicWrite(path, content) {
+  const temp = join17(dirname8(path), `.${basename6(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  const file = await open(temp, "wx", 384);
+  try {
+    await file.writeFile(content, "utf8");
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+  await rename3(temp, path);
+  try {
+    const directory = await open(dirname8(path), "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  } catch {}
+}
 async function assertContained(root, candidate) {
   const canonicalRoot = await realpath4(root);
   let canonicalCandidate;
@@ -7958,8 +8162,7 @@ function normalizeSlug(value) {
     throw new Error(`Invalid plan slug: ${value}.`);
   }
   const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  if (!zx.id.safeParse(slug).success)
-    throw new Error(`Invalid plan slug: ${value}.`);
+  assertStableId(slug, "plan slug");
   return slug;
 }
 function normalizeQuery(value) {
@@ -7974,11 +8177,345 @@ function stripDate(value) {
 function titleFromSlug(value) {
   return normalizeSlug(value).replace(/^(?:[a-z]+-\d+-)/, "").split("-").map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
 }
+
+// src/plan/controller.ts
+function createPlanController(options = {}) {
+  const store = createPlanStore(options);
+  const controller = {
+    context: store.context,
+    create: store.init,
+    read: store.read,
+    update: store.mutate,
+    appendLog: store.log,
+    updateStatus: (cwd, query, input) => updateStatus(store, cwd, query, input),
+    updateCi: (cwd, query, input) => updateCi(store, cwd, query, input),
+    retryCi: (cwd, query, input) => retryCi(store, cwd, query, input),
+    assertPhasePushEligible,
+    validate: validatePlanDocument,
+    countDesignWords,
+    annotate: annotatePlan,
+    annotations: readPlanAnnotations,
+    acknowledgeAnnotations: acknowledgePlanAnnotations,
+    executionPacket: createExecutionPacket,
+    executionPrompt: renderExecutionPrompt,
+    renderEscalation: renderSubagentEscalation,
+    assertStableId
+  };
+  return controller;
+}
+async function updateStatus(store, cwd, query, input) {
+  let escalation;
+  const record = await store.mutate(cwd, query, "update status", (plan) => {
+    if (input.target.type === "plan") {
+      if (plan.status !== input.expectedStatus)
+        throw new Error(`Expected plan status ${input.expectedStatus}, found ${plan.status}.`);
+      assertPlanTransition(plan.status, input.status);
+      if (input.status === "ready") {
+        const errors = validatePlanDocument(plan, { strict: true }).filter((issue) => issue.severity === "error");
+        if (errors.length)
+          throw new Error(`Plan cannot become ready: ${errors.map((issue) => issue.message).join(" ")}`);
+      }
+      if ((input.status === "blocked" || input.status === "completed") && plan.status === "in_progress")
+        assertExecutionOwner(plan, input.executionId);
+      if (input.status === "completed" && plan.phases.some((phase) => phase.status !== "completed" && phase.status !== "skipped"))
+        throw new Error("Every phase must be complete or skipped before the plan completes.");
+      if (input.status === "completed" && plan.execution?.policy === "commit-per-phase") {
+        const unsettled = plan.phases.filter((phase) => phase.status === "completed" && (!phase.commit?.pushedAt || !["passed", "skipped"].includes(phase.commit.ci?.status ?? "pending")));
+        if (unsettled.length)
+          throw new Error(`CI must settle successfully for phases: ${unsettled.map((phase) => phase.id).join(", ")}.`);
+      }
+      return {
+        ...heartbeat(plan),
+        status: input.status,
+        execution: input.status === "completed" || input.status === "blocked" ? plan.execution && { ...plan.execution, active: false, heartbeatAt: new Date().toISOString() } : plan.execution
+      };
+    }
+    if (!input.target.id)
+      throw new Error("Target ID is required.");
+    const phase = input.target.type === "phase" ? getPhase(plan, input.target.id) : findTaskPhase(plan, input.target.id);
+    if (input.target.type === "phase") {
+      if (phase.status !== input.expectedStatus)
+        throw new Error(`Expected phase status ${input.expectedStatus}, found ${phase.status}.`);
+      if (phase.status === "completed")
+        throw new Error(`Completed phase ${phase.id} cannot transition again.`);
+      assertExecutionOwner(plan, input.executionId);
+      assertPhaseTransition(phase.status, input.status);
+      if (input.status === "in_progress" || input.status === "completed")
+        assertPhaseDependenciesSatisfied(plan, phase);
+      if (input.status === "completed") {
+        if (phase.tasks.some((task) => task.status !== "completed" && task.status !== "skipped"))
+          throw new Error("All phase tasks must be complete or skipped.");
+        if (phase.gate.status !== "passed")
+          throw new Error("Phase gates must pass before completion.");
+        if (plan.execution?.policy === "commit-per-phase")
+          assertPhasePushEligible(plan, phase.id, input.executionId);
+        if (plan.execution?.policy === "commit-per-phase" && !input.commit)
+          throw new Error("Commit-per-phase execution requires commit metadata before phase completion.");
+        if (plan.execution?.policy === "commit-per-phase" && (!input.commit?.pushedAt || input.commit.ci?.status !== "pending"))
+          throw new Error("Commit-per-phase execution requires a pushed commit with pending CI monitoring.");
+        if (plan.execution?.policy === "no-commit" && input.commit)
+          throw new Error("No-commit execution cannot record a phase commit.");
+      }
+      const updated = {
+        ...phase,
+        status: input.status,
+        revision: phase.revision + 1,
+        commit: input.commit ?? phase.commit,
+        blocker: input.blockedReason ? blocker(input) : phase.blocker
+      };
+      if (input.status === "blocked" && input.blockedReason)
+        escalation = escalationFor(plan, updated.id, undefined, input);
+      const phases = plan.phases.map((item) => {
+        if (item.id === updated.id)
+          return updated;
+        if (input.status === "completed" && plan.execution?.policy === "commit-per-phase" && input.commit && item.status !== "completed" && item.status !== "skipped" && item.gate.status === "passed")
+          return { ...item, gate: { ...item.gate, status: "stale" } };
+        return item;
+      });
+      return { ...heartbeat(plan), phases };
+    }
+    const task = getTask(phase, input.target.id);
+    if (task.status !== input.expectedStatus)
+      throw new Error(`Expected task status ${input.expectedStatus}, found ${task.status}.`);
+    assertExecutionOwner(plan, input.executionId);
+    assertTaskTransition(task, input.status, input.executionId, input.actor);
+    if (input.status === "in_progress" || input.status === "completed") {
+      if (phase.status !== "in_progress")
+        throw new Error(`Phase ${phase.id} is not in progress.`);
+      assertTaskDependenciesSatisfied(plan, task);
+    }
+    const updatedTask = {
+      ...task,
+      status: input.status,
+      revision: task.revision + 1,
+      owner: input.status === "in_progress" ? input.actor : task.owner,
+      executionId: input.status === "in_progress" ? input.executionId : task.executionId,
+      blocker: input.blockedReason ? blocker(input) : task.blocker
+    };
+    if (input.status === "blocked" && input.blockedReason)
+      escalation = escalationFor(plan, phase.id, task.id, input);
+    const updatedPhase = {
+      ...phase,
+      revision: phase.revision + 1,
+      tasks: phase.tasks.map((item) => item.id === updatedTask.id ? updatedTask : item)
+    };
+    return {
+      ...heartbeat(plan),
+      phases: plan.phases.map((item) => item.id === updatedPhase.id ? updatedPhase : item)
+    };
+  });
+  await store.log(cwd, record.id, {
+    planRevision: record.document.revision,
+    kind: input.status === "blocked" ? "blocker" : "status",
+    actor: input.actor,
+    message: input.message,
+    executionId: input.executionId,
+    phaseId: input.target.type === "phase" ? input.target.id : escalation?.correlation.parentUnitId ?? escalation?.correlation.unitId,
+    taskId: input.target.type === "task" ? input.target.id : undefined,
+    evidence: input.evidence
+  });
+  return { record, escalation };
+}
+async function updateCi(store, cwd, query, input) {
+  const record = await store.mutate(cwd, query, "update CI status", (plan) => {
+    assertExecutionOwner(plan, input.executionId);
+    if (plan.execution?.policy !== "commit-per-phase")
+      throw new Error("CI status applies only to commit-per-phase execution.");
+    const phase = getPhase(plan, input.phaseId);
+    if (phase.status !== "completed")
+      throw new Error(`Phase ${phase.id} must be completed before CI can settle.`);
+    if (!phase.commit || phase.commit.sha !== input.sha)
+      throw new Error(`Phase ${phase.id} is not committed at ${input.sha}.`);
+    const current = phase.commit.ci?.status;
+    if (current !== "pending")
+      throw new Error(`CI for phase ${phase.id} is already ${current ?? "untracked"}.`);
+    const timestamp = new Date().toISOString();
+    const updated = {
+      ...phase,
+      revision: phase.revision + 1,
+      commit: {
+        ...phase.commit,
+        ci: {
+          ...phase.commit.ci,
+          status: input.status,
+          startedAt: phase.commit.ci?.startedAt ?? timestamp,
+          completedAt: timestamp,
+          detail: input.detail
+        }
+      }
+    };
+    return {
+      ...heartbeat(plan),
+      phases: plan.phases.map((item) => item.id === updated.id ? updated : item)
+    };
+  });
+  await store.log(cwd, record.id, {
+    planRevision: record.document.revision,
+    kind: "gate",
+    actor: input.actor,
+    message: `CI ${input.status} for ${input.phaseId}: ${input.detail}`,
+    executionId: input.executionId,
+    phaseId: input.phaseId,
+    evidence: [input.sha]
+  });
+  return record;
+}
+async function retryCi(store, cwd, query, input) {
+  let previousDetail;
+  const record = await store.mutate(cwd, query, "retry CI", (plan) => {
+    assertExecutionOwner(plan, input.executionId);
+    if (plan.execution?.policy !== "commit-per-phase")
+      throw new Error("CI retry applies only to commit-per-phase execution.");
+    const phase = getPhase(plan, input.phaseId);
+    if (phase.status !== "completed")
+      throw new Error(`Phase ${phase.id} must be completed before CI can retry.`);
+    if (!phase.commit || phase.commit.sha !== input.sha)
+      throw new Error(`Phase ${phase.id} is not committed at ${input.sha}.`);
+    if (phase.commit.ci?.status !== "failed")
+      throw new Error(`CI for phase ${phase.id} cannot retry from ${phase.commit.ci?.status ?? "untracked"}.`);
+    previousDetail = phase.commit.ci.detail;
+    const updated = {
+      ...phase,
+      revision: phase.revision + 1,
+      commit: {
+        ...phase.commit,
+        ci: { status: "pending", startedAt: new Date().toISOString() }
+      }
+    };
+    return {
+      ...heartbeat(plan),
+      phases: plan.phases.map((item) => item.id === updated.id ? updated : item)
+    };
+  });
+  await store.log(cwd, record.id, {
+    planRevision: record.document.revision,
+    kind: "gate",
+    actor: input.actor,
+    message: `Retrying CI for ${input.phaseId}: ${input.reason}`,
+    executionId: input.executionId,
+    phaseId: input.phaseId,
+    evidence: [input.sha],
+    data: { previousStatus: "failed", previousDetail }
+  });
+  return record;
+}
+function assertPhasePushEligible(plan, phaseId, executionId) {
+  assertExecutionOwner(plan, executionId);
+  if (plan.execution?.policy !== "commit-per-phase")
+    return;
+  const phaseIndex = plan.phases.findIndex((phase) => phase.id === phaseId);
+  if (phaseIndex < 0)
+    throw new Error(`Unknown phase: ${phaseId}.`);
+  const unsettled = plan.phases.slice(0, phaseIndex).filter((phase) => {
+    if (phase.status === "skipped")
+      return false;
+    return phase.status !== "completed" || !phase.commit?.pushedAt || !["passed", "skipped"].includes(phase.commit.ci?.status ?? "pending");
+  });
+  if (unsettled.length)
+    throw new Error(`Prior phase CI must settle successfully before another push: ${unsettled.map((phase) => phase.id).join(", ")}.`);
+}
+function assertPhaseDependenciesSatisfied(plan, phase) {
+  const unsettled = phase.dependencies.map((id) => getPhase(plan, id)).filter((dependency) => !dependencySatisfied(dependency.status));
+  if (unsettled.length)
+    throw new Error(`Phase ${phase.id} has incomplete dependencies: ${unsettled.map((dependency) => `${dependency.id} (${dependency.status})`).join(", ")}.`);
+}
+function assertTaskDependenciesSatisfied(plan, task) {
+  const tasks = plan.phases.flatMap((phase) => phase.tasks);
+  const unsettled = task.dependencies.map((id) => {
+    const dependency = tasks.find((candidate) => candidate.id === id);
+    if (!dependency)
+      throw new Error(`Unknown task dependency: ${id}.`);
+    return dependency;
+  }).filter((dependency) => !dependencySatisfied(dependency.status));
+  if (unsettled.length)
+    throw new Error(`Task ${task.id} has incomplete dependencies: ${unsettled.map((dependency) => `${dependency.id} (${dependency.status})`).join(", ")}.`);
+}
+function dependencySatisfied(status) {
+  return status === "completed" || status === "skipped";
+}
+var PLAN_TRANSITIONS = {
+  draft: ["ready"],
+  ready: ["draft", "in_progress"],
+  in_progress: ["blocked", "completed"],
+  blocked: ["draft", "ready", "in_progress"],
+  completed: []
+};
+var WORK_TRANSITIONS = {
+  pending: ["in_progress", "skipped"],
+  in_progress: ["blocked", "completed"],
+  blocked: ["pending", "in_progress", "skipped"],
+  completed: [],
+  skipped: []
+};
+function assertPlanTransition(from, to) {
+  if (from !== to && !PLAN_TRANSITIONS[from].includes(to))
+    throw new Error(`Invalid plan status transition: ${from} -> ${to}.`);
+}
+function assertPhaseTransition(from, to) {
+  if (from !== to && !WORK_TRANSITIONS[from].includes(to))
+    throw new Error(`Invalid phase status transition: ${from} -> ${to}.`);
+}
+function assertTaskTransition(task, to, executionId, actor) {
+  if (task.status !== to && !WORK_TRANSITIONS[task.status].includes(to))
+    throw new Error(`Invalid task status transition: ${task.status} -> ${to}.`);
+  if (task.status === "in_progress" && task.executionId && executionId !== task.executionId)
+    throw new Error(`Task ${task.id} is owned by execution ${task.executionId}.`);
+  if (task.status === "in_progress" && task.owner && actor && actor !== task.owner)
+    throw new Error(`Task ${task.id} is owned by ${task.owner}.`);
+}
+function getPhase(plan, phaseId) {
+  const phase = plan.phases.find((item) => item.id === phaseId);
+  if (!phase)
+    throw new Error(`Unknown phase: ${phaseId}.`);
+  return phase;
+}
+function findTaskPhase(plan, taskId) {
+  const phase = plan.phases.find((item) => item.tasks.some((task) => task.id === taskId));
+  if (!phase)
+    throw new Error(`Unknown task: ${taskId}.`);
+  return phase;
+}
+function getTask(phase, taskId) {
+  const task = phase.tasks.find((item) => item.id === taskId);
+  if (!task)
+    throw new Error(`Unknown task: ${taskId}.`);
+  return task;
+}
+function assertExecutionOwner(plan, executionId) {
+  if (!plan.execution?.active || !executionId || plan.execution.id !== executionId)
+    throw new Error(`Execution ${executionId ?? "(missing)"} does not own this plan.`);
+}
+function blocker(input) {
+  return {
+    reason: input.blockedReason,
+    attempts: input.attempts,
+    evidence: input.evidence,
+    needsUserDecision: input.needsUserDecision
+  };
+}
+function escalationFor(plan, phaseId, taskId, input) {
+  return {
+    correlation: {
+      workflow: "plan",
+      executionId: input.executionId,
+      unitId: taskId ?? phaseId,
+      parentUnitId: taskId ? phaseId : undefined,
+      metadata: { planId: plan.id }
+    },
+    blocker: input.blockedReason,
+    attempts: input.attempts ?? [],
+    evidence: input.evidence ?? [],
+    needsUserDecision: input.needsUserDecision ?? false
+  };
+}
+function heartbeat(plan) {
+  return plan.execution?.active ? { ...plan, execution: { ...plan.execution, heartbeatAt: new Date().toISOString() } } : plan;
+}
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter3 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir3, readFile as readFile13 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile15 } from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
-import { basename as basename7, join as join17 } from "node:path";
+import { basename as basename7, join as join18 } from "node:path";
 var MISE_DEPENDENCIES = [
   { name: "node", tool: "node", spec: "node@22", minimumVersion: "22.19.0" },
   { name: "zellij", tool: "zellij", spec: "zellij@latest", minimumVersion: undefined },
@@ -8017,7 +8554,7 @@ var FORGE_DEPENDENCIES = {
 };
 async function ensureMise(options = {}) {
   const homeDir = options.homeDir ?? homedir9();
-  const current = await mise.executableCheck() ?? await mise.executableCheck(join17(homeDir, ".local", "bin", "mise"));
+  const current = await mise.executableCheck() ?? await mise.executableCheck(join18(homeDir, ".local", "bin", "mise"));
   if (current)
     return { executable: current, action: createSetupAction("mise", "ready", current) };
   reportProgress(options, "Installing mise");
@@ -8066,9 +8603,9 @@ async function ensureMiseDeps(miseExecutable, options = {}) {
 async function ensurePiPlugins(options = {}) {
   const actions = await ensurePiPackages(PI_PACKAGES, options);
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const webSearch = await pi.configEnsure(join17(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
+  const webSearch = await pi.configEnsure(join18(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
   actions.push(getConfigSetupAction("web search settings", webSearch));
-  const lsp = await pi.configEnsure(join17(agentDir, "pi-lsp.json"), (config) => ({
+  const lsp = await pi.configEnsure(join18(agentDir, "pi-lsp.json"), (config) => ({
     ...config,
     progressive: { ...getRecord(config.progressive), enabled: true, inject: "none" }
   }), options.dryRun);
@@ -8083,7 +8620,7 @@ async function ensurePiAgents(options = {}) {
   const actions = [];
   for (const entry of entries) {
     const id = basename7(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile13(join17(bundledAgentsDir, entry.name), "utf8");
+    const source = await readFile15(join18(bundledAgentsDir, entry.name), "utf8");
     const content = materializeAgentModels(source, id, userConfig.config, options.availableModels);
     const result = await pi.agentEnsure(entry.name, content, agentDir, options.dryRun);
     actions.push(getConfigSetupAction(`pi agent ${id}`, result));
@@ -8092,7 +8629,7 @@ async function ensurePiAgents(options = {}) {
 }
 async function ensurePiSkills(miseExecutable, options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const sharedSkillsDir = join17(options.homeDir ?? homedir9(), ".agents", "skills");
+  const sharedSkillsDir = join18(options.homeDir ?? homedir9(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -8288,7 +8825,7 @@ function reportProgress(options, message) {
   options.onProgress?.(message);
 }
 async function packageVersion2() {
-  const source = await readFile13(join17(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
+  const source = await readFile15(join18(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
   let value;
   try {
     value = JSON.parse(source);
@@ -8319,7 +8856,7 @@ export {
   createForgeBackend,
   createLocalReviewBackend,
   createModeController,
-  createPlanStore,
+  createPlanController,
   createRemoteReviewBackend,
   createVcsBackend,
   dedupeFindings,
@@ -8355,7 +8892,6 @@ export {
   localReviewAuthor,
   mcp,
   mise,
-  openFileAdjacent,
   openInNewTab,
   parseGitlabDiffRefs,
   parseRemote,