@groeponline/pi-missions 0.2.0

package/dist/index.js

@@ -0,0 +1,3970 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/types.ts
+var types_exports = {};
+__export(types_exports, {
+  CriterionSchema: () => CriterionSchema,
+  DEFAULT_AUTOPILOT: () => DEFAULT_AUTOPILOT,
+  DEFAULT_FEATURE_MAX_TOOL_CALLS: () => DEFAULT_FEATURE_MAX_TOOL_CALLS,
+  DEFAULT_FEATURE_MAX_WALL_CLOCK_MS: () => DEFAULT_FEATURE_MAX_WALL_CLOCK_MS,
+  FeatureSchema: () => FeatureSchema,
+  MilestoneSchema: () => MilestoneSchema,
+  SCHEMA_VERSION: () => SCHEMA_VERSION,
+  STALE_FEATURE_WARN_MS: () => STALE_FEATURE_WARN_MS,
+  TOOL_POLICIES: () => TOOL_POLICIES,
+  WizardCriterionSchema: () => WizardCriterionSchema,
+  WizardFeatureSchema: () => WizardFeatureSchema,
+  WizardMilestoneSchema: () => WizardMilestoneSchema,
+  WizardOutputSchema: () => WizardOutputSchema,
+  formatValidationErrors: () => formatValidationErrors,
+  validate: () => validate
+});
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+function validate(schema, value) {
+  try {
+    if (Value.Check(schema, value)) return { valid: true, errors: [] };
+    const errors = [];
+    for (const error of Value.Errors(schema, value)) {
+      errors.push({ path: error.path, message: error.message, value: error.value });
+    }
+    return { valid: false, errors };
+  } catch (e) {
+    return {
+      valid: false,
+      errors: [{ path: "root", message: e instanceof Error ? e.message : String(e), value }]
+    };
+  }
+}
+function formatValidationErrors(errors) {
+  if (errors.length === 0) return "";
+  const lines = ["Validation errors:"];
+  for (const e of errors.slice(0, 10)) {
+    lines.push(`  - ${e.path}: ${e.message}`);
+    if (e.value !== void 0) lines.push(`    (value: ${JSON.stringify(e.value).slice(0, 50)})`);
+  }
+  if (errors.length > 10) lines.push(`  ... and ${errors.length - 10} more errors`);
+  return lines.join("\n");
+}
+var SCHEMA_VERSION, DEFAULT_FEATURE_MAX_WALL_CLOCK_MS, DEFAULT_FEATURE_MAX_TOOL_CALLS, STALE_FEATURE_WARN_MS, DEFAULT_AUTOPILOT, TOOL_POLICIES, CriterionSchema, FeatureSchema, MilestoneSchema, WizardCriterionSchema, WizardFeatureSchema, WizardMilestoneSchema, WizardOutputSchema;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    "use strict";
+    SCHEMA_VERSION = 3;
+    DEFAULT_FEATURE_MAX_WALL_CLOCK_MS = 30 * 60 * 1e3;
+    DEFAULT_FEATURE_MAX_TOOL_CALLS = 150;
+    STALE_FEATURE_WARN_MS = 20 * 60 * 1e3;
+    DEFAULT_AUTOPILOT = {
+      enabled: false,
+      mode: "manual",
+      iteration: 0,
+      maxIterations: 25,
+      consecutiveFailures: 0,
+      maxConsecutiveFailures: 3,
+      noProgressTurns: 0,
+      maxNoProgressTurns: 3,
+      maxContextPercent: 85,
+      startedAt: "",
+      continueAcrossFeatures: true,
+      requireEvidenceForDone: true
+    };
+    TOOL_POLICIES = {
+      planning: {
+        phase: "planning",
+        allowedTools: [
+          "read",
+          "grep",
+          "find",
+          "ls",
+          "mission_next_feature",
+          "mission_feature_done",
+          "mission_ask_user",
+          "mission_block_self",
+          "mission_fork",
+          "mission_error_status",
+          "mission_retry_error",
+          "mission_spawn_worker",
+          "mission_worker_status",
+          "mission_kill_worker"
+        ],
+        maxToolCalls: 30
+      },
+      execution: {
+        phase: "execution",
+        allowedTools: [
+          "read",
+          "write",
+          "edit",
+          "bash",
+          "grep",
+          "find",
+          "ls",
+          "mission_next_feature",
+          "mission_feature_done",
+          "mission_ask_user",
+          "mission_block_self",
+          "mission_fork",
+          "mission_error_status",
+          "mission_retry_error",
+          "mission_spawn_worker",
+          "mission_worker_status",
+          "mission_kill_worker"
+        ],
+        maxToolCalls: 120
+      },
+      verification: {
+        phase: "verification",
+        allowedTools: [
+          "read",
+          "bash",
+          "grep",
+          "find",
+          "ls",
+          "mission_next_feature",
+          "mission_feature_done",
+          "mission_ask_user",
+          "mission_block_self",
+          "mission_fork",
+          "mission_error_status",
+          "mission_retry_error",
+          "mission_spawn_worker",
+          "mission_worker_status",
+          "mission_kill_worker"
+        ],
+        maxToolCalls: 60
+      }
+    };
+    CriterionSchema = Type.Object({
+      id: Type.String({ minLength: 1, maxLength: 50 }),
+      description: Type.String({ minLength: 1, maxLength: 500 }),
+      checkType: Type.Union([Type.Literal("manual"), Type.Literal("bash"), Type.Literal("test_file")]),
+      checkCommand: Type.Optional(Type.String({ maxLength: 1e3 })),
+      evidence: Type.Optional(Type.String()),
+      verified: Type.Boolean(),
+      waived: Type.Optional(Type.Boolean())
+    });
+    FeatureSchema = Type.Object({
+      id: Type.String({ pattern: "^F[0-9]{3}$" }),
+      milestoneId: Type.String({ pattern: "^M[0-9]{2}$" }),
+      title: Type.String({ minLength: 1, maxLength: 200 }),
+      description: Type.String({ minLength: 1, maxLength: 2e3 }),
+      priority: Type.Integer({ minimum: 1, maximum: 5 }),
+      dependsOn: Type.Array(Type.String({ pattern: "^F[0-9]{3}$" })),
+      acceptance: Type.Array(CriterionSchema, { minItems: 1 }),
+      status: Type.Union([
+        Type.Literal("pending"),
+        Type.Literal("waiting"),
+        Type.Literal("active"),
+        Type.Literal("done"),
+        Type.Literal("blocked"),
+        Type.Literal("failed")
+      ]),
+      sessions: Type.Array(Type.String()),
+      toolCallCount: Type.Integer({ minimum: 0 }),
+      tokensUsed: Type.Optional(Type.Integer({ minimum: 0 })),
+      startedAt: Type.Optional(Type.Integer()),
+      completedAt: Type.Optional(Type.Integer()),
+      maxWallClockMs: Type.Optional(Type.Integer({ minimum: 0 })),
+      maxToolCalls: Type.Optional(Type.Integer({ minimum: 0 })),
+      notes: Type.Optional(Type.String({ maxLength: 1e3 }))
+    }, { additionalProperties: false });
+    MilestoneSchema = Type.Object({
+      id: Type.String({ pattern: "^M[0-9]{2}$" }),
+      title: Type.String({ minLength: 1, maxLength: 200 }),
+      description: Type.String({ maxLength: 1e3 }),
+      status: Type.Union([Type.Literal("pending"), Type.Literal("active"), Type.Literal("complete")]),
+      features: Type.Array(FeatureSchema, { minItems: 1 }),
+      dependsOn: Type.Optional(Type.Array(Type.String({ pattern: "^M[0-9]{2}$" })))
+    });
+    WizardCriterionSchema = Type.Object({
+      id: Type.Optional(Type.String({ minLength: 1, maxLength: 50 })),
+      description: Type.String({ minLength: 1, maxLength: 500 }),
+      checkType: Type.Union([Type.Literal("manual"), Type.Literal("bash"), Type.Literal("test_file")]),
+      checkCommand: Type.Optional(Type.String({ maxLength: 1e3 }))
+    }, { additionalProperties: false });
+    WizardFeatureSchema = Type.Object({
+      id: Type.Optional(Type.String({ pattern: "^F[0-9]{3}$" })),
+      title: Type.String({ minLength: 1, maxLength: 200 }),
+      description: Type.String({ minLength: 1, maxLength: 2e3 }),
+      priority: Type.Integer({ minimum: 1, maximum: 5 }),
+      dependsOn: Type.Array(Type.String({ pattern: "^F[0-9]{3}$" })),
+      acceptance: Type.Array(WizardCriterionSchema, { minItems: 1 })
+    }, { additionalProperties: false });
+    WizardMilestoneSchema = Type.Object({
+      id: Type.Optional(Type.String({ pattern: "^M[0-9]{2}$" })),
+      title: Type.String({ minLength: 1, maxLength: 200 }),
+      description: Type.String({ maxLength: 1e3 }),
+      features: Type.Array(WizardFeatureSchema, { minItems: 1 })
+    }, { additionalProperties: false });
+    WizardOutputSchema = Type.Object({
+      title: Type.String({ minLength: 1, maxLength: 200 }),
+      milestones: Type.Array(WizardMilestoneSchema, { minItems: 2, maxItems: 20 })
+    }, { additionalProperties: false });
+  }
+});
+
+// src/core/extension.ts
+import { fileURLToPath } from "url";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import * as fs4 from "fs";
+
+// src/core/state.ts
+import * as fs2 from "fs";
+import * as fsAsync from "fs/promises";
+import * as path3 from "path";
+import * as lockfile from "proper-lockfile";
+
+// src/utils/markdown.ts
+init_types();
+
+// src/utils/fs.ts
+import * as os from "os";
+import * as path from "path";
+import * as crypto from "crypto";
+function missionsRoot() {
+  if (process.env.MISSIONS_ROOT) {
+    if (!path.isAbsolute(process.env.MISSIONS_ROOT)) {
+      throw new Error(`MISSIONS_ROOT must be an absolute path, got: ${process.env.MISSIONS_ROOT}`);
+    }
+    return process.env.MISSIONS_ROOT;
+  }
+  if (process.env.PI_MISSIONS_ROOT) {
+    if (!path.isAbsolute(process.env.PI_MISSIONS_ROOT)) {
+      throw new Error(`PI_MISSIONS_ROOT must be an absolute path, got: ${process.env.PI_MISSIONS_ROOT}`);
+    }
+    return process.env.PI_MISSIONS_ROOT;
+  }
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  return path.join(home, ".pi", "missions");
+}
+function missionDirSafe(id) {
+  const root = path.resolve(missionsRoot());
+  const safeId = id.replace(/[^a-zA-Z0-9._-]/g, "-");
+  const resolved = path.resolve(root, safeId);
+  if (!resolved.startsWith(root + path.sep)) {
+    throw new Error(`Invalid mission id: path traversal detected (${id})`);
+  }
+  return resolved;
+}
+function createMissionId(title, now = Date.now()) {
+  const date = new Date(now).toISOString().replace(/[-:T.Z]/g, "");
+  const stamp = date.slice(0, 17);
+  const slug = slugify(title);
+  return `pim:${stamp}:${slug}`;
+}
+function isValidMissionId(id) {
+  return id.startsWith("pim:") && id.split(":").length === 3;
+}
+function createValidationToken() {
+  return crypto.randomBytes(32).toString("hex");
+}
+function slugify(input) {
+  return input.toLowerCase().trim().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "mission";
+}
+function sha256(data) {
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+
+// src/utils/context.ts
+function clip(text, max = 88) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+function progressBar(done, total, width = 16) {
+  if (total === 0) return `[${"\u2591".repeat(width)}]`;
+  const ratio = Math.max(0, Math.min(1, done / total));
+  const filled = Math.round(ratio * width);
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(width - filled)}]`;
+}
+function featureStatusIcon(status) {
+  switch (status) {
+    case "done":
+      return "\u2705";
+    case "active":
+      return "\u27A1\uFE0F";
+    case "blocked":
+      return "\u26D4";
+    case "failed":
+      return "\u274C";
+    case "waiting":
+      return "\u23F3";
+    default:
+      return "\u2022";
+  }
+}
+function missionStatusIcon(status) {
+  switch (status) {
+    case "complete":
+      return "\u2705";
+    case "paused":
+      return "\u23F8";
+    case "blocked":
+      return "\u26D4";
+    case "budget_limited":
+      return "\u26A0\uFE0F";
+    default:
+      return "\u{1F3AF}";
+  }
+}
+function acceptanceProgress(feature) {
+  const done = feature.acceptance.filter((ac) => ac.verified || ac.waived).length;
+  return { done, total: feature.acceptance.length, label: `${done}/${feature.acceptance.length}` };
+}
+function pendingAcceptance(feature, arrow = "\u2192") {
+  return feature.acceptance.filter((ac) => !ac.verified && !ac.waived).map((ac) => ac.checkType === "bash" && ac.checkCommand ? `${ac.id}: ${ac.description} ${arrow} ${ac.checkCommand}` : `${ac.id}: ${ac.description}`);
+}
+function phaseLine(phase) {
+  switch (phase) {
+    case "planning":
+      return "\u{1F50D} Phase: planning \u2014 explore, read, clarify. Avoid writes. Read-only bash.";
+    case "verification":
+      return "\u2705 Phase: verification \u2014 run checks, capture evidence, report exact gaps.";
+    default:
+      return "\u{1F527} Phase: execution \u2014 smallest change that satisfies acceptance criteria.";
+  }
+}
+function buildMissionBanner(mission) {
+  const active = getActiveFeature(mission);
+  const p = progress(mission);
+  const phase = getMissionPhase(mission);
+  const bar = progressBar(p.done, p.total);
+  const lines = [
+    "## Pi Missions Extension \u2014 Active",
+    `Mission: ${mission.title}  |  Goal: ${mission.goal}`,
+    `  ${bar} ${p.done}/${p.total} leaf goals (${p.pct}%) \u2014 ${p.done}/${p.total} features`,
+    `  Status: ${mission.status}  |  Phase: ${phase}`,
+    `  State: ~/.pi/missions/${mission.id}/`
+  ];
+  if (active) {
+    lines.push("", `  \u25B6 ${active.id}: ${active.title} [${phase}]`, `  ${active.description}`);
+  } else {
+    lines.push("", "  No active feature.");
+  }
+  return lines.join("\n");
+}
+function buildFeatureBrief(mission, feature, tokenBudget = 250) {
+  const phase = getMissionPhase(mission);
+  const allFeatures = getAllFeatures(mission);
+  const pendingCount = allFeatures.filter((f) => f.status === "pending").length;
+  const blockedCount = allFeatures.filter((f) => f.status === "blocked").length;
+  const lines = [];
+  let used = 0;
+  function add(...items) {
+    for (const item of items) {
+      const cost = item.length / 4;
+      if (used + cost > tokenBudget) return;
+      lines.push(item);
+      used += cost;
+    }
+  }
+  const milestoneTitle = mission.milestones.find((m) => m.id === feature.milestoneId)?.title ?? "";
+  add(`Goal path: ${milestoneTitle} > ${feature.title}`);
+  add("");
+  if (feature.acceptance.length) {
+    add("**Acceptance:**");
+    for (const ac of feature.acceptance) {
+      const mark = ac.verified || ac.waived ? "x" : " ";
+      const waived = ac.waived ? " (waived)" : "";
+      add(`- [${mark}] ${ac.id}: ${ac.description}${waived}`);
+    }
+  }
+  if (feature.dependsOn.length) {
+    add(`Dependencies: ${feature.dependsOn.join(", ")}`);
+  }
+  add("");
+  add(phaseLine(phase));
+  if (pendingCount) add(`\u{1F4CB} ${pendingCount} pending feature(s) queued.`);
+  if (blockedCount) add(`\u26D4 ${blockedCount} blocked feature(s).`);
+  return lines.join("\n");
+}
+var MISSION_HELP = [
+  "### How To Work This Mission",
+  "- Work only on the active feature unless the user explicitly redirects you or /mission next changes it.",
+  "- During planning: gather context, avoid writes; read-only shell exploration is allowed.",
+  "- During execution: make the smallest coherent change that satisfies the mission goal.",
+  "- During verification: run relevant checks, capture evidence, and report exact gaps.",
+  "- Do not silently mark work complete. Use /mission done or mission_feature_done only with concrete evidence.",
+  "- If blocked, use /mission block <reason> or mission_block_self with a clear reason and next option.",
+  "",
+  "### Mission Commands",
+  "- /mission start/new: create a new mission.",
+  "- /mission load: resume an existing mission.",
+  "- /mission status: show active mission, feature, progress, acceptance criteria.",
+  "- /mission next: activate the next unblocked pending feature.",
+  "- /mission done: mark the active feature done and save evidence.",
+  "- /mission block: block the active feature.",
+  "- /mission fork: create a linked alternative feature.",
+  "- /mission dashboard: open mission control UI.",
+  "- /mission debug: inspect recent mission history.",
+  "- /mission metrics: show mission/session metrics.",
+  "- /mission templates: create from a built-in template.",
+  "- /mission export: export mission report as markdown.",
+  "",
+  "### Mission Tools",
+  "- mission_next_feature: advance to the next pending feature.",
+  "- mission_feature_done: mark the active feature done with evidence.",
+  "- mission_ask_user: ask for clarification.",
+  "- mission_block_self: self-block when stuck.",
+  "- mission_fork: split into a linked fork.",
+  "- mission_error_status: inspect error recovery state.",
+  "- mission_retry_error: retry a retryable recorded error."
+].join("\n");
+function buildMissionHelp() {
+  return MISSION_HELP;
+}
+function buildMissionContext(mission) {
+  const active = getActiveFeature(mission);
+  const banner = buildMissionBanner(mission);
+  const brief = active ? buildFeatureBrief(mission, active, 300) : "";
+  const help = buildMissionHelp();
+  const allFeatures = getAllFeatures(mission);
+  const doneRecent = allFeatures.filter((f) => f.status === "done").slice(-3);
+  const parts = [banner];
+  if (brief) parts.push("", brief);
+  parts.push("", help);
+  parts.push("", `### Goal Tree`);
+  if (active) parts.push(`\u25B6 ${active.title}`);
+  if (doneRecent.length) {
+    const recent = doneRecent.map((f) => `\u2705 ${f.id} ${f.title}`).join("  |  ");
+    if (recent) parts.push(`### Recently completed: ${recent}`);
+  }
+  parts.push("", "Work only on the active feature unless the user or /mission next changes it.");
+  return parts.join("\n");
+}
+function buildLeanContext(mission) {
+  const active = getActiveFeature(mission);
+  if (!active) return `${buildMissionBanner(mission)}
+
+No active feature. Use \`/mission status\` for overview.`;
+  const acLines = active.acceptance.map((a) => {
+    const mark = a.verified || a.waived ? "[x]" : "[ ]";
+    return `- ${mark} **${a.id}**: ${a.description}`;
+  });
+  return `${buildMissionBanner(mission)}
+
+${acLines.join("\n")}`;
+}
+function buildCompactionSummary(mission) {
+  const active = getActiveFeature(mission);
+  const p = progress(mission);
+  let blocked = 0;
+  let waiting = 0;
+  for (const m of mission.milestones) {
+    for (const f of m.features) {
+      if (f.status === "blocked") blocked++;
+      else if (f.status === "waiting") waiting++;
+    }
+  }
+  return `Mission: ${mission.title}  |  ID: ${mission.id}
+  Goal: ${mission.goal}
+  Progress: ${p.done}/${p.total} features (${p.pct}%)  |  ${p.done}/${p.total} leaf goals (${p.pct}%)  |  Status: ${mission.status}
+  ${active ? `Active: ${active.id} \u2014 ${active.title}` : "Active: none"}
+  Blocked/Waiting: ${blocked}/${waiting}
+  State: ~/.pi/missions/${mission.id}/
+  Resume by loading mission state and continuing the active feature.`;
+}
+function dependsOnChain(mission, feature) {
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  function trace(fId) {
+    if (visited.has(fId)) return;
+    visited.add(fId);
+    const f = mission.milestones.flatMap((m) => m.features).find((f2) => f2.id === fId);
+    if (!f) return;
+    if (f.status === "done") return;
+    chain.push({ id: f.id, status: f.status, title: f.title });
+    for (const depId of f.dependsOn) {
+      const dep = mission.milestones.flatMap((m) => m.features).find((f2) => f2.id === depId);
+      if (!dep || dep.status === "done") continue;
+      trace(depId);
+    }
+  }
+  for (const depId of feature.dependsOn) trace(depId);
+  return chain;
+}
+function formatDepChain(chain) {
+  if (!chain.length) return "";
+  const statusIcon = {
+    pending: "\u2022",
+    waiting: "\u23F3",
+    blocked: "\u26D4",
+    active: "\u27A1\uFE0F",
+    done: "\u2705",
+    failed: "\u274C"
+  };
+  const parts = chain.map((n) => {
+    const icon = statusIcon[n.status] ?? "\u2022";
+    const label = n.title ? ` ${clip(n.title, 20)}` : "";
+    return `${n.id}(${icon}${label})`;
+  });
+  return `\u{1F517} ${parts.join(" \u2192 ")}`;
+}
+
+// src/utils/markdown.ts
+import * as fs from "fs";
+import * as path2 from "path";
+var MISSION_TEMPLATES = [
+  {
+    id: "refactor",
+    label: "Refactor",
+    description: "Safely refactor legacy code",
+    goal: "Refactor a module or subsystem to improve maintainability without changing behavior.",
+    constraints: "Existing tests must pass. No behavior changes. Keep the public API compatible."
+  },
+  {
+    id: "fix-bug",
+    label: "Fix Bug",
+    description: "Investigate and fix a bug",
+    goal: "Identify the root cause of a reported bug and apply the minimal fix.",
+    constraints: "Add a regression test. Do not refactor unrelated code. Verify the fix with evidence."
+  },
+  {
+    id: "add-feature",
+    label: "Add Feature",
+    description: "Implement a new feature",
+    goal: "Implement a new capability or endpoint according to the specification.",
+    constraints: "Add tests for the new functionality. Keep changes minimal and focused."
+  },
+  {
+    id: "docs",
+    label: "Document",
+    description: "Generate or update documentation",
+    goal: "Produce accurate, verified documentation for a module, API, or workflow.",
+    constraints: "Docs must be accurate and reflect current behavior. No stub or TODO content. Rendered output must be verified."
+  },
+  {
+    id: "investigate",
+    label: "Investigate",
+    description: "Research and analyze a codebase question",
+    goal: "Answer a technical question about the codebase through exploration.",
+    constraints: "Read-only exploration. No code changes. Provide evidence from the codebase."
+  },
+  {
+    id: "auth",
+    label: "Auth implementation",
+    description: "Implement authentication in a codebase",
+    goal: "Add or refactor authentication in a codebase.",
+    constraints: "Implement secure auth patterns. Add tests. Verify with evidence."
+  },
+  {
+    id: "ci-cd",
+    label: "CI/CD Pipeline",
+    description: "Set up or improve CI/CD pipeline",
+    goal: "Implement or improve CI/CD pipeline.",
+    constraints: "Ensure robust pipeline configuration. Verify with test runs."
+  },
+  {
+    id: "security-audit",
+    label: "Security Audit",
+    description: "Find and fix security vulnerabilities",
+    goal: "Identify security vulnerabilities in a module, API, or workflow and document findings.",
+    constraints: "Do not make permanent changes without explicit user approval. Document all findings with evidence. Prioritize critical/high severity issues."
+  },
+  {
+    id: "performance-opt",
+    label: "Performance Optimization",
+    description: "Improve performance of existing code",
+    goal: "Identify and eliminate performance bottlenecks in a module or subsystem.",
+    constraints: "Measure before and after. Do not degrade correctness or readability. Target meaningful improvements (\u226520% speedup or \u226550% memory reduction)."
+  }
+];
+function createMissionFromTemplate(templateId, title) {
+  const t = MISSION_TEMPLATES.find((t2) => t2.id === templateId);
+  if (!t) return null;
+  return createStructuredMission(title || t.label, t.goal, t.constraints);
+}
+function createStructuredMission(title, goal, constraints) {
+  const id = createMissionId(title);
+  const now = Date.now();
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    title,
+    goal,
+    status: "active",
+    activeMilestoneId: "M01",
+    activeFeatureId: "F001",
+    tokensUsed: 0,
+    lastContextTokens: 0,
+    validationToken: createValidationToken(),
+    autopilot: {
+      enabled: false,
+      mode: "manual",
+      iteration: 0,
+      maxIterations: 25,
+      consecutiveFailures: 0,
+      maxConsecutiveFailures: 3,
+      noProgressTurns: 0,
+      maxNoProgressTurns: 3,
+      maxContextPercent: 85,
+      startedAt: new Date(now).toISOString(),
+      continueAcrossFeatures: true,
+      requireEvidenceForDone: true
+    },
+    createdAt: now,
+    updatedAt: now,
+    milestones: [
+      {
+        id: "M01",
+        title: "Plan and execute",
+        description: constraints ? `Constraints: ${constraints}` : "Initial execution milestone",
+        status: "active",
+        features: [
+          { id: "F001", milestoneId: "M01", title: "Clarify scope and current state", description: "Read the repository, identify relevant files, constraints, and existing behavior.", priority: 1, dependsOn: [], status: "active", sessions: [], toolCallCount: 0, startedAt: now, acceptance: [{ id: "AC001", description: "Relevant files and constraints documented", checkType: "manual", verified: false }] },
+          { id: "F002", milestoneId: "M01", title: "Implement the core change", description: "Make the smallest coherent implementation that satisfies the mission goal.", priority: 2, dependsOn: ["F001"], status: "pending", sessions: [], toolCallCount: 0, acceptance: [{ id: "AC001", description: "Implementation matches mission goal", checkType: "manual", verified: false }] },
+          { id: "F003", milestoneId: "M01", title: "Verify and summarize", description: "Run relevant checks, capture evidence, and summarize results.", priority: 3, dependsOn: ["F002"], status: "pending", sessions: [], toolCallCount: 0, acceptance: [{ id: "AC001", description: "Verification evidence saved", checkType: "manual", verified: false }] }
+        ]
+      }
+    ]
+  };
+}
+function missionFromWizardOutput(raw, title, goal) {
+  const milestones = raw.milestones || [];
+  if (milestones.length < 2) return null;
+  const id = createMissionId(title);
+  const now = Date.now();
+  const mapping = [];
+  let counter = 0;
+  const intermediate = milestones.map((m, mi) => ({
+    ...m,
+    features: (m.features || []).map((f) => {
+      const newId = `F${String(++counter).padStart(3, "0")}`;
+      mapping.push({ oldId: f.id, newId });
+      return { ...f, id: newId, dependsOn: [] };
+    })
+  }));
+  const oldToNewSet = /* @__PURE__ */ new Map();
+  for (const { oldId, newId } of mapping) {
+    const arr = oldToNewSet.get(oldId) || [];
+    arr.push(newId);
+    oldToNewSet.set(oldId, arr);
+  }
+  const wizardFeatures = milestones.flatMap(
+    (wm, mi) => wm.features.map((wf) => ({ ...wf, _mi: mi }))
+  );
+  let mapIdx = 0;
+  for (let mi = 0; mi < intermediate.length; mi++) {
+    const m = intermediate[mi];
+    for (let fi = 0; fi < m.features.length; fi++) {
+      const f = m.features[fi];
+      mapIdx++;
+      const orig = wizardFeatures[mapIdx - 1];
+      if (!orig) continue;
+      f.dependsOn = (orig.dependsOn || []).filter((d) => oldToNewSet.has(d)).map((d) => {
+        const candidates = oldToNewSet.get(d);
+        const resolveMilestone = (cid) => {
+          const idx = mapping.findIndex((me) => me.newId === cid);
+          return idx >= 0 ? wizardFeatures[idx]?._mi : void 0;
+        };
+        const sameMilestone = candidates.find((cid) => resolveMilestone(cid) === orig._mi);
+        if (sameMilestone) return sameMilestone;
+        const earlier = candidates.find((cid) => {
+          const mi2 = resolveMilestone(cid);
+          return mi2 !== void 0 && mi2 < (orig._mi ?? 99);
+        });
+        if (earlier) return earlier;
+        return candidates[0];
+      });
+    }
+  }
+  const migrated = intermediate.map((m, mi) => {
+    const milestoneId = m.id ?? `M${String(mi + 1).padStart(2, "0")}`;
+    return {
+      id: milestoneId,
+      title: m.title,
+      description: m.description || "",
+      status: mi === 0 ? "active" : "pending",
+      dependsOn: mi > 0 ? [milestones[mi - 1].id || `M${String(mi).padStart(2, "0")}`] : void 0,
+      features: m.features.map((f, fi) => {
+        const fid = f.id;
+        return {
+          id: fid,
+          milestoneId,
+          title: f.title,
+          description: f.description || "",
+          priority: f.priority || 1,
+          dependsOn: f.dependsOn,
+          status: mi === 0 && fi === 0 ? "active" : "pending",
+          sessions: [],
+          toolCallCount: 0,
+          acceptance: (f.acceptance || []).map((ac, ai) => ({
+            id: ac.id || `AC${String(ai + 1).padStart(3, "0")}`,
+            description: ac.description,
+            checkType: ac.checkType || "manual",
+            checkCommand: ac.checkCommand,
+            verified: false
+          }))
+        };
+      })
+    };
+  });
+  const displayTitle = raw.title || title;
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    title: displayTitle,
+    goal,
+    status: "active",
+    activeMilestoneId: migrated[0].id,
+    activeFeatureId: migrated[0].features[0]?.id || "F001",
+    tokensUsed: 0,
+    lastContextTokens: 0,
+    validationToken: createValidationToken(),
+    autopilot: {
+      enabled: false,
+      mode: "manual",
+      iteration: 0,
+      maxIterations: 25,
+      consecutiveFailures: 0,
+      maxConsecutiveFailures: 3,
+      noProgressTurns: 0,
+      maxNoProgressTurns: 3,
+      maxContextPercent: 85,
+      startedAt: new Date(now).toISOString(),
+      continueAcrossFeatures: true,
+      requireEvidenceForDone: true
+    },
+    createdAt: now,
+    updatedAt: now,
+    milestones: migrated
+  };
+}
+function exportMarkdown(mission) {
+  const p = progress(mission);
+  const active = getActiveFeature(mission);
+  const all = getAllFeatures(mission);
+  const done = all.filter((f) => f.status === "done");
+  const lines = [
+    `# Mission Report: ${mission.title}`,
+    "",
+    `- **Goal**: ${mission.goal}`,
+    `- **Status**: ${mission.status}`,
+    `- **Goal tree**: ${p.done}/${p.total} leaf goals (${p.pct}%)`,
+    `- **Progress**: ${p.done}/${p.total} (${p.pct}%)`,
+    `- **Tokens used**: ${mission.tokensUsed.toLocaleString()}`,
+    `- **Created**: ${new Date(mission.createdAt).toISOString()}`,
+    "",
+    "## Executive Summary",
+    "",
+    active ? `**Active feature**: ${active.id} \u2014 ${active.title} [${active.status}]` : "**Active feature**: none",
+    `**Handoff**: ${mission.autopilot.lastStopReason ?? "none"}${mission.autopilot.lastStopMessage ? ` - ${mission.autopilot.lastStopMessage}` : ""}`,
+    "",
+    "## Goal Tree",
+    ""
+  ];
+  for (const m of mission.milestones) {
+    const mDone = m.features.filter((f) => f.status === "done").length;
+    lines.push(
+      `## ${m.id}: ${m.title}`,
+      `Status: ${m.status} | Progress: ${mDone}/${m.features.length}`,
+      m.description ? `
+${m.description}
+` : "",
+      `**Acceptance criteria:**`
+    );
+    for (const f of m.features) {
+      const icon = featureStatusIcon(f.status);
+      const ac = acceptanceProgress(f);
+      lines.push(
+        `### ${f.id}: ${f.title}`,
+        `- **Status**: ${f.status} | **Priority**: P${f.priority}`,
+        `- **Acceptance**: ${ac.label}`,
+        f.dependsOn.length ? `- **Dependencies**: ${f.dependsOn.join(", ")}` : "",
+        f.notes ? `- **Notes**: ${f.notes}` : "",
+        f.description ? `
+${f.description}
+` : ""
+      );
+      for (const a of f.acceptance) {
+        const mark = a.verified || a.waived ? "\u2713" : "\u2610";
+        const waived = a.waived ? " (waived)" : "";
+        const cmd = a.checkCommand ? ` \`${a.checkCommand}\`` : "";
+        lines.push(`- [${mark}] ${a.id}: ${a.description}${cmd}${waived}`);
+      }
+      lines.push("");
+    }
+  }
+  if (done.length) {
+    lines.push("", "## Evidence");
+    for (const f of done) {
+      const evidenceFile = path2.join(missionDirSafe(mission.id), "evidence", `${f.id}.md`);
+      if (fs.existsSync(evidenceFile)) {
+        const evidence = fs.readFileSync(evidenceFile, "utf-8");
+        lines.push(`### ${f.id}: ${f.title}`, "", evidence.trim(), "");
+      }
+    }
+  }
+  const history = readHistory(mission.id);
+  if (history.length) {
+    lines.push("## Recent History");
+    for (const h of history.slice(-10)) {
+      const ts = new Date(h.ts * 1e3).toISOString();
+      lines.push(`- \`${ts}\` ${h.event}${h.featureId ? ` (${h.featureId})` : ""}${h.note ? ` - ${h.note}` : ""}`);
+    }
+    lines.push("");
+  }
+  const nextRunnable = getActiveFeature(mission) ?? getAllFeatures(mission).find((f) => f.status === "pending" || f.status === "waiting");
+  if (nextRunnable) {
+    lines.push(`**Next runnable**: ${nextRunnable.id} \u2014 ${nextRunnable.title}`);
+  }
+  lines.push("---", `Generated by pi-missions at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  return lines.join("\n");
+}
+
+// src/utils/mission-builder.ts
+function buildMissionGoalTree(title, goal, milestones) {
+  const children = milestones.map((m) => ({
+    id: m.id,
+    label: m.title,
+    status: m.status,
+    children: m.features.map((f) => ({
+      id: f.id,
+      label: f.title,
+      status: f.status,
+      children: [],
+      root: {}
+    })),
+    root: {}
+  }));
+  const tree = {
+    id: "root",
+    label: title,
+    status: "active",
+    children,
+    root: {}
+  };
+  tree.root = tree;
+  for (const mc of tree.children) {
+    mc.root = tree;
+    for (const fc of mc.children) fc.root = tree;
+  }
+  return tree;
+}
+
+// src/core/state.ts
+init_types();
+async function withLock(lockPath, callback, stale = 3e4) {
+  fs2.mkdirSync(path3.dirname(lockPath), { recursive: true });
+  const release = await lockfile.lock(lockPath, {
+    retries: { retries: 10, minTimeout: 100, maxTimeout: 500 },
+    stale,
+    realpath: false
+  });
+  try {
+    return await callback();
+  } finally {
+    await release();
+  }
+}
+function getAllFeatures(mission) {
+  const result = [];
+  for (const m of mission.milestones) {
+    for (const f of m.features) {
+      result.push(f);
+    }
+  }
+  return result;
+}
+function getMilestoneById(mission, id) {
+  return mission.milestones.find((m) => m.id === id);
+}
+function getFeatureById(mission, id) {
+  for (const m of mission.milestones) {
+    for (const f of m.features) {
+      if (f.id === id) return f;
+    }
+  }
+  return void 0;
+}
+function getActiveFeature(mission) {
+  if (!mission.activeFeatureId) return null;
+  return getFeatureById(mission, mission.activeFeatureId) ?? null;
+}
+function dependenciesDone(mission, feature) {
+  return feature.dependsOn.every((id) => getFeatureById(mission, id)?.status === "done");
+}
+function getNextPendingFeature(mission) {
+  return getAllFeatures(mission).filter((f) => (f.status === "pending" || f.status === "waiting") && dependenciesDone(mission, f)).sort((a, b) => a.priority - b.priority || a.id.localeCompare(b.id))[0] ?? null;
+}
+function progress(mission) {
+  let done = 0;
+  let total = 0;
+  for (const m of mission.milestones) {
+    for (const f of m.features) {
+      total++;
+      if (f.status === "done") done++;
+    }
+  }
+  return { done, total, pct: total ? Math.round(done / total * 100) : 0 };
+}
+function migrateMission(raw) {
+  const value = raw;
+  const version = value.schemaVersion ?? 1;
+  if (version > SCHEMA_VERSION) throw new Error(`Unsupported mission schemaVersion ${version}`);
+  if (version === SCHEMA_VERSION) {
+    return { ...value, autopilot: { ...DEFAULT_AUTOPILOT, ...value.autopilot } };
+  }
+  const v1Features = (value.features ?? []).map((f) => ({
+    ...f,
+    toolCallCount: typeof f.toolCallCount === "number" ? f.toolCallCount : 0
+  }));
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: String(value.id ?? createMissionId(String(value.title ?? "mission"))),
+    title: String(value.title ?? "Untitled mission"),
+    goal: String(value.goal ?? ""),
+    status: value.status ?? "active",
+    activeFeatureId: value.activeFeatureId,
+    activeMilestoneId: value.activeMilestoneId ?? "M01",
+    tokensBudget: value.tokensBudget,
+    tokensUsed: value.tokensUsed ?? 0,
+    lastContextTokens: value.lastContextTokens ?? 0,
+    validationToken: value.validationToken || createValidationToken(),
+    autopilot: {
+      ...DEFAULT_AUTOPILOT,
+      ...value.autopilot,
+      startedAt: value.autopilot?.startedAt ?? new Date(value.createdAt ?? Date.now()).toISOString()
+    },
+    userPreferences: value.userPreferences,
+    createdAt: value.createdAt ?? Date.now(),
+    updatedAt: Date.now(),
+    milestones: value.milestones ?? [{
+      id: "M01",
+      title: "Migrated",
+      description: "Migrated flat feature list",
+      status: "active",
+      features: v1Features
+    }]
+  };
+}
+async function saveMissionSafe(mission) {
+  const dir = missionDirSafe(mission.id);
+  const target = path3.join(dir, "plan.json");
+  await withLock(target, async () => {
+    await fsAsync.mkdir(dir, { recursive: true });
+    await fsAsync.mkdir(path3.join(dir, "evidence"), { recursive: true });
+    await fsAsync.mkdir(path3.join(dir, "sessions"), { recursive: true });
+    const backup = path3.join(dir, "plan.json.bak");
+    const preMigration = path3.join(dir, "plan.json.pre-migration.bak");
+    const temp = path3.join(dir, "plan.json.tmp");
+    if (fs2.existsSync(target)) {
+      await fsAsync.copyFile(target, backup);
+      if (!fs2.existsSync(preMigration)) await fsAsync.copyFile(target, preMigration);
+    }
+    mission.updatedAt = Date.now();
+    const { goalTree: _, ...serializable } = mission;
+    const data = JSON.stringify(serializable, null, 2);
+    try {
+      await fsAsync.writeFile(temp, data, "utf-8");
+    } catch {
+      await new Promise((r) => setTimeout(r, 100));
+      await fsAsync.writeFile(temp, data, "utf-8");
+    }
+    await fsAsync.rename(temp, target);
+  });
+}
+function loadMissionFromDisk(id) {
+  const dir = missionDirSafe(id);
+  for (const name of ["plan.json", "plan.json.bak"]) {
+    try {
+      const raw = JSON.parse(fs2.readFileSync(path3.join(dir, name), "utf-8"));
+      return migrateMission(raw);
+    } catch {
+    }
+  }
+  return null;
+}
+function readRawSchemaVersion(id) {
+  const dir = missionDirSafe(id);
+  for (const name of ["plan.json", "plan.json.bak"]) {
+    try {
+      const raw = JSON.parse(fs2.readFileSync(path3.join(dir, name), "utf-8"));
+      if (raw && typeof raw === "object" && !Array.isArray(raw) && "schemaVersion" in raw) {
+        return raw.schemaVersion;
+      }
+      return 1;
+    } catch {
+    }
+  }
+  return null;
+}
+async function migrateMissionOnDisk(id) {
+  const dir = missionDirSafe(id);
+  const target = path3.join(dir, "plan.json");
+  if (!fs2.existsSync(target)) return null;
+  return withLock(target, async () => {
+    const preBackup = path3.join(dir, `plan.json.pre-migration-${Date.now()}.bak`);
+    await fsAsync.copyFile(target, preBackup);
+    const raw = JSON.parse(await fsAsync.readFile(target, "utf-8"));
+    const migrated = migrateMission(raw);
+    const temp = path3.join(dir, "plan.json.tmp");
+    await fsAsync.writeFile(temp, JSON.stringify(migrated, null, 2), "utf-8");
+    await fsAsync.rename(temp, target);
+    return migrated;
+  });
+}
+function readRawMissionCounts(id) {
+  const dir = missionDirSafe(id);
+  for (const name of ["plan.json", "plan.json.bak"]) {
+    try {
+      const raw = JSON.parse(fs2.readFileSync(path3.join(dir, name), "utf-8"));
+      if (raw && typeof raw === "object") {
+        const o = raw;
+        if (Array.isArray(o.milestones)) {
+          const features = o.milestones.reduce(
+            (s, m) => s + (Array.isArray(m?.features) ? m.features.length : 0),
+            0
+          );
+          return { milestones: o.milestones.length, features };
+        }
+        if (Array.isArray(o.features)) {
+          return { milestones: 1, features: o.features.length };
+        }
+        return { milestones: 0, features: 0 };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function listMissions() {
+  const root = missionsRoot();
+  if (!fs2.existsSync(root)) return [];
+  return fs2.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => {
+    if (e.name.startsWith("pim-")) return true;
+    if (/^mission-\d{17,}/.test(e.name)) return true;
+    return false;
+  }).map((e) => loadMissionFromDisk(e.name)).filter((m) => Boolean(m)).sort((a, b) => b.updatedAt - a.updatedAt);
+}
+function appendHistory(mission, entry) {
+  const dir = missionDirSafe(mission.id);
+  fs2.mkdirSync(dir, { recursive: true });
+  const line = {
+    ts: Math.floor(Date.now() / 1e3),
+    missionId: mission.id,
+    ...entry
+  };
+  fs2.appendFileSync(path3.join(dir, "history.jsonl"), JSON.stringify(line) + "\n", "utf-8");
+}
+function readHistory(id) {
+  const file = path3.join(missionDirSafe(id), "history.jsonl");
+  if (!fs2.existsSync(file)) return [];
+  return fs2.readFileSync(file, "utf-8").split("\n").filter(Boolean).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+}
+function saveEvidence(mission, feature, text) {
+  const dir = path3.join(missionDirSafe(mission.id), "evidence");
+  fs2.mkdirSync(dir, { recursive: true });
+  const file = path3.join(dir, `${feature.id}.md`);
+  fs2.writeFileSync(file, text, "utf-8");
+  return file;
+}
+function evidenceIntegrityHash(mission, featureId) {
+  const evidenceFile = path3.join(missionDirSafe(mission.id), "evidence", `${featureId}.md`);
+  if (!fs2.existsSync(evidenceFile)) return null;
+  return sha256(fs2.readFileSync(evidenceFile));
+}
+function linkSession(mission, sessionFile, agent) {
+  const dir = path3.join(missionDirSafe(mission.id), "sessions");
+  fs2.mkdirSync(dir, { recursive: true });
+  const agentSource = agent || process.env.CODING_AGENT || "unknown";
+  const refPath = path3.join(dir, `${path3.basename(sessionFile)}.${agentSource}.ref`);
+  fs2.writeFileSync(refPath, JSON.stringify({
+    sessionFile,
+    agent: agentSource,
+    linkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    linkedAtMs: Date.now()
+  }, null, 2), "utf-8");
+}
+function autoBlockBlockedFeatures(mission) {
+  let changed = 0;
+  for (const m of mission.milestones) {
+    for (const f of m.features) {
+      if (f.status === "pending" || f.status === "active") {
+        const isBlocked = f.dependsOn.some((depId) => {
+          const dep = getFeatureById(mission, depId);
+          return dep && dep.status === "blocked";
+        });
+        if (isBlocked) {
+          f.status = "blocked";
+          f.notes = f.notes ? f.notes + "\nAuto-blocked: Dependency is blocked." : "Auto-blocked: Dependency is blocked.";
+          changed++;
+        }
+      }
+    }
+  }
+  return changed;
+}
+function autoUnblockResolved(mission) {
+  let changed = 0;
+  for (const m of mission.milestones) {
+    for (const f of m.features) {
+      if (f.status === "blocked") {
+        const depsDone = dependenciesDone(mission, f);
+        const noBlockedDeps = !f.dependsOn.some((depId) => {
+          const dep = getFeatureById(mission, depId);
+          return dep && dep.status === "blocked";
+        });
+        if (depsDone || noBlockedDeps) {
+          f.status = "pending";
+          f.notes = f.notes ? f.notes + "\nAuto-unblocked: Dependencies resolved." : "Auto-unblocked: Dependencies resolved.";
+          changed++;
+        }
+      }
+    }
+  }
+  return changed;
+}
+function autoCompleteMilestones(mission) {
+  let completed = 0;
+  for (const m of mission.milestones) {
+    if (m.status === "complete") continue;
+    if (m.features.every((f) => f.status === "done")) {
+      m.status = "complete";
+      completed++;
+    } else if (m.features.some((f) => f.status === "active")) {
+      m.status = "active";
+    }
+  }
+  return completed;
+}
+function getMissionPhase(mission) {
+  if (mission.status === "planning") return "planning";
+  const active = getActiveFeature(mission);
+  if (!active) return "execution";
+  const t = `${active.title} ${active.description ?? ""}`.toLowerCase();
+  if (t.includes("verify") || t.includes("test") || t.includes("summarize")) return "verification";
+  if (t.includes("clarify") || t.includes("plan") || t.includes("scope") || t.includes("research") || t.includes("analyze") || t.includes("analyse") || t.includes("inspect") || t.includes("investigate") || t.includes("discover") || t.includes("reconnaissance") || t.includes("current state")) {
+    return "planning";
+  }
+  return "execution";
+}
+function allFeaturesDone(mission) {
+  return getAllFeatures(mission).every((f) => f.status === "done");
+}
+function autoVerifyAcceptance(feature, execFn) {
+  let verified = 0;
+  for (const ac of feature.acceptance) {
+    if (ac.verified || ac.waived || ac.checkType !== "bash" || !ac.checkCommand) continue;
+    try {
+      const result = execFn(ac.checkCommand);
+      if (result.code === 0) {
+        ac.verified = true;
+        ac.evidence = result.stdout.slice(0, 1e3);
+        verified++;
+      }
+    } catch {
+    }
+  }
+  return verified;
+}
+function completeActiveFeature(mission, options) {
+  const feature = getActiveFeature(mission);
+  if (!feature) return { ok: false, reason: "No active mission feature." };
+  if (options.autoVerify && feature._execFn) {
+    autoVerifyAcceptance(feature, feature._execFn);
+  }
+  const unverifiedBash = feature.acceptance.filter(
+    (ac) => !ac.verified && !ac.waived && ac.checkType === "bash"
+  );
+  if (unverifiedBash.length > 0) {
+    const details = unverifiedBash.map((ac) => `${ac.id}: ${ac.description}${ac.checkCommand ? ` [bash: ${ac.checkCommand}]` : ""}`).join("\n");
+    return { ok: false, reason: `Cannot mark feature done: ${unverifiedBash.length} bash acceptance criteria need verification.
+${details}`, unverifiedBashCount: unverifiedBash.length };
+  }
+  feature.status = "done";
+  feature.completedAt = Date.now();
+  if (options.notes !== void 0) feature.notes = options.notes;
+  if (options.markAcceptanceVerified) {
+    for (const ac of feature.acceptance) if (!ac.waived) ac.verified = true;
+  }
+  const evidenceFile = saveEvidence(mission, feature, options.evidence || "Marked done.");
+  appendHistory(mission, {
+    event: "feature_done",
+    featureId: feature.id,
+    note: options.historyNote ?? options.notes,
+    details: { evidenceFile, ...options.historyDetails }
+  });
+  autoUnblockResolved(mission);
+  const missionComplete = !getNextPendingFeature(mission) && allFeaturesDone(mission);
+  if (missionComplete) {
+    mission.status = "complete";
+    mission.autopilot.enabled = false;
+    mission.autopilot.lastStopReason = "mission_complete";
+  }
+  autoCompleteMilestones(mission);
+  mission.goalTree = buildMissionGoalTree(mission.title, mission.goal, mission.milestones);
+  return { ok: true, feature, evidenceFile, missionComplete };
+}
+function activateNextFeature(mission, note) {
+  const active = getActiveFeature(mission);
+  if (active?.status === "active") return { ok: false, reason: "active_not_done", active };
+  autoUnblockResolved(mission);
+  const next = getNextPendingFeature(mission);
+  if (!next) {
+    if (allFeaturesDone(mission)) {
+      mission.status = "complete";
+      mission.autopilot.enabled = false;
+      mission.autopilot.lastStopReason = "mission_complete";
+      autoCompleteMilestones(mission);
+      appendHistory(mission, { event: "mission_complete", note: note ?? "All features complete" });
+      return { ok: false, reason: "mission_complete" };
+    }
+    return { ok: false, reason: "no_unblocked_pending" };
+  }
+  next.status = "active";
+  next.startedAt = next.startedAt ?? Date.now();
+  mission.status = "active";
+  mission.activeFeatureId = next.id;
+  mission.activeMilestoneId = next.milestoneId;
+  appendHistory(mission, { event: "feature_active", featureId: next.id, note });
+  return { ok: true, next };
+}
+function computeMissionMetrics(mission) {
+  const all = getAllFeatures(mission);
+  const history = readHistory(mission.id);
+  const doneFeatures = all.filter((f) => f.status === "done");
+  const failedFeatures = all.filter((f) => f.status === "failed");
+  let acceptanceFailures = 0;
+  let evidenceHashErrors = 0;
+  for (const f of all) {
+    acceptanceFailures += f.acceptance.filter((ac) => !ac.verified && !ac.waived).length;
+    if (f.status === "done" && evidenceIntegrityHash(mission, f.id) === null) evidenceHashErrors++;
+  }
+  const completionEvent = history.find((h) => h.event === "mission_complete");
+  const totalWallMs = completionEvent ? completionEvent.ts * 1e3 - mission.createdAt : Date.now() - mission.createdAt;
+  return {
+    missionId: mission.id,
+    created: mission.createdAt,
+    completed: completionEvent?.ts ? completionEvent.ts * 1e3 : void 0,
+    totalFeatures: all.length,
+    featuresDone: doneFeatures.length,
+    featuresFailed: failedFeatures.length,
+    totalTokensUsed: mission.tokensUsed,
+    totalWallClockMs: totalWallMs,
+    acceptanceFailures,
+    evidenceHashErrors
+  };
+}
+function calculateMetricsSummary() {
+  const missions = listMissions();
+  const metrics = missions.map(computeMissionMetrics);
+  if (metrics.length === 0) {
+    return {
+      totalMissions: 0,
+      completedMissions: 0,
+      successRate: 0,
+      averageTokensPerMission: 0,
+      averageFeaturesPerMission: 0,
+      averageCompletionTimeMs: 0
+    };
+  }
+  const completed = metrics.filter((m) => m.completed !== void 0);
+  const totalTokens = metrics.reduce((s, m) => s + m.totalTokensUsed, 0);
+  const totalFeatures = metrics.reduce((s, m) => s + m.totalFeatures, 0);
+  const totalTime = completed.reduce((s, m) => s + ((m.completed ?? m.created) - m.created), 0);
+  return {
+    totalMissions: metrics.length,
+    completedMissions: completed.length,
+    successRate: completed.length / metrics.length,
+    averageTokensPerMission: totalTokens / metrics.length,
+    averageFeaturesPerMission: totalFeatures / metrics.length,
+    averageCompletionTimeMs: completed.length > 0 ? totalTime / completed.length : 0
+  };
+}
+
+// src/commands/handlers.ts
+init_types();
+import * as fs3 from "fs";
+import * as path4 from "path";
+init_types();
+
+// src/ui/components.ts
+function deriveNextAction(feature) {
+  if (feature.status === "blocked") {
+    return feature.notes ? `Unblock ${feature.id}: ${clip(feature.notes, 72)}` : `Unblock ${feature.id} before continuing`;
+  }
+  if (feature.status === "waiting") {
+    return feature.dependsOn.length ? `Wait for ${feature.dependsOn.join(", ")} before resuming ${feature.id}` : `Resume ${feature.id} when external dependency clears`;
+  }
+  const next = pendingAcceptance(feature, "->")[0];
+  if (next) return `Finish ${feature.id}: ${clip(next, 72)}`;
+  return `Advance ${feature.id}: ${clip(feature.description || feature.title, 72)}`;
+}
+function deriveHandoffSummary(mission, active, next) {
+  const stop = mission.autopilot.lastStopReason;
+  const msg = mission.autopilot.lastStopMessage;
+  if (stop === "needs_user_decision" && msg) return `Needs user decision: ${clip(msg, 78)}`;
+  if (stop === "blocked" && msg) return `Blocked: ${clip(msg, 78)}`;
+  if (active?.notes) return `Carry over: ${clip(active.notes, 78)}`;
+  if (next) return `After ${active?.id ?? "current"} hand off to ${next.id} ${clip(next.title, 52)}`;
+  return "Close out evidence and confirm mission state";
+}
+function buildMissionControlSummary(mission) {
+  const active = getActiveFeature(mission);
+  const blocked = getAllFeatures(mission).filter((f) => f.status === "blocked");
+  const waiting = getAllFeatures(mission).filter((f) => f.status === "waiting");
+  const nextFeature = getNextPendingFeature(mission);
+  return { active, nextFeature, blocked, waiting, handoff: deriveHandoffSummary(mission, active, nextFeature) };
+}
+function updateFooter(ctx, mission) {
+  if (!mission) {
+    ctx.ui.setStatus("pi-mission", "");
+    return;
+  }
+  const p = progress(mission);
+  const active = getActiveFeature(mission);
+  const icon = missionStatusIcon(mission.status);
+  const a = mission.autopilot;
+  const ap = a.enabled ? ` \xB7 \u{1F916} ${a.iteration}/${a.maxIterations} np${a.noProgressTurns}/${a.maxNoProgressTurns} f${a.consecutiveFailures}/${a.maxConsecutiveFailures}` : " \xB7 \u23F9 off";
+  const line = active ? `${icon} ${mission.title} [${p.done}/${p.total} ${p.pct}%] \u2014 ${active.id} ${active.title}${ap}` : `${icon} ${mission.title} [${p.done}/${p.total} ${p.pct}%]${ap}`;
+  ctx.ui.setStatus("pi-mission", line);
+}
+function statusText(mission) {
+  const p = progress(mission);
+  const s = buildMissionControlSummary(mission);
+  const active = s.active;
+  const lines = [
+    `\u{1F3AF} Mission: ${mission.title}`,
+    `ID: ${mission.id}`,
+    `Status: ${mission.status}`,
+    `Goal: ${mission.goal}`,
+    `Progress: ${p.done}/${p.total} (${p.pct}%)`,
+    active ? `Active: ${active.id} \u2014 ${active.title}` : "Active: none",
+    `Blocked/Waiting: ${s.blocked.length}/${s.waiting.length}`,
+    `Next action: ${active ? deriveNextAction(active) : s.nextFeature ? `Start ${s.nextFeature.id} \u2014 ${s.nextFeature.title}` : "None"}`,
+    `Handoff: ${s.handoff}`,
+    `Autopilot: ${mission.autopilot.enabled ? "ON" : "OFF"} (${mission.autopilot.mode})`,
+    `Iteration: ${mission.autopilot.iteration}/${mission.autopilot.maxIterations}`,
+    `Failures: ${mission.autopilot.consecutiveFailures}/${mission.autopilot.maxConsecutiveFailures}`,
+    `No-progress: ${mission.autopilot.noProgressTurns}/${mission.autopilot.maxNoProgressTurns}`,
+    `Last continuation: ${mission.autopilot.lastContinuationAt ?? "never"}`,
+    `Last stop: ${mission.autopilot.lastStopReason ?? "none"}${mission.autopilot.lastStopMessage ? ` - ${mission.autopilot.lastStopMessage}` : ""}`,
+    ""
+  ];
+  for (const m of mission.milestones) {
+    const mi = m.status === "complete" ? "\u2705" : m.status === "active" ? "\u27A1\uFE0F" : "\u2022";
+    const mDone = m.features.filter((f) => f.status === "done").length;
+    lines.push(`${mi} ${m.id}: ${m.title} [${mDone}/${m.features.length}]`);
+    for (const f of m.features) {
+      const mark = featureStatusIcon(f.status);
+      const blocked = f.status === "blocked" && f.notes ? ` \u2014 ${f.notes.slice(0, 50)}` : "";
+      lines.push(`  ${mark} ${f.id}: ${f.title} (${f.status})${blocked}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/engines/metrics.ts
+var SessionMetricsCollector = class _SessionMetricsCollector {
+  metrics;
+  static instance = null;
+  constructor() {
+    this.metrics = this.freshMetrics();
+  }
+  static reset() {
+    _SessionMetricsCollector.instance = null;
+  }
+  static get() {
+    if (!_SessionMetricsCollector.instance) {
+      _SessionMetricsCollector.instance = new _SessionMetricsCollector();
+    }
+    return _SessionMetricsCollector.instance;
+  }
+  freshMetrics() {
+    return {
+      sessionId: `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      startTime: Date.now(),
+      toolCalls: { total: 0, byTool: {}, successful: 0, failed: 0 },
+      tokensUsed: 0,
+      featuresCompleted: 0,
+      errors: { total: 0, byCategory: {} },
+      autoAdvanceCount: 0,
+      stuckDetectionCount: 0
+    };
+  }
+  // ── Public API ────────────────────────────────────────────────────────
+  static getInstance() {
+    if (!_SessionMetricsCollector.instance) {
+      _SessionMetricsCollector.instance = new _SessionMetricsCollector();
+    }
+    return _SessionMetricsCollector.instance;
+  }
+  // Instance methods (delegate to static)
+  recordToolCall(tool, success) {
+    _SessionMetricsCollector.recordToolCall(tool, success);
+  }
+  recordTokenUsage(tokens) {
+    _SessionMetricsCollector.addTokens(tokens);
+  }
+  recordFeatureCompleted() {
+    _SessionMetricsCollector.recordFeatureCompleted();
+  }
+  recordError(category) {
+    _SessionMetricsCollector.recordError(category);
+  }
+  recordAutoAdvance() {
+    _SessionMetricsCollector.recordAutoAdvance();
+  }
+  recordStuckDetection() {
+    _SessionMetricsCollector.recordStuckDetection();
+  }
+  endSession() {
+    _SessionMetricsCollector.endSession();
+  }
+  reset() {
+    _SessionMetricsCollector.reset();
+  }
+  getMetrics() {
+    return _SessionMetricsCollector.getMetrics();
+  }
+  getMetricsSummary() {
+    return _SessionMetricsCollector.getMetricsSummary();
+  }
+  exportMetrics() {
+    return JSON.stringify(_SessionMetricsCollector.getMetrics());
+  }
+  static recordToolCall(tool, success) {
+    const s = _SessionMetricsCollector.get();
+    s.metrics.toolCalls.total++;
+    s.metrics.toolCalls.byTool[tool] = (s.metrics.toolCalls.byTool[tool] ?? 0) + 1;
+    if (success) s.metrics.toolCalls.successful++;
+    else s.metrics.toolCalls.failed++;
+  }
+  static recordError(category) {
+    const s = _SessionMetricsCollector.get();
+    s.metrics.errors.total++;
+    s.metrics.errors.byCategory[category] = (s.metrics.errors.byCategory[category] ?? 0) + 1;
+  }
+  static recordFeatureCompleted() {
+    _SessionMetricsCollector.get().metrics.featuresCompleted++;
+  }
+  static recordAutoAdvance() {
+    _SessionMetricsCollector.get().metrics.autoAdvanceCount++;
+  }
+  static recordStuckDetection() {
+    _SessionMetricsCollector.get().metrics.stuckDetectionCount++;
+  }
+  static addTokens(count) {
+    _SessionMetricsCollector.get().metrics.tokensUsed += count;
+  }
+  static endSession() {
+    const s = _SessionMetricsCollector.get();
+    s.metrics.endTime = Date.now();
+  }
+  static getMetrics() {
+    return { ..._SessionMetricsCollector.get().metrics };
+  }
+  static getMetricsSummary() {
+    const m = _SessionMetricsCollector.get().metrics;
+    const duration = m.endTime ? (m.endTime - m.startTime) / 1e3 : (Date.now() - m.startTime) / 1e3;
+    const successRate = m.toolCalls.total === 0 ? 100 : m.toolCalls.successful / m.toolCalls.total * 100;
+    return [
+      `Session: ${m.sessionId}`,
+      `Duration: ${duration.toFixed(1)}s`,
+      `Tool Calls: ${m.toolCalls.total} (${successRate.toFixed(1)}% success)`,
+      `Features Completed: ${m.featuresCompleted}`,
+      `Auto-Advances: ${m.autoAdvanceCount}`,
+      `Stuck Detections: ${m.stuckDetectionCount}`,
+      `Errors: ${m.errors.total}`,
+      `Tokens Used: ${m.tokensUsed}`
+    ].join("\n");
+  }
+};
+var sessionMetrics = SessionMetricsCollector.getInstance();
+
+// src/ui/dashboard.ts
+function featureNextAction(feature) {
+  if (feature.status === "blocked") return feature.notes ? `Unblock: ${clip(feature.notes)}` : "Unblock before continuing";
+  if (feature.status === "waiting") return feature.dependsOn.length ? `Wait for ${feature.dependsOn.join(", ")}` : "Wait for external dependency";
+  const next = pendingAcceptance(feature)[0];
+  if (next) return `Finish: ${clip(next)}`;
+  return `Advance: ${clip(feature.description || feature.title)}`;
+}
+function featureLabel(f) {
+  const ac = acceptanceProgress(f);
+  const badge = f.acceptance.length ? ` [${ac.label} AC]` : "";
+  return `${featureStatusIcon(f.status)} ${f.id} [P${f.priority}] ${f.title}${badge}`;
+}
+function featureDescription(f, milestoneId) {
+  const deps = f.dependsOn.length ? ` \u{1F517}${f.dependsOn.join(",")}` : "";
+  return `${milestoneId}: ${f.description.slice(0, 70)}${deps}`;
+}
+function buildFeatureItems(mission) {
+  let len = 1;
+  for (const m of mission.milestones) {
+    len += m.features.length;
+  }
+  const items = new Array(len);
+  items[0] = {
+    value: "__session_metrics__",
+    label: "\u{1F4CA} Session Metrics",
+    description: "View current session performance metrics"
+  };
+  let idx = 1;
+  for (const m of mission.milestones) {
+    for (const f of m.features) {
+      items[idx++] = { value: f.id, label: featureLabel(f), description: featureDescription(f, m.id) };
+    }
+  }
+  return items;
+}
+function sessionMetricsLines(width) {
+  const m = sessionMetrics.getMetrics();
+  const barW = Math.min(width - 4, 72);
+  const bar = "\u2500".repeat(barW > 0 ? barW : 40);
+  const duration = m.endTime ? (m.endTime - m.startTime) / 1e3 : (Date.now() - m.startTime) / 1e3;
+  const successRate = m.toolCalls.total === 0 ? 100 : m.toolCalls.successful / m.toolCalls.total * 100;
+  const lines = [bar, "  \u{1F4CA} Session Metrics"];
+  lines.push(`  Session: ${m.sessionId}`);
+  lines.push(`  Health: ${m.errors.total === 0 ? "clean" : `${m.errors.total} errors`}  |  Tool success: ${successRate.toFixed(1)}%`);
+  lines.push(`  Throughput: ${m.featuresCompleted} features  |  ${m.toolCalls.total} tool calls  |  ${m.tokensUsed} tokens`);
+  lines.push(`  Duration: ${duration.toFixed(1)}s  |  Auto-advances: ${m.autoAdvanceCount}  |  Stuck: ${m.stuckDetectionCount}`);
+  if (m.errors.total > 0) {
+    lines.push("  Error categories:");
+    for (const [cat, count] of Object.entries(m.errors.byCategory)) lines.push(`    - ${cat}: ${count}`);
+  }
+  lines.push(bar);
+  return lines;
+}
+var MissionControl = class {
+  mission;
+  tui;
+  onAction;
+  selectedIdx = 0;
+  flatItems = [];
+  filter = "";
+  searchMode = false;
+  width = 80;
+  constructor(mission, tui, onAction) {
+    this.mission = mission;
+    this.tui = tui;
+    this.onAction = onAction;
+    this.flatItems = buildFeatureItems(mission);
+  }
+  visibleItems() {
+    if (!this.filter) return this.flatItems;
+    const q = this.filter.toLowerCase();
+    return this.flatItems.filter(
+      (item) => item.value !== "__session_metrics__" && `${item.value} ${item.label} ${item.description}`.toLowerCase().includes(q)
+    );
+  }
+  clampSelection() {
+    const visible = this.visibleItems();
+    this.selectedIdx = Math.max(0, Math.min(this.selectedIdx, Math.max(visible.length - 1, 0)));
+  }
+  renderDashboardLines() {
+    const p = progress(this.mission);
+    const s = buildMissionControlSummary(this.mission);
+    const visible = this.visibleItems();
+    const selectedValue = visible[this.selectedIdx]?.value;
+    const icon = missionStatusIcon(this.mission.status);
+    const lines = [
+      `${icon} Mission Control \u2014 ${this.mission.title}`,
+      `  Goal: ${clip(this.mission.goal || "No goal", 88)}`,
+      `  Focus: ${s.active ? `${s.active.id} ${s.active.title}` : "None"}  |  Progress: ${p.done}/${p.total} (${p.pct}%)`,
+      `  Blocked/Waiting: ${s.blocked.length}/${s.waiting.length}  |  Handoff: ${clip(s.handoff, 76)}`
+    ];
+    if (s.active) lines.push(`  Next: ${featureNextAction(s.active)}`);
+    lines.push(this.filter ? `  Filter: ${this.filter}  (${visible.length} features)` : "  / to search", "");
+    lines.push("  Milestones  " + progressBar(p.done, p.total, 12) + ` ${p.done}/${p.total} (${p.pct}%)`, "");
+    if (this.filter && visible.length === 0) {
+      lines.push(`  No matching features for "${this.filter}"`, "");
+    }
+    const smItem = this.flatItems[0];
+    if (smItem && smItem.value === "__session_metrics__" && !this.filter) {
+      const smSel = smItem.value === selectedValue;
+      const smPrefix = smSel ? "\u2192" : " ";
+      lines.push(`${smPrefix}   ${smItem.label}`, "");
+      if (smSel) {
+        lines.push(...sessionMetricsLines(this.width));
+        lines.push("");
+      }
+    }
+    for (const m of this.mission.milestones) {
+      const mDone = m.features.filter((f) => f.status === "done").length;
+      const mTotal = m.features.length;
+      const msIcon = m.status === "complete" ? "\u2705" : m.status === "active" ? "\u27A1\uFE0F" : "\u2022";
+      const order = { active: 0, pending: 1, waiting: 2, blocked: 3, failed: 4, done: 5 };
+      const sorted = [...m.features].sort((a, b) => (order[a.status] ?? 5) - (order[b.status] ?? 5) || a.priority - b.priority);
+      const shown = this.filter ? sorted.filter((f) => visible.some((v) => v.value === f.id)) : sorted;
+      if (!shown.length) continue;
+      lines.push(`  ${msIcon} ${m.id}: ${m.title}  ${progressBar(mDone, mTotal, 12)} ${mDone}/${mTotal}`);
+      for (const f of shown) {
+        const sel = f.id === selectedValue;
+        const prefix = sel ? "\u2192" : " ";
+        const ac = acceptanceProgress(f);
+        const badge = f.acceptance.length ? ` [${ac.label} AC]` : "";
+        const deps = f.dependsOn.length ? ` \u{1F517}${f.dependsOn.join(",")}` : "";
+        lines.push(`${prefix}   ${featureStatusIcon(f.status)} ${f.id} [P${f.priority}] ${f.title}${badge}${deps}`);
+        if (sel || f.id === this.mission.activeFeatureId) {
+          lines.push(`      ${f.id}: ${f.title}`);
+          if (f.description) lines.push(`      ${clip(f.description, 88)}`);
+          const chain = dependsOnChain(this.mission, f);
+          if (chain.length) lines.push(`      \u{1F517} Chain: ${formatDepChain(chain)}`);
+          lines.push(`      AC: ${ac.label}${f.dependsOn.length ? `  |  deps: ${f.dependsOn.join(", ")}` : ""}`);
+          lines.push(`      Next: ${featureNextAction(f)}`);
+          for (const a of pendingAcceptance(f).slice(0, 4)) lines.push(`      \u2610 ${clip(a, 82)}`);
+          if (f.startedAt && Date.now() - f.startedAt > 6e5) {
+            lines.push(`      Active ${Math.round((Date.now() - f.startedAt) / 6e4)}min`);
+          }
+          if (f.toolCallCount > 50) lines.push(`      ${f.toolCallCount} tool calls`);
+          if (f.notes) lines.push(`      Note: ${clip(f.notes, 82)}`);
+        }
+      }
+      lines.push("");
+    }
+    lines.push("  Keys: \u2191\u2193/j/k navigate  |  Enter select  |  / search  |  Backspace/Ctrl+U clear  |  Esc close");
+    return lines;
+  }
+  // ── Component interface ────────────────────────────────────────────────
+  render(width) {
+    this.width = width;
+    return this.renderDashboardLines();
+  }
+  invalidate() {
+  }
+  handleInput(data) {
+    if (data === "/") {
+      this.searchMode = true;
+      this.filter = "";
+      this.selectedIdx = 0;
+      this.tui.requestRender();
+      return true;
+    }
+    if (this.searchMode && data.length === 1 && data.charCodeAt(0) >= 32 && data.charCodeAt(0) <= 126) {
+      this.filter += data;
+      this.selectedIdx = 0;
+      this.clampSelection();
+      this.tui.requestRender();
+      return true;
+    }
+    if (data === "\b" || data === "\x7F") {
+      if (this.filter) {
+        this.filter = this.filter.slice(0, -1);
+        this.selectedIdx = 0;
+        this.clampSelection();
+      }
+      this.tui.requestRender();
+      return true;
+    }
+    if (data === "") {
+      this.filter = "";
+      this.searchMode = false;
+      this.selectedIdx = 0;
+      this.tui.requestRender();
+      return true;
+    }
+    if (data === "\x1B[B" || data === "j") {
+      this.selectedIdx = Math.min(this.selectedIdx + 1, Math.max(this.visibleItems().length - 1, 0));
+      this.tui.requestRender();
+      return true;
+    }
+    if (data === "\x1B[A" || data === "k") {
+      this.selectedIdx = Math.max(this.selectedIdx - 1, 0);
+      this.tui.requestRender();
+      return true;
+    }
+    if (data === "\r" || data === "\n") {
+      const item = this.visibleItems()[this.selectedIdx];
+      if (item && item.value !== "__session_metrics__") {
+        this.onAction?.(item.value);
+        this.tui.hideOverlay();
+      }
+      return true;
+    }
+    if (data === "\x1B") {
+      if (this.filter || this.searchMode) {
+        this.filter = "";
+        this.searchMode = false;
+        this.selectedIdx = 0;
+        this.tui.requestRender();
+        return true;
+      }
+      this.tui.hideOverlay();
+      return true;
+    }
+    return false;
+  }
+  dispose() {
+  }
+};
+function missionControlOverlay(mission, onAction) {
+  return (tui) => new MissionControl(mission, tui, onAction);
+}
+
+// src/engines/completion.ts
+var MAX_RECENT_TOOLS = 20;
+var MAX_RECENT_TEXTS = 10;
+var ERROR_FREE_STREAK_THRESHOLD = 5;
+var STUCK_FAILURE_THRESHOLD = 3;
+var STUCK_REPEAT_PATTERN_THRESHOLD = 5;
+var TEXT_LOOP_SIMILARITY_THRESHOLD = 4;
+var CompletionDetector = class {
+  recentToolCalls = [];
+  recentTextOutputs = [];
+  recordToolCall(tool, success) {
+    this.recentToolCalls.push({ tool, success, timestamp: Date.now() });
+    if (this.recentToolCalls.length > MAX_RECENT_TOOLS) this.recentToolCalls.shift();
+  }
+  recordTextOutput(text) {
+    if (!text || text.length < 20) return;
+    const hash = text.slice(0, 100).toLowerCase().replace(/\s+/g, " ").trim();
+    this.recentTextOutputs.push({ hash, timestamp: Date.now() });
+    if (this.recentTextOutputs.length > MAX_RECENT_TEXTS) this.recentTextOutputs.shift();
+  }
+  clearToolCallHistory() {
+    this.recentToolCalls = [];
+    this.recentTextOutputs = [];
+  }
+  // ── Completion detection ────────────────────────────────────────────────
+  detectCompletion(feature, agentText) {
+    const signals = [];
+    const now = Date.now();
+    const kw = this.detectKeywordSignal(agentText, now);
+    if (kw) signals.push(kw);
+    const ac = this.detectAcceptanceSignal(feature, now);
+    if (ac) signals.push(ac);
+    const tp = this.detectToolPatternSignal(now);
+    if (tp) signals.push(tp);
+    const ef = this.detectErrorFreeStreakSignal(now);
+    if (ef) signals.push(ef);
+    return this.aggregateSignals(signals, feature);
+  }
+  detectKeywordSignal(text, now) {
+    const lower = text.toLowerCase();
+    const keywords = [
+      "done",
+      "complete",
+      "completed",
+      "finished",
+      "implemented",
+      "klaar",
+      "voltooid",
+      "tests pass",
+      "tests slagen",
+      "success",
+      "working",
+      "functional",
+      "ready"
+    ];
+    const found = keywords.filter((kw) => lower.includes(kw));
+    if (found.length === 0) return null;
+    const confidence = found.length >= 2 ? "high" : "medium";
+    return { type: "keyword", confidence, evidence: `Found completion keywords: ${found.join(", ")}`, timestamp: now };
+  }
+  detectAcceptanceSignal(feature, now) {
+    if (feature.acceptance.length === 0) return null;
+    const verified = feature.acceptance.filter((ac) => ac.verified).length;
+    const waived = feature.acceptance.filter((ac) => ac.waived).length;
+    const satisfied = verified + waived;
+    const total = feature.acceptance.length;
+    const pct = satisfied / total * 100;
+    if (pct === 100) {
+      return { type: "acceptance", confidence: "high", evidence: `All ${total} acceptance criteria satisfied (${verified} verified, ${waived} waived)`, timestamp: now };
+    }
+    if (pct >= 75) {
+      return { type: "acceptance", confidence: "medium", evidence: `${satisfied}/${total} criteria satisfied (${pct.toFixed(0)}%)`, timestamp: now };
+    }
+    return null;
+  }
+  detectToolPatternSignal(now) {
+    if (this.recentToolCalls.length < 3) return null;
+    const reads = this.recentToolCalls.filter((tc) => tc.tool === "read").length;
+    const pct = reads / this.recentToolCalls.length * 100;
+    if (pct >= 70) {
+      return { type: "tool_pattern", confidence: "medium", evidence: `${pct.toFixed(0)}% of recent ${this.recentToolCalls.length} tool calls were read operations`, timestamp: now };
+    }
+    return null;
+  }
+  detectErrorFreeStreakSignal(now) {
+    if (this.recentToolCalls.length < ERROR_FREE_STREAK_THRESHOLD) return null;
+    const recent = this.recentToolCalls.slice(-ERROR_FREE_STREAK_THRESHOLD);
+    if (recent.every((tc) => tc.success)) {
+      return { type: "error_free_streak", confidence: "medium", evidence: `Last ${ERROR_FREE_STREAK_THRESHOLD} tool calls successful`, timestamp: now };
+    }
+    return null;
+  }
+  // ── Stuck detection ─────────────────────────────────────────────────────
+  detectTextLoop() {
+    if (this.recentTextOutputs.length < TEXT_LOOP_SIMILARITY_THRESHOLD) {
+      return { isStuck: false, reason: "Insufficient text history", suggestedAction: "continue" };
+    }
+    const recent = this.recentTextOutputs.slice(-TEXT_LOOP_SIMILARITY_THRESHOLD);
+    const unique = new Set(recent.map((t) => t.hash));
+    if (unique.size <= 2) {
+      return { isStuck: true, reason: `Text loop: ${unique.size} unique outputs in last ${TEXT_LOOP_SIMILARITY_THRESHOLD} turns`, suggestedAction: "block_self" };
+    }
+    const stuckPhrases = [
+      "i've been stuck in a loop",
+      "i need to ask the user directly",
+      "actually, let me just provide a final summary",
+      "operation aborted"
+    ];
+    let count = 0;
+    for (const t of recent) {
+      if (stuckPhrases.some((p) => t.hash.includes(p))) count++;
+    }
+    if (count >= 3) {
+      return { isStuck: true, reason: `Stuck phrases in ${count}/${TEXT_LOOP_SIMILARITY_THRESHOLD} recent turns`, suggestedAction: "block_self" };
+    }
+    return { isStuck: false, reason: "No text loop detected", suggestedAction: "continue" };
+  }
+  detectStuck() {
+    if (this.recentToolCalls.length < STUCK_FAILURE_THRESHOLD) {
+      return { isStuck: false, reason: "Insufficient tool call history", suggestedAction: "continue" };
+    }
+    const recent = this.recentToolCalls.slice(-STUCK_FAILURE_THRESHOLD);
+    if (recent.every((tc) => !tc.success)) {
+      return { isStuck: true, reason: `${STUCK_FAILURE_THRESHOLD} consecutive failures`, suggestedAction: "block_self" };
+    }
+    const last5 = this.recentToolCalls.slice(-STUCK_REPEAT_PATTERN_THRESHOLD);
+    if (last5.length >= STUCK_REPEAT_PATTERN_THRESHOLD) {
+      const uniqueTools = new Set(last5.map((tc) => tc.tool));
+      if (uniqueTools.size === 1) {
+        return { isStuck: true, reason: `${STUCK_REPEAT_PATTERN_THRESHOLD} consecutive calls to '${last5[0].tool}'`, suggestedAction: "block_self" };
+      }
+    }
+    const recent10 = this.recentToolCalls.slice(-10);
+    if (recent10.length >= 5) {
+      const failures = recent10.filter((tc) => !tc.success).length;
+      if (failures / recent10.length >= 0.7) {
+        return { isStuck: true, reason: `High failure rate: ${failures}/${recent10.length} recent calls`, suggestedAction: "block_self" };
+      }
+    }
+    return { isStuck: false, reason: "No stuck pattern", suggestedAction: "continue" };
+  }
+  // ── Aggregation ─────────────────────────────────────────────────────────
+  aggregateSignals(signals, feature) {
+    if (signals.length === 0) {
+      return { isComplete: false, confidence: "low", signals: [], suggestedAction: "continue", reason: "No completion signals" };
+    }
+    const high = signals.filter((s) => s.confidence === "high").length;
+    const medium = signals.filter((s) => s.confidence === "medium").length;
+    let confidence;
+    if (high >= 2 || high === 1 && medium >= 2) confidence = "high";
+    else if (high === 1 || medium >= 2) confidence = "medium";
+    else confidence = "low";
+    const acPct = feature.acceptance.length > 0 ? feature.acceptance.filter((ac) => ac.verified || ac.waived).length / feature.acceptance.length * 100 : 0;
+    let suggestedAction;
+    let reason;
+    if (confidence === "high" && acPct >= 100) {
+      suggestedAction = "auto_done";
+      reason = "High confidence, all acceptance criteria satisfied";
+    } else if (confidence === "high" && acPct >= 75) {
+      suggestedAction = "suggest_done";
+      reason = "High confidence but some acceptance unverified";
+    } else if (confidence === "medium" && acPct >= 100) {
+      suggestedAction = "suggest_done";
+      reason = "Medium confidence, all acceptance satisfied";
+    } else if (confidence === "medium") {
+      suggestedAction = "ask_user";
+      reason = "Medium confidence \u2014 ask user";
+    } else {
+      suggestedAction = "continue";
+      reason = "Low confidence \u2014 continue";
+    }
+    return {
+      isComplete: suggestedAction === "auto_done" || suggestedAction === "suggest_done",
+      confidence,
+      signals,
+      suggestedAction,
+      reason
+    };
+  }
+};
+var globalDetector = null;
+function getCompletionDetector() {
+  if (!globalDetector) globalDetector = new CompletionDetector();
+  return globalDetector;
+}
+
+// src/engines/autopilot.ts
+function shouldContinue(mission, ctx) {
+  const a = mission.autopilot;
+  if (!a.enabled) return { continue: false, reason: "disabled" };
+  if (mission.status === "paused") return { continue: false, reason: "paused_by_user" };
+  if (mission.status === "blocked") return { continue: false, reason: "blocked" };
+  if (mission.status === "complete") return { continue: false, reason: "mission_complete" };
+  if (a.iteration >= a.maxIterations) return { continue: false, reason: "max_iterations" };
+  if (a.consecutiveFailures >= a.maxConsecutiveFailures) return { continue: false, reason: "max_consecutive_failures" };
+  if (a.noProgressTurns >= a.maxNoProgressTurns) return { continue: false, reason: "no_progress" };
+  const usage = ctx?.getContextUsage?.() ?? { percent: 0 };
+  if ((usage.percent ?? 0) > a.maxContextPercent) return { continue: false, reason: "context_limit" };
+  return { continue: true };
+}
+function ensureActiveFeature(mission) {
+  let feature = getActiveFeature(mission);
+  if (feature && feature.status === "active") return feature;
+  autoUnblockResolved(mission);
+  const next = getNextPendingFeature(mission);
+  if (next) {
+    next.status = "active";
+    mission.activeFeatureId = next.id;
+    mission.activeMilestoneId = next.milestoneId;
+    appendHistory(mission, { event: "feature_active", featureId: next.id });
+    return next;
+  }
+  if (mission.milestones.every((m) => m.features.every((f) => f.status === "done"))) {
+    mission.status = "complete";
+    mission.autopilot.enabled = false;
+    mission.autopilot.lastStopReason = "mission_complete";
+  }
+  return null;
+}
+function buildContinuationPrompt(mission) {
+  const feature = getActiveFeature(mission) || { id: "none", title: "no active feature" };
+  return [
+    `Mission: ${mission.title}`,
+    `Active feature: ${feature.id} - ${feature.title}`,
+    `Autopilot iteration: ${mission.autopilot.iteration}`,
+    "",
+    "Continue the mission with ONE controlled turn. After this turn the autopilot will evaluate progress and decide whether to continue or stop.",
+    "Stop conditions: mission complete, user stop, blocker, max iterations, etc."
+  ].join("\n");
+}
+async function triggerContinuation(pi, ctx, mission) {
+  const decision = shouldContinue(mission, ctx);
+  if (!decision.continue) {
+    mission.autopilot.lastStopReason = decision.reason;
+    await saveMissionSafe(mission);
+    updateFooter(ctx, mission);
+    return;
+  }
+  mission.autopilot.iteration++;
+  mission.autopilot.lastContinuationAt = (/* @__PURE__ */ new Date()).toISOString();
+  await pi.sendUserMessage(buildContinuationPrompt(mission));
+  await saveMissionSafe(mission);
+  updateFooter(ctx, mission);
+}
+async function processAgentEndForAutopilot(pi, ctx, event, runtime) {
+  const mission = runtime.activeMission;
+  if (!mission?.autopilot?.enabled) return;
+  const feature = getActiveFeature(mission);
+  const text = (event.messages ?? []).flatMap((m) => Array.isArray(m.content) ? m.content : []).filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => c.text).join("\n");
+  const lower = text.toLowerCase();
+  const wasAborted = /\b(operation aborted|operation cancelled|action cancelled)\b/i.test(text);
+  const detector = getCompletionDetector();
+  const textLoop = detector.detectTextLoop();
+  const inTextLoop = textLoop.isStuck;
+  const wantsToAskUser = /\b(need to ask the user|should ask the user|must ask the user)\b/i.test(lower) && !lower.includes("mission_ask_user");
+  const isBlocked = mission.status === "blocked" || feature && feature.status === "blocked" || /\b(blocked|block self|self-block|stuck|cannot proceed|deadlock|need external|api key|permission)\b/i.test(lower);
+  if (inTextLoop || wasAborted) {
+    mission.autopilot.noProgressTurns += (inTextLoop ? 2 : 0) + (wasAborted ? 1 : 0);
+  }
+  if (wantsToAskUser) {
+    mission.autopilot.enabled = false;
+    mission.autopilot.lastStopReason = "needs_user_decision";
+    mission.autopilot.lastStopMessage = text.slice(0, 200);
+    appendHistory(mission, { event: "autopilot_stopped", note: "needs_user_decision (model wants to ask)" });
+    await saveMissionSafe(mission);
+    updateFooter(ctx, mission);
+    return;
+  }
+  if (isBlocked) {
+    mission.autopilot.enabled = false;
+    mission.autopilot.lastStopReason = "blocked";
+    mission.autopilot.lastStopMessage = text.slice(0, 200);
+    if (feature) feature.status = "blocked";
+    appendHistory(mission, { event: "autopilot_stopped", note: "blocked" });
+    await saveMissionSafe(mission);
+    updateFooter(ctx, mission);
+    return;
+  }
+  const madeProgress = !lower.includes("no progress") && !lower.includes("same state");
+  if (!madeProgress) mission.autopilot.noProgressTurns++;
+  else mission.autopilot.noProgressTurns = Math.max(0, mission.autopilot.noProgressTurns - 1);
+  const hasError = lower.includes("error") || lower.includes("failed");
+  if (hasError) mission.autopilot.consecutiveFailures++;
+  else mission.autopilot.consecutiveFailures = 0;
+  const decision = shouldContinue(mission, ctx);
+  if (decision.continue) {
+    await triggerContinuation(pi, ctx, mission);
+  } else {
+    mission.autopilot.enabled = false;
+    mission.autopilot.lastStopReason = decision.reason;
+    appendHistory(mission, { event: "autopilot_stopped", note: decision.reason });
+    await saveMissionSafe(mission);
+    updateFooter(ctx, mission);
+  }
+}
+
+// src/engines/worker.ts
+import { spawn } from "child_process";
+var activeWorker = null;
+function getActiveWorker() {
+  return activeWorker;
+}
+function isWorkerRunning() {
+  return activeWorker?.status === "running";
+}
+function getExtensionPath() {
+  return process.env.PI_MISSIONS_EXTENSION_PATH || null;
+}
+var MAX_STDOUT_BYTES = 5e4;
+var MAX_STDERR_BYTES = 25e3;
+function buildWorkerPrompt(mission, feature, customPrompt) {
+  const context = buildLeanContext(mission);
+  const lines = [
+    context,
+    "",
+    `You are a worker agent executing a single feature in a software development mission.`,
+    ``,
+    `## First: Load the mission`,
+    `Run: /mission load ${mission.id}`,
+    ``,
+    `3. Implement the smallest, most coherent change that satisfies the acceptance criteria`,
+    `4. When ALL acceptance criteria are satisfied, call **mission_feature_done** with evidence`,
+    `5. If you get stuck, call **mission_block_self** with a clear reason`,
+    `6. If you need user input, call **mission_ask_user**`,
+    `7. Do NOT move to the NEXT feature \u2014 just complete this one and stop`
+  ];
+  if (customPrompt) {
+    lines.push("", "## Additional Instructions", customPrompt);
+  }
+  lines.push(
+    "",
+    "## Output",
+    "Provide a brief summary of what you accomplished, then call mission_feature_done with evidence."
+  );
+  return lines.join("\n");
+}
+function spawnWorker(mission, config) {
+  if (isWorkerRunning()) {
+    const running = activeWorker;
+    if (running) {
+      return Promise.resolve({ error: `Worker already running for feature ${running.featureId}. Wait for it to finish.` });
+    }
+  }
+  const feature = getFeatureById(mission, config.featureId);
+  if (!feature) {
+    return Promise.resolve({ error: `Feature not found: ${config.featureId}` });
+  }
+  const prompt = buildWorkerPrompt(mission, feature, config.customPrompt);
+  const piPath = process.env.PI_PATH || "pi";
+  const model = config.model || process.env.PI_WORKER_MODEL || "auto";
+  const timeoutMs = config.timeoutMs ?? 6e5;
+  const extPath = getExtensionPath();
+  const args = ["--model", model];
+  if (extPath) {
+    args.push("-e", extPath);
+  }
+  args.push(prompt);
+  const child = spawn(piPath, args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, PI_NO_COLOR: "1" }
+  });
+  let stdout = "";
+  let stderr = "";
+  let killed = false;
+  child.stdout?.on("data", (chunk) => {
+    if (stdout.length < MAX_STDOUT_BYTES) {
+      stdout += chunk.toString().slice(0, MAX_STDOUT_BYTES - stdout.length);
+    }
+  });
+  child.stderr?.on("data", (chunk) => {
+    if (stderr.length < MAX_STDERR_BYTES) {
+      stderr += chunk.toString().slice(0, MAX_STDERR_BYTES - stderr.length);
+    }
+  });
+  const startedAt = Date.now();
+  activeWorker = {
+    process: child,
+    featureId: config.featureId,
+    startedAt,
+    status: "running"
+  };
+  const timeout = setTimeout(() => {
+    killed = true;
+    if (activeWorker) activeWorker.status = "timeout";
+    child.kill("SIGTERM");
+    setTimeout(() => {
+      if (!child.killed) child.kill("SIGKILL");
+    }, 5e3);
+  }, timeoutMs);
+  return new Promise((resolve3) => {
+    child.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      const durationMs = Date.now() - startedAt;
+      const result = {
+        featureId: config.featureId,
+        exitCode: code,
+        signal: signal ?? null,
+        stdout,
+        stderr,
+        durationMs,
+        killed
+      };
+      if (activeWorker) {
+        activeWorker.result = result;
+        activeWorker.status = result.killed ? "timeout" : result.exitCode === 0 ? "done" : "error";
+      }
+      try {
+        const missionId = mission.id;
+        appendHistory(mission, {
+          event: "worker_finished",
+          featureId: config.featureId,
+          note: `Exit ${code}${signal ? ` (${signal})` : ""} in ${Math.round(durationMs / 1e3)}s`,
+          details: {
+            exitCode: code,
+            signal: signal ?? void 0,
+            durationMs,
+            killed,
+            missionId,
+            stdoutLen: stdout.length,
+            stderrLen: stderr.length,
+            model
+          }
+        });
+        saveMissionSafe(mission).catch(() => {
+        });
+      } catch {
+      }
+      resolve3(result);
+    });
+    child.on("error", (err) => {
+      clearTimeout(timeout);
+      activeWorker = null;
+      resolve3({
+        error: `Worker process error: ${err.message}`
+      });
+    });
+  });
+}
+function killWorker() {
+  if (!activeWorker || activeWorker.status !== "running") return false;
+  activeWorker.process.kill("SIGTERM");
+  return true;
+}
+
+// src/tools/index.ts
+init_types();
+import { Type as Type2 } from "@sinclair/typebox";
+
+// src/engines/recovery.ts
+import * as crypto2 from "crypto";
+var ErrorRecoveryEngine = class {
+  errorRecords = /* @__PURE__ */ new Map();
+  activeRetries = /* @__PURE__ */ new Map();
+  alertCallbacks = /* @__PURE__ */ new Set();
+  consecutiveFailures = /* @__PURE__ */ new Map();
+  alertThresholds = {
+    criticalErrors: 1,
+    consecutiveFailures: 3,
+    totalErrorsBeforeAlert: 5,
+    windowMs: 6e4
+  };
+  strategies = /* @__PURE__ */ new Map([
+    ["transient", { category: "transient", maxRetries: 3, backoffMs: 1e3, fallbackAction: "retry" }],
+    ["network", { category: "network", maxRetries: 5, backoffMs: 2e3, fallbackAction: "retry" }],
+    ["permission", { category: "permission", maxRetries: 0, backoffMs: 0, fallbackAction: "ask_user" }],
+    ["permanent", { category: "permanent", maxRetries: 0, backoffMs: 0, fallbackAction: "block" }],
+    ["user", { category: "user", maxRetries: 0, backoffMs: 0, fallbackAction: "ask_user" }],
+    ["system", { category: "system", maxRetries: 2, backoffMs: 5e3, fallbackAction: "degrade" }],
+    ["unknown", { category: "unknown", maxRetries: 1, backoffMs: 1e3, fallbackAction: "skip" }]
+  ]);
+  onAlert(cb) {
+    this.alertCallbacks.add(cb);
+    return () => this.alertCallbacks.delete(cb);
+  }
+  setAlertThresholds(t) {
+    Object.assign(this.alertThresholds, t);
+  }
+  fireAlert(type, record, message) {
+    const recent = Array.from(this.errorRecords.values()).filter(
+      (r) => Date.now() - r.timestamp < this.alertThresholds.windowMs
+    );
+    const stats = {
+      total: this.errorRecords.size,
+      critical: recent.filter((r) => r.severity === "critical").length,
+      recent: recent.length
+    };
+    for (const cb of this.alertCallbacks) {
+      try {
+        cb({ type, record, stats, message });
+      } catch {
+      }
+    }
+  }
+  opKey(ctx) {
+    return `${ctx.toolName ?? "unknown"}:${ctx.featureId ?? "global"}`;
+  }
+  categorizeError(ctx) {
+    const msg = ctx.errorMessage.toLowerCase();
+    if (msg.includes("network") || msg.includes("connection") || msg.includes("timeout") || msg.includes("econnrefused") || msg.includes("enotfound") || msg.includes("etimedout")) return "network";
+    if (msg.includes("permission") || msg.includes("access denied") || msg.includes("eacces") || msg.includes("eperm") || ctx.errorType.toLowerCase().includes("permission")) return "permission";
+    if (msg.includes("invalid input") || msg.includes("validation") || msg.includes("user") || ctx.errorType.toLowerCase().includes("validation") || ctx.errorType.toLowerCase().includes("user")) return "user";
+    if (msg.includes("temporary") || msg.includes("retry") || msg.includes("busy") || msg.includes("locked") || msg.includes("eagain") || msg.includes("ebusy")) return "transient";
+    if (msg.includes("memory") || msg.includes("disk") || msg.includes("space") || ctx.errorType.toLowerCase().includes("system")) return "system";
+    if (msg.includes("syntax") || msg.includes("parse") || ctx.errorType.toLowerCase().includes("syntax") || ctx.errorType.toLowerCase().includes("parse")) return "permanent";
+    return "unknown";
+  }
+  determineSeverity(category) {
+    if (category === "permanent" || category === "permission") return "critical";
+    if (category === "system") return "high";
+    if (category === "network" || category === "unknown") return "medium";
+    return "low";
+  }
+  handleError(ctx) {
+    const category = this.categorizeError(ctx);
+    const severity = this.determineSeverity(category);
+    const strategy = this.strategies.get(category) ?? this.strategies.get("unknown");
+    const errorKey = `${ctx.toolName ?? "unknown"}:${ctx.errorType}:${ctx.featureId ?? "none"}`;
+    const retryState = this.activeRetries.get(errorKey);
+    const retryCount = retryState?.count ?? 0;
+    const key = this.opKey(ctx);
+    const consecutive = (this.consecutiveFailures.get(key) ?? 0) + 1;
+    this.consecutiveFailures.set(key, consecutive);
+    const record = {
+      id: crypto2.randomUUID(),
+      context: ctx,
+      category,
+      severity,
+      retryCount,
+      actionTaken: "skip",
+      resolved: false,
+      timestamp: Date.now()
+    };
+    let action;
+    let shouldRetry = false;
+    let retryAfter;
+    if (retryCount < strategy.maxRetries) {
+      action = strategy.fallbackAction ?? "retry";
+      shouldRetry = action === "retry";
+      if (shouldRetry) {
+        retryAfter = strategy.backoffMs * Math.pow(2, retryCount);
+        this.activeRetries.set(errorKey, { count: retryCount + 1, lastAttempt: Date.now() });
+      }
+    } else {
+      action = strategy.fallbackAction ?? "skip";
+    }
+    record.actionTaken = action;
+    this.errorRecords.set(record.id, record);
+    if (severity === "critical") this.fireAlert("error_critical", record, `Critical: ${ctx.errorMessage}`);
+    if (consecutive >= this.alertThresholds.consecutiveFailures) this.fireAlert("error_threshold", record, `${consecutive} consecutive failures for ${key}`);
+    if (action === "skip" || action === "block") this.fireAlert("recovery_failed", record, `Recovery failed: ${action}`);
+    if (retryCount >= strategy.maxRetries && !shouldRetry) this.fireAlert("retry_exhausted", record, `Retries exhausted after ${retryCount} for ${key}`);
+    return { action, shouldRetry, retryAfter, record };
+  }
+  markResolved(recordId) {
+    const record = this.errorRecords.get(recordId);
+    if (record) {
+      record.resolved = true;
+      this.activeRetries.delete(`${record.context.toolName ?? "unknown"}:${record.context.errorType}:${record.context.featureId ?? "none"}`);
+      this.consecutiveFailures.delete(this.opKey(record.context));
+    }
+  }
+  clearConsecutiveFailures(toolName, featureId) {
+    if (!toolName && !featureId) {
+      this.consecutiveFailures.clear();
+      return;
+    }
+    const filter = `${toolName ?? "unknown"}:${featureId ?? "global"}`;
+    for (const key of this.consecutiveFailures.keys()) {
+      if (key === filter || toolName && key.startsWith(`${toolName}:`) || featureId && key.endsWith(`:${featureId}`)) {
+        this.consecutiveFailures.delete(key);
+      }
+    }
+  }
+  getErrorsForFeature(featureId) {
+    return Array.from(this.errorRecords.values()).filter((r) => r.context.featureId === featureId);
+  }
+  getErrorsForMission(missionId) {
+    return Array.from(this.errorRecords.values()).filter((r) => r.context.missionId === missionId);
+  }
+  clearErrors() {
+    this.errorRecords.clear();
+    this.activeRetries.clear();
+  }
+  clearErrorsForFeature(featureId) {
+    for (const [id, record] of this.errorRecords) {
+      if (record.context.featureId === featureId) {
+        this.activeRetries.delete(`${record.context.toolName ?? "unknown"}:${record.context.errorType}:${record.context.featureId ?? "none"}`);
+        this.errorRecords.delete(id);
+      }
+    }
+  }
+  getStats() {
+    const records = Array.from(this.errorRecords.values());
+    const byCategory = { transient: 0, permanent: 0, user: 0, system: 0, network: 0, permission: 0, unknown: 0 };
+    const bySeverity = { low: 0, medium: 0, high: 0, critical: 0 };
+    for (const r of records) {
+      byCategory[r.category]++;
+      bySeverity[r.severity]++;
+    }
+    return { total: records.length, resolved: records.filter((r) => r.resolved).length, byCategory, bySeverity };
+  }
+  setStrategy(category, strategy) {
+    this.strategies.set(category, strategy);
+  }
+};
+var globalEngine = null;
+function getErrorRecoveryEngine() {
+  if (!globalEngine) globalEngine = new ErrorRecoveryEngine();
+  return globalEngine;
+}
+
+// src/tools/index.ts
+var PLANNING_RO_BASH = /* @__PURE__ */ new Set([
+  "cat",
+  "grep",
+  "head",
+  "ls",
+  "pwd",
+  "rg",
+  "tail",
+  "wc"
+]);
+function firstWord(cmd) {
+  const m = cmd.trim().match(/^([A-Za-z0-9_.-]+)/);
+  return m?.[1] ?? "";
+}
+function hasOpt(cmd, opt) {
+  const escaped = opt.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?:^|\\s)${escaped}(?:\\s|$)`).test(cmd);
+}
+function isReadOnlyFind(cmd) {
+  return /^find(?:\s|$)/.test(cmd) && !/\s-(?:delete|exec|execdir|ok|okdir|fls|fprint|fprint0|fprintf)(?:\s|$)/.test(cmd);
+}
+function isReadOnlySed(cmd) {
+  return /^sed\s+-n(?:\s|$)/.test(cmd) && !hasOpt(cmd, "-i") && !hasOpt(cmd, "--in-place");
+}
+function isReadOnlyPlanningBash(input) {
+  const cmd = typeof input?.command === "string" ? input.command.trim() : "";
+  if (!cmd) return false;
+  if (/[;&|`$<>\n\r\t]/.test(cmd)) return false;
+  const w = firstWord(cmd);
+  if (PLANNING_RO_BASH.has(w)) return true;
+  const strippedCmd = cmd.replace(/['"\\]/g, "");
+  if (w === "find") return isReadOnlyFind(strippedCmd);
+  if (w === "sed") return isReadOnlySed(strippedCmd);
+  if (w === "git") return /^git\s+(?:status|diff|show|log)(?:\s|$)/.test(cmd);
+  return false;
+}
+function toolResultErrorMessage(event) {
+  const text = event.content?.filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => c.text).join("\n").trim();
+  return text || `Tool '${event.toolName}' failed`;
+}
+function cloneFeatureForFork(feature, id, title, notes) {
+  const acLen = feature.acceptance.length;
+  const newAcceptance = new Array(acLen);
+  for (let i = 0; i < acLen; i++) {
+    const ac = feature.acceptance[i];
+    newAcceptance[i] = { ...ac, verified: false, evidence: void 0 };
+  }
+  return {
+    ...feature,
+    id,
+    title,
+    status: "active",
+    notes,
+    completedAt: void 0,
+    dependsOn: [...feature.dependsOn],
+    sessions: [...feature.sessions],
+    acceptance: newAcceptance
+  };
+}
+function appendForkNote(existing, entries) {
+  const filtered = entries.filter(Boolean);
+  return existing ? `${existing}
+
+${filtered.join("\n")}` : filtered.join("\n");
+}
+function pushSessionRef(feature, ref) {
+  if (ref) feature.sessions.push(ref);
+}
+function buildForkKickoffMessage(missionTitle, source, forked, reason, subtask, parentSessionFile) {
+  const lines = [
+    `## Forked Mission: ${missionTitle}`,
+    `Source: ${source.id} \u2014 ${source.title}`,
+    `Fork: ${forked.id} \u2014 ${forked.title}`,
+    `Reason: ${reason}`
+  ];
+  if (subtask) lines.push(`Subtask: ${subtask}`);
+  if (parentSessionFile) lines.push(`Parent session: ${parentSessionFile}`);
+  lines.push(
+    "",
+    `Active fork feature: ${forked.id} \u2014 ${forked.title}`,
+    "Continue mission: work ONLY on the forked feature. When complete:",
+    `1. Call mission_feature_done with evidence.`,
+    `2. The original ${source.id} is blocked \u2014 the user will resolve it.`
+  );
+  return lines.join("\n");
+}
+function buildManualForkHandoff(missionTitle, source, forked, reason, parentLeafId, parentSessionFile) {
+  const lines = [
+    `\u{1F500} Manual fork handoff for ${missionTitle}:`,
+    `   Source: ${source.id} \u2014 ${source.title}`,
+    `   Fork: ${forked.id} \u2014 ${forked.title}`,
+    `   Reason: ${reason}`
+  ];
+  if (parentLeafId) lines.push(`   Parent leaf: ${parentLeafId}`);
+  if (parentSessionFile) lines.push(`   Parent session: ${parentSessionFile}`);
+  lines.push(
+    "",
+    "Action: open or clone a new Pi session and load this mission via /mission load <id>.",
+    `Focus on: ${forked.id} \u2014 ${forked.title}`
+  );
+  return lines.join("\n");
+}
+function injectMissionContext(pi, ctx, mission, reason, content) {
+  const details = { missionId: mission.id, reason, injectedAt: Date.now() };
+  const sm = ctx.sessionManager;
+  if (typeof sm.appendCustomMessageEntry === "function") {
+    sm.appendCustomMessageEntry("pi-mission-context", content, false, details);
+  }
+  pi.appendEntry("pi-mission-context", { ...details, content });
+}
+function enforceToolPolicy(toolName, phase, input, allowBashInPlanning, toolCallCount) {
+  const policy = TOOL_POLICIES[phase];
+  if (policy.allowedTools.includes(toolName)) return { blocked: false };
+  const allowedBash = phase === "planning" && toolName === "bash" && (allowBashInPlanning || isReadOnlyPlanningBash(input));
+  if (allowedBash) return { blocked: false };
+  if (phase === "planning" && toolName === "bash") {
+    return { blocked: true, reason: "Tool 'bash' is only allowed in planning phase for single read-only commands: pwd, ls, find, grep, rg, cat, sed -n, head, tail, wc, git status/diff/show/log." };
+  }
+  return { blocked: true, reason: `'${toolName}' not allowed in ${phase}. Allowed: ${policy.allowedTools.join(", ")}` };
+}
+function enforceToolMax(phase, count) {
+  const max = TOOL_POLICIES[phase].maxToolCalls;
+  if (count > max) return { blocked: true, reason: `Max tool calls (${max}) exceeded for ${phase} phase.` };
+  return { blocked: false };
+}
+function registerMissionTools(_pi, runtime) {
+  const pi = _pi;
+  pi.registerTool({
+    name: "mission_feature_done",
+    label: "Mission Feature Done",
+    description: "Mark the active mission feature as done with evidence.",
+    promptSnippet: "Mark the active mission feature as done with evidence",
+    promptGuidelines: ["Use only after all acceptance criteria are satisfied and evidence is available."],
+    parameters: Type2.Object({
+      evidence: Type2.String({ description: "Completion evidence" }),
+      notes: Type2.Optional(Type2.String({ description: "Optional notes" }))
+    }),
+    async execute(_id, params, _sig, _upd, ctx) {
+      const m = runtime.activeMission;
+      const f = m ? getActiveFeature(m) : null;
+      if (!m || !f) return { isError: true, content: [{ type: "text", text: "No active mission feature." }], details: {} };
+      const result = completeActiveFeature(m, {
+        evidence: String(params.evidence ?? ""),
+        notes: typeof params.notes === "string" ? params.notes : void 0
+      });
+      if (!result.ok) return { isError: true, content: [{ type: "text", text: `${result.reason}
+Use /mission edit to waive criteria.` }], details: {} };
+      await saveMissionSafe(m);
+      updateFooter(ctx, m);
+      return { content: [{ type: "text", text: `\u2705 Feature ${result.feature.id} done. Evidence: ${result.evidenceFile}` }], details: { featureId: result.feature.id, evidenceFile: result.evidenceFile }, isError: false };
+    }
+  });
+  pi.registerTool({
+    name: "mission_next_feature",
+    label: "Next Feature",
+    description: "Advance to the next pending mission feature.",
+    parameters: Type2.Object({}),
+    async execute(_id, _p, _sig, _upd, ctx) {
+      const m = runtime.activeMission;
+      if (!m) return { isError: true, content: [{ type: "text", text: "No active mission." }], details: {} };
+      const result = activateNextFeature(m);
+      if (!result.ok) {
+        if (result.reason === "active_not_done") {
+          return { isError: true, content: [{ type: "text", text: `Active feature not done yet: ${result.active.id} \u2014 ${result.active.title}. Use mission_feature_done or /mission block.` }], details: {} };
+        }
+        if (result.reason === "mission_complete") {
+          await saveMissionSafe(m);
+          updateFooter(ctx, m);
+          return { content: [{ type: "text", text: "\u{1F389} Mission complete." }], details: { missionId: m.id }, isError: false };
+        }
+        return { isError: true, content: [{ type: "text", text: "No unblocked pending feature found." }], details: {} };
+      }
+      await saveMissionSafe(m);
+      updateFooter(ctx, m);
+      return { content: [{ type: "text", text: `\u27A1\uFE0F Active feature: ${result.next.id} \u2014 ${result.next.title}
+${result.next.description}` }], details: { feature: result.next }, isError: false };
+    }
+  });
+  pi.registerTool({
+    name: "mission_ask_user",
+    label: "Ask User",
+    description: "Ask the user a question during mission execution.",
+    promptSnippet: "Ask the user a question",
+    promptGuidelines: [
+      "Use when you need user input to proceed.",
+      "Use 'confirm' for yes/no, 'select' for choices, 'input' for text.",
+      "Always provide a sensible default."
+    ],
+    parameters: Type2.Object({
+      question: Type2.String({ description: "The question to ask" }),
+      questionType: Type2.Optional(Type2.String({ description: "input, confirm, or select", enum: ["input", "confirm", "select"] })),
+      options: Type2.Optional(Type2.Array(Type2.String({ description: "Options for select" }))),
+      defaultValue: Type2.Optional(Type2.String({ description: "Default value" })),
+      context: Type2.Optional(Type2.String({ description: "Additional context" }))
+    }),
+    async execute(_id, params, _sig, _upd, ctx) {
+      const m = runtime.activeMission;
+      if (!m) throw new Error("No active mission.");
+      const f = getActiveFeature(m);
+      m.autopilot.enabled = false;
+      m.autopilot.lastStopReason = "needs_user_decision";
+      m.autopilot.lastStopMessage = String(params.question ?? "");
+      appendHistory(m, { event: "user_asked", featureId: f?.id, note: `Q: ${params.question}`, details: { questionType: params.questionType, options: params.options, defaultValue: params.defaultValue } });
+      const qType = String(params.questionType ?? "input");
+      const dflt = typeof params.defaultValue === "string" ? params.defaultValue : null;
+      let answer = null;
+      let source = "no_ui";
+      if (ctx.hasUI) {
+        try {
+          switch (qType) {
+            case "confirm":
+              answer = await ctx.ui.confirm(String(params.question ?? ""), String(params.context ?? "")) ? "yes" : "no";
+              break;
+            case "select": {
+              const opts = Array.isArray(params.options) ? params.options.map(String) : [];
+              if (!opts.length) throw new Error("Select requires options");
+              const choice = await ctx.ui.select(String(params.question ?? ""), opts);
+              answer = choice || dflt || null;
+              break;
+            }
+            default:
+              answer = await ctx.ui.input(String(params.question ?? ""), String(params.context ?? "")) || dflt || null;
+          }
+          source = "ui";
+        } catch {
+          answer = dflt;
+          source = "default";
+        }
+      } else {
+        answer = dflt || "[No UI available]";
+      }
+      if (f) appendHistory(m, { event: "user_answered", featureId: f.id, note: `A: ${answer}`, details: { answer, answerSource: source, questionType: qType } });
+      if (answer === "ALLOW_BASH_IN_PLANNING") {
+        m.userPreferences = m.userPreferences ?? {};
+        m.userPreferences.allowBashInPlanning = true;
+        await saveMissionSafe(m);
+      }
+      return { content: [{ type: "text", text: `User answered: ${answer}${source !== "ui" ? ` (via ${source})` : ""}` }], details: { question: params.question, answer, answerSource: source }, isError: false };
+    }
+  });
+  pi.registerTool({
+    name: "mission_block_self",
+    label: "Block Self",
+    description: "Block the current feature when stuck.",
+    promptSnippet: "Block the current feature",
+    promptGuidelines: ["Use when stuck. Provide a clear reason."],
+    parameters: Type2.Object({
+      reason: Type2.String({ description: "Reason for blocking" }),
+      context: Type2.Optional(Type2.String({ description: "Additional context" }))
+    }),
+    async execute(_id, params, _sig, _upd, ctx) {
+      const m = runtime.activeMission;
+      const f = m ? getActiveFeature(m) : null;
+      if (!m || !f) throw new Error("No active feature.");
+      f.status = "blocked";
+      f.notes = `Self-blocked: ${params.reason}${params.context ? `
+
+Context: ${params.context}` : ""}`;
+      m.status = "blocked";
+      m.autopilot.enabled = false;
+      m.autopilot.lastStopReason = "blocked";
+      m.autopilot.lastStopMessage = String(params.reason ?? "");
+      appendHistory(m, { event: "feature_blocked", featureId: f.id, note: String(params.reason ?? ""), details: { context: params.context, self: true } });
+      autoUnblockResolved(m);
+      const next = getNextPendingFeature(m);
+      if (next) {
+        next.status = "active";
+        m.status = "active";
+        m.activeFeatureId = next.id;
+        m.activeMilestoneId = next.milestoneId;
+        m.autopilot.lastStopReason = void 0;
+        m.autopilot.lastStopMessage = void 0;
+        appendHistory(m, { event: "feature_active", featureId: next.id, note: "Auto-advanced after self-block" });
+        await saveMissionSafe(m);
+        updateFooter(ctx, m);
+        return { content: [{ type: "text", text: `\u{1F6AB} Self-blocked ${f.id}: ${params.reason}
+\u27A1\uFE0F Auto-advanced to ${next.id} \u2014 ${next.title}` }], details: { featureId: f.id, nextFeatureId: next.id }, isError: false };
+      }
+      await saveMissionSafe(m);
+      updateFooter(ctx, m);
+      throw new Error(`Self-blocked ${f.id}: ${params.reason}. No pending features available.`);
+    }
+  });
+  pi.registerTool({
+    name: "mission_fork",
+    label: "Fork Feature",
+    description: "Fork the current feature into a separate session.",
+    promptSnippet: "Fork the current feature",
+    promptGuidelines: ["Use for parallel work or isolation. Provide a clear reason."],
+    parameters: Type2.Object({
+      reason: Type2.String({ description: "Reason for forking" }),
+      subtask: Type2.Optional(Type2.String({ description: "Specific subtask" }))
+    }),
+    async execute(_id, params, _sig, _upd, ctx) {
+      const m = runtime.activeMission;
+      const f = m ? getActiveFeature(m) : null;
+      if (!m || !f) throw new Error("No active feature.");
+      const sm = ctx.sessionManager;
+      const reason = String(params.reason ?? "Alternative approach");
+      const parentLeafId = sm.getLeafId?.() ?? null;
+      const parentSessionFile = sm.getSessionFile?.();
+      const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+      const forked = cloneFeatureForFork(f, `${f.id}-fork-${Date.now()}`, `${f.title} [fork]`, `Fork: ${reason}${params.subtask ? ` (${params.subtask})` : ""}`);
+      const milestone = getMilestoneById(m, f.milestoneId);
+      if (!milestone) return { isError: true, content: [{ type: "text", text: "Milestone not found." }], details: {} };
+      f.status = "blocked";
+      f.notes = appendForkNote(f.notes, [`Forked at ${createdAt}`, `Fork: ${forked.id}`, `Reason: ${reason}`, params.subtask ? `Subtask: ${params.subtask}` : "", parentLeafId ? `Leaf: ${parentLeafId}` : "", parentSessionFile ? `Session: ${parentSessionFile}` : ""]);
+      pushSessionRef(f, `fork:${forked.id}`);
+      pushSessionRef(f, parentLeafId ? `leaf:${parentLeafId}` : void 0);
+      pushSessionRef(f, parentSessionFile ? `session:${parentSessionFile}` : void 0);
+      forked.notes = appendForkNote(forked.notes, [`Fork source: ${f.id}`, `Created: ${createdAt}`, `Reason: ${reason}`, params.subtask ? `Subtask: ${params.subtask}` : "", parentSessionFile ? `Parent session: ${parentSessionFile}` : ""]);
+      pushSessionRef(forked, `parent-feature:${f.id}`);
+      pushSessionRef(forked, parentLeafId ? `parent-leaf:${parentLeafId}` : void 0);
+      pushSessionRef(forked, parentSessionFile ? `parent-session:${parentSessionFile}` : void 0);
+      milestone.features.push(forked);
+      m.activeFeatureId = forked.id;
+      m.activeMilestoneId = forked.milestoneId;
+      m.status = "active";
+      appendHistory(m, { event: "feature_forked", featureId: f.id, note: reason, details: { subtask: params.subtask, self: true, forkedFeatureId: forked.id, parentLeafId, parentSessionFile, forkApiAvailable: typeof ctx.fork === "function" } });
+      await saveMissionSafe(m);
+      const kickoff = buildForkKickoffMessage(m.title, f, forked, reason, typeof params.subtask === "string" ? params.subtask : void 0, parentSessionFile);
+      const manual = buildManualForkHandoff(m.title, f, forked, reason, parentLeafId, parentSessionFile);
+      if (parentLeafId && typeof ctx.fork === "function") {
+        const result = await ctx.fork(parentLeafId, {
+          position: "at",
+          withSession: async (fc) => {
+            const fcCtx = fc;
+            const fsf = fc.sessionManager?.getSessionFile?.();
+            const pm = loadMissionFromDisk(m.id);
+            const pf = pm ? getFeatureById(pm, forked.id) : null;
+            if (pm && pf) {
+              pushSessionRef(pf, fsf ? `session:${fsf}` : void 0);
+              appendHistory(pm, { event: "feature_fork_session_created", featureId: forked.id, note: reason, details: { sourceFeatureId: f.id, subtask: params.subtask, forkSessionFile: fsf, parentLeafId, self: true } });
+              await saveMissionSafe(pm);
+            }
+            if (typeof fc.sendUserMessage === "function") await fc.sendUserMessage(kickoff);
+            else fc.ui.notify(`\u{1F33F} Fork active: ${forked.title}
+
+${kickoff}`, "info");
+          }
+        });
+        if (!result?.cancelled) {
+          return { content: [{ type: "text", text: `\u{1F500} Forked ${f.id} into ${forked.id} \u2014 started a dedicated Pi session
+
+${kickoff}` }], details: { featureId: f.id, forkedFeatureId: forked.id, reason, subtask: params.subtask, mode: "fork_api" }, isError: false };
+        }
+      }
+      return { content: [{ type: "text", text: `${manual}
+
+Kickoff prompt:
+${kickoff}` }], details: { featureId: f.id, forkedFeatureId: forked.id, reason, subtask: params.subtask, mode: "manual" }, isError: false };
+    }
+  });
+  pi.registerTool({
+    name: "mission_error_status",
+    label: "Error Status",
+    description: "View error recovery statistics.",
+    promptSnippet: "View error status",
+    promptGuidelines: ["Check what errors occurred and their recovery status."],
+    parameters: Type2.Object({
+      scope: Type2.Optional(Type2.String({ description: "'feature' or 'mission'", enum: ["feature", "mission"] }))
+    }),
+    async execute(_id, params, _sig, _upd, _ctx) {
+      const m = runtime.activeMission;
+      if (!m) throw new Error("No active mission.");
+      const f = getActiveFeature(m);
+      const recovery = getErrorRecoveryEngine();
+      const scope = String(params.scope ?? "feature");
+      const errors = scope === "feature" && f ? recovery.getErrorsForFeature(f.id) : recovery.getErrorsForMission(m.id);
+      const stats = recovery.getStats();
+      if (!errors.length) {
+        return { content: [{ type: "text", text: `\u2705 No errors for ${scope === "feature" ? `feature ${f?.id}` : "mission"}.
+
+Total: ${stats.total}, resolved: ${stats.resolved}` }], details: { scope, errorCount: 0, stats }, isError: false };
+      }
+      const lines = [
+        `\u{1F4CB} Error Status (${scope})`,
+        `Total: ${errors.length}, Resolved: ${errors.filter((e) => e.resolved).length}`,
+        "",
+        "Recent:",
+        ...errors.slice(-5).map((e) => `- [${e.resolved ? "\u2713" : "\u2717"}] ${e.context.toolName ?? "?"}: ${e.context.errorMessage.slice(0, 50)}`),
+        "",
+        "By category:",
+        ...Object.entries(stats.byCategory).map(([k, v]) => `- ${k}: ${v}`),
+        "",
+        "By severity:",
+        ...Object.entries(stats.bySeverity).map(([k, v]) => `- ${k}: ${v}`)
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }], details: { scope, errors, stats }, isError: false };
+    }
+  });
+  pi.registerTool({
+    name: "mission_spawn_worker",
+    label: "Spawn Worker",
+    description: "Spawn a worker subprocess to autonomously execute a feature.",
+    promptSnippet: "Spawn a worker to execute a feature autonomously",
+    promptGuidelines: [
+      "Use for large features that need focused execution.",
+      "The worker runs in a separate pi process with the feature context.",
+      "Only one worker runs at a time. Check status with mission_worker_status."
+    ],
+    parameters: Type2.Object({
+      featureId: Type2.Optional(Type2.String({ description: "Feature ID (defaults to active feature)" })),
+      customPrompt: Type2.Optional(Type2.String({ description: "Custom instructions for the worker" })),
+      model: Type2.Optional(Type2.String({ description: "Model override (default: auto)" }))
+    }),
+    async execute(_id, params, _sig, _upd, _ctx) {
+      const m = runtime.activeMission;
+      const f = m ? getActiveFeature(m) : null;
+      if (!m || !f) throw new Error("No active mission feature.");
+      const featureId = typeof params.featureId === "string" ? params.featureId : f.id;
+      const feat = getFeatureById(m, featureId);
+      if (!feat) throw new Error(`Feature not found: ${featureId}`);
+      if (isWorkerRunning()) {
+        const aw = getActiveWorker();
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Worker already running for ${aw?.featureId}. Use mission_worker_status to check.` }],
+          details: { running: true, featureId: aw?.featureId }
+        };
+      }
+      feat.status = "active";
+      m.activeFeatureId = feat.id;
+      m.activeMilestoneId = feat.milestoneId;
+      m.status = "active";
+      appendHistory(m, {
+        event: "worker_spawned",
+        featureId: feat.id,
+        note: `Spawning worker for ${feat.id} \u2014 ${feat.title}`,
+        details: { model: params.model, hasCustomPrompt: !!params.customPrompt }
+      });
+      await saveMissionSafe(m);
+      spawnWorker(m, {
+        featureId: feat.id,
+        customPrompt: typeof params.customPrompt === "string" ? params.customPrompt : void 0,
+        model: typeof params.model === "string" ? params.model : void 0
+      }).then((result) => {
+        if ("error" in result) {
+          appendHistory(m, { event: "worker_error", featureId: feat.id, note: result.error });
+          saveMissionSafe(m).catch((saveErr) => {
+            process.stderr.write(`[pi-missions] Failed to save after worker error: ${saveErr}
+`);
+          });
+        }
+      }).catch((spawnErr) => {
+        process.stderr.write(`[pi-missions] Worker spawn failed for ${feat.id}: ${spawnErr}
+`);
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `\u{1F680} Worker spawned for ${feat.id} \u2014 ${feat.title}
+
+The worker runs autonomously in a separate process. Results are logged to history.
+Check status: /mission worker-status`
+        }],
+        details: { featureId: feat.id, mode: "async" },
+        isError: false
+      };
+    }
+  });
+  pi.registerTool({
+    name: "mission_worker_status",
+    label: "Worker Status",
+    description: "Check the status of the currently running worker.",
+    promptSnippet: "Check worker status",
+    promptGuidelines: ["Check if a worker is running and its progress."],
+    parameters: Type2.Object({}),
+    async execute(_id, _p, _sig, _upd, _ctx) {
+      const aw = getActiveWorker();
+      if (!aw) {
+        return { content: [{ type: "text", text: "No worker running." }], details: { running: false }, isError: false };
+      }
+      const elapsed = Math.round((Date.now() - aw.startedAt) / 1e3);
+      const lines = [
+        `\u{1F527} Worker Status`,
+        `Feature: ${aw.featureId}`,
+        `Status: ${aw.status}`,
+        `Running: ${elapsed}s`
+      ];
+      if (aw.result) {
+        lines.push(
+          "",
+          "## Last Result",
+          `Exit: ${aw.result.exitCode}${aw.result.signal ? ` (${aw.result.signal})` : ""}`,
+          `Duration: ${Math.round(aw.result.durationMs / 1e3)}s`,
+          `Stdout: ${aw.result.stdout.slice(0, 500)}`,
+          aw.result.stderr ? `Stderr: ${aw.result.stderr.slice(0, 300)}` : ""
+        );
+      }
+      return { content: [{ type: "text", text: lines.filter(Boolean).join("\n") }], details: { running: true, featureId: aw.featureId, status: aw.status, elapsedMs: Date.now() - aw.startedAt }, isError: false };
+    }
+  });
+  pi.registerTool({
+    name: "mission_kill_worker",
+    label: "Kill Worker",
+    description: "Kill the currently running worker process.",
+    promptSnippet: "Kill running worker",
+    promptGuidelines: ["Use to stop a runaway or stuck worker."],
+    parameters: Type2.Object({}),
+    async execute(_id, _p, _sig, _upd, _ctx) {
+      const killed = killWorker();
+      if (!killed) {
+        return { content: [{ type: "text", text: "No worker running to kill." }], details: { killed: false }, isError: false };
+      }
+      return { content: [{ type: "text", text: "\u{1F6D1} Worker killed." }], details: { killed: true }, isError: false };
+    }
+  });
+  pi.registerTool({
+    name: "mission_retry_error",
+    label: "Retry Error",
+    description: "Retry a failed operation or clear errors.",
+    promptSnippet: "Retry failed operation",
+    promptGuidelines: ["Clear error state to allow retry after fixing the root cause."],
+    parameters: Type2.Object({
+      errorId: Type2.Optional(Type2.String({ description: "Error ID to retry" }))
+    }),
+    async execute(_id, params, _sig, _upd, _ctx) {
+      const m = runtime.activeMission;
+      const f = m ? getActiveFeature(m) : null;
+      if (!m || !f) throw new Error("No active feature.");
+      const recovery = getErrorRecoveryEngine();
+      if (typeof params.errorId === "string" && params.errorId) {
+        recovery.markResolved(params.errorId);
+        appendHistory(m, { event: "error_resolved", featureId: f.id, note: `Resolved ${params.errorId}` });
+        return { content: [{ type: "text", text: `\u2705 Error ${params.errorId} resolved.` }], details: { errorId: params.errorId }, isError: false };
+      }
+      recovery.clearErrorsForFeature(f.id);
+      appendHistory(m, { event: "errors_cleared", featureId: f.id, note: "Cleared all errors" });
+      return { content: [{ type: "text", text: `\u2705 Cleared all errors for ${f.id}.` }], details: { featureId: f.id }, isError: false };
+    }
+  });
+}
+
+// src/commands/handlers.ts
+var PLANNING_WIZARD_PROMPT = `You are the mission planner for a software development mission. Analyze the user's goal and produce a structured mission plan.
+
+Goal: {goal}
+Constraints: {constraints}
+
+Respond ONLY with a valid JSON object (no markdown, no explanation) in this exact format:
+{
+  "title": "short mission title",
+  "milestones": [
+    {
+      "id": "M01",
+      "title": "Milestone 1 title",
+      "description": "What this milestone covers",
+      "features": [
+        {
+          "id": "F001",
+          "title": "Feature 1 title",
+          "description": "What this feature does",
+          "priority": 1,
+          "dependsOn": [],
+          "acceptance": [
+            { "id": "AC001", "description": "Acceptance criterion", "checkType": "manual" }
+          ]
+        }
+      ]
+    }
+  ]
+}
+
+Rules:
+- id format: M01, M02, ... for milestones; F001, F002, ... per milestone
+- At least 2 milestones, at least 5 total features
+- Each feature needs at least one acceptance criterion
+- checkType: "manual" | "bash" | "test_file"
+- priority: 1 (highest) to 5 (lowest)
+- Be specific and actionable
+`;
+function injectMissionContextWrapper(pi, ctx, mission, reason) {
+  injectMissionContext(pi, ctx, mission, reason, buildMissionContext(mission));
+}
+async function handleNew(titleArg, ctx, pi, runtime) {
+  const title = titleArg || "Untitled mission";
+  let goal = title;
+  let constraints = "";
+  let usedWizard = false;
+  if (ctx.hasUI) {
+    goal = await ctx.ui.input("Mission goal", `What should '${title}' achieve?`) || title;
+    constraints = await ctx.ui.input("Constraints", "Hard rules? (tests, no deps, etc.)") || "";
+  }
+  let parsedMission = null;
+  const planningPrompt = PLANNING_WIZARD_PROMPT.replace("{goal}", goal).replace("{constraints}", constraints);
+  const piWithSend = pi;
+  if (piWithSend.sendUserMessage) {
+    try {
+      ctx.ui.notify("\u{1F916} Planning wizard generating milestones\u2026", "info");
+      const response = await piWithSend.sendUserMessage(planningPrompt, { timeoutMs: 6e4 });
+      const text = typeof response === "string" ? response : String(response?.content ?? JSON.stringify(response));
+      const m = String(text).match(/\{[\s\S]*\}/);
+      if (m) {
+        const raw = JSON.parse(m[0]);
+        const validation = validate(WizardOutputSchema, raw);
+        if (!validation.valid) {
+          ctx.ui.notify("Wizard output incomplete; falling back to structured scaffold.", "warning");
+        } else {
+          parsedMission = missionFromWizardOutput(raw, title, goal);
+          if (!parsedMission) ctx.ui.notify("Wizard output too little structure; falling back.", "warning");
+          else usedWizard = true;
+        }
+      }
+    } catch {
+    }
+  }
+  const mission = parsedMission ?? createStructuredMission(title, goal, constraints);
+  runtime.activeMission = mission;
+  await saveMissionSafe(mission);
+  appendHistory(mission, { event: "mission_created", note: goal, details: { usedWizard } });
+  pi.appendEntry("pi-mission-active", { missionId: mission.id, validationToken: mission.validationToken });
+  injectMissionContextWrapper(pi, ctx, mission, "mission_started");
+  pi.setSessionName(`\u{1F3AF} ${mission.title}`);
+  updateFooter(ctx, mission);
+  const fc = mission.milestones.reduce((s, m) => s + m.features.length, 0);
+  ctx.ui.notify(usedWizard ? `\u2705 Mission created: ${mission.milestones.length} milestones, ${fc} features (AI-generated)` : `\u2705 Mission created: ${mission.id} \u2014 /mission status or /mission next`, "info");
+}
+async function handleTemplates(sub, arg, title, ctx, pi, runtime) {
+  if (!sub || sub === "list") {
+    const lines = ["Available templates:", ""];
+    for (const t of MISSION_TEMPLATES) lines.push(`  ${t.id.padEnd(12)} ${t.label.padEnd(20)} ${t.description}`);
+    lines.push("", "/mission templates scaffold <id> [title]");
+    ctx.ui.notify(lines.join("\n"), "info");
+    return;
+  }
+  if (sub === "scaffold" && arg) {
+    const mission = createMissionFromTemplate(arg, title);
+    if (!mission) return ctx.ui.notify(`Unknown template: ${arg}. Use /mission templates list.`, "error");
+    runtime.activeMission = mission;
+    await saveMissionSafe(mission);
+    appendHistory(mission, { event: "mission_created", note: `From template: ${arg}` });
+    pi.appendEntry("pi-mission-active", { missionId: mission.id, validationToken: mission.validationToken });
+    injectMissionContextWrapper(pi, ctx, mission, "mission_started_from_template");
+    pi.setSessionName(`\u{1F3AF} ${mission.title}`);
+    updateFooter(ctx, mission);
+    ctx.ui.notify(`\u2705 Mission created from '${arg}' template: ${mission.id}`, "info");
+    return;
+  }
+  ctx.ui.notify("Usage: /mission templates [list|scaffold <id> [title]]", "warning");
+}
+async function handleList(ctx, pi, runtime) {
+  const missions = listMissions();
+  if (!missions.length) return ctx.ui.notify("No missions found.", "info");
+  if (!ctx.hasUI) {
+    return ctx.ui.notify(missions.map((m) => `${m.id} \u2014 ${m.title} (${m.status})`).join("\n"), "info");
+  }
+  const labels = missions.map((m) => `${m.id} \u2014 ${m.title} [${progress(m).done}/${progress(m).total}] ${m.status}`);
+  const choice = await ctx.ui.select("Load mission:", labels);
+  if (!choice) return;
+  await handleLoad(choice.split(" \u2014 ")[0], ctx, pi, runtime);
+}
+async function handleLoad(id, ctx, pi, runtime) {
+  if (!id) return ctx.ui.notify("Usage: /mission load <id>", "warning");
+  const mission = loadMissionFromDisk(id);
+  if (!mission) return ctx.ui.notify(`Mission not found: ${id}`, "error");
+  autoBlockBlockedFeatures(mission);
+  runtime.activeMission = mission;
+  pi.appendEntry("pi-mission-active", { missionId: mission.id, validationToken: mission.validationToken });
+  injectMissionContextWrapper(pi, ctx, mission, "mission_loaded");
+  pi.setSessionName(`\u{1F3AF} ${mission.title}`);
+  updateFooter(ctx, mission);
+  ctx.ui.notify(`Loaded mission: ${mission.title}`, "info");
+}
+async function handleStatus(ctx, runtime) {
+  const mission = runtime.activeMission;
+  if (!mission) return ctx.ui.notify("No active mission. /mission new or /mission load.", "info");
+  updateFooter(ctx, mission);
+  ctx.ui.notify(statusText(mission), "info");
+}
+async function handleHelp(ctx) {
+  ctx.ui.notify(buildMissionHelp(), "info");
+}
+async function handleNext(ctx, runtime) {
+  const m = runtime.activeMission;
+  if (!m) return ctx.ui.notify("No active mission.", "warning");
+  const result = activateNextFeature(m);
+  if (!result.ok) {
+    if (result.reason === "active_not_done") {
+      return ctx.ui.notify(`Active feature not done yet: ${result.active.id} \u2014 ${result.active.title}
+/mission done or /mission block.`, "warning");
+    }
+    if (result.reason === "mission_complete") {
+      await saveMissionSafe(m);
+      updateFooter(ctx, m);
+      return ctx.ui.notify("\u{1F389} Mission complete.", "info");
+    }
+    return ctx.ui.notify("No unblocked pending feature found.", "warning");
+  }
+  autoBlockBlockedFeatures(m);
+  await saveMissionSafe(m);
+  updateFooter(ctx, m);
+  ctx.ui.notify(`\u27A1\uFE0F Active feature: ${result.next.id} \u2014 ${result.next.title}
+${result.next.description}`, "info");
+}
+async function handleDone(evidence, ctx, runtime) {
+  const m = runtime.activeMission;
+  const f = m ? getActiveFeature(m) : null;
+  if (!m || !f) return ctx.ui.notify("No active feature.", "warning");
+  if (!evidence && ctx.hasUI) evidence = await ctx.ui.input("Evidence", "Why is this feature done?") || "Marked done.";
+  const result = completeActiveFeature(m, { evidence: evidence || "Marked done.", autoVerify: true });
+  if (!result.ok) return ctx.ui.notify(`${result.reason}
+
+/mission edit to waive criteria.`, "warning");
+  await saveMissionSafe(m);
+  updateFooter(ctx, m);
+  const wallMs = f.startedAt && f.completedAt ? f.completedAt - f.startedAt : 0;
+  const isLarge = f.toolCallCount > 50 || wallMs > 6e5;
+  const nextPending = getNextPendingFeature(m);
+  let notify = `\u2705 ${result.feature.id} done. Evidence: ${result.evidenceFile}`;
+  if (isLarge && nextPending && !result.missionComplete) {
+    notify += `
+
+\u{1F91D} Large feature completed (${f.toolCallCount} calls, ${Math.round(wallMs / 6e4)}min). Consider /handoff "Continue ${m.title} from ${nextPending.id} \u2014 ${nextPending.title}" for a fresh session.`;
+  }
+  ctx.ui.notify(notify, "info");
+}
+async function handleBlock(reason, ctx, runtime) {
+  const m = runtime.activeMission;
+  const f = m ? getActiveFeature(m) : null;
+  if (!m || !f) return ctx.ui.notify("No active feature.", "warning");
+  f.status = "blocked";
+  f.notes = reason || "Blocked";
+  appendHistory(m, { event: "feature_blocked", featureId: f.id, note: f.notes });
+  await saveMissionSafe(m);
+  updateFooter(ctx, m);
+}
+async function handleRun(ctx, pi, runtime) {
+  const m = runtime.activeMission;
+  if (!m) return ctx.ui.notify("No active mission.", "warning");
+  m.status = "active";
+  m.autopilot = {
+    ...m.autopilot,
+    enabled: true,
+    mode: "autopilot",
+    iteration: 0,
+    consecutiveFailures: 0,
+    noProgressTurns: 0,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastStopReason: void 0,
+    lastStopMessage: void 0
+  };
+  const f = ensureActiveFeature(m);
+  if (!f) {
+    m.autopilot.enabled = false;
+    m.autopilot.lastStopReason = "no_active_feature";
+    await saveMissionSafe(m);
+    updateFooter(ctx, m);
+    return ctx.ui.notify("No runnable feature available.", "warning");
+  }
+  appendHistory(m, { event: "autopilot_started", featureId: f.id });
+  await saveMissionSafe(m);
+  updateFooter(ctx, m);
+  await triggerContinuation(pi, ctx, m);
+  ctx.ui.notify(`Autopilot started for ${f.id} - ${f.title}.`, "info");
+}
+async function handleAutopilot(ctx, runtime) {
+  const m = runtime.activeMission;
+  if (!m) return ctx.ui.notify("No active mission.", "warning");
+  const decision = shouldContinue(m, ctx);
+  const a = m.autopilot;
+  ctx.ui.notify([
+    `Autopilot: ${a.enabled ? "ON" : "OFF"} (${a.mode})`,
+    `Iteration: ${a.iteration}/${a.maxIterations}`,
+    `Failures: ${a.consecutiveFailures}/${a.maxConsecutiveFailures}`,
+    `No-progress: ${a.noProgressTurns}/${a.maxNoProgressTurns}`,
+    `Last stop: ${a.lastStopReason ?? "none"}${a.lastStopMessage ? ` - ${a.lastStopMessage}` : ""}`,
+    `Would continue: ${decision.continue ? "yes" : `no (${decision.reason})`}`
+  ].join("\n"), "info");
+}
+async function handleStop(ctx, runtime) {
+  const m = runtime.activeMission;
+  if (!m) return ctx.ui.notify("No active mission.", "warning");
+  m.autopilot.enabled = false;
+  m.autopilot.mode = "manual";
+  m.autopilot.lastStopReason = "paused_by_user";
+  m.autopilot.lastStopMessage = "Stopped by user.";
+  appendHistory(m, { event: "autopilot_stopped" });
+  await saveMissionSafe(m);
+  updateFooter(ctx, m);
+  ctx.ui.notify("Autopilot stopped.", "info");
+}
+async function handlePause(ctx, runtime) {
+  if (!runtime.activeMission) return ctx.ui.notify("No active mission.", "warning");
+  runtime.activeMission.status = "paused";
+  runtime.activeMission.autopilot.enabled = false;
+  runtime.activeMission.autopilot.lastStopReason = "paused_by_user";
+  runtime.activeMission.autopilot.lastStopMessage = "Paused by user.";
+  appendHistory(runtime.activeMission, { event: "mission_paused" });
+  await saveMissionSafe(runtime.activeMission);
+  updateFooter(ctx, runtime.activeMission);
+}
+async function handleResume(ctx, runtime) {
+  if (!runtime.activeMission) return ctx.ui.notify("No active mission.", "warning");
+  runtime.activeMission.status = "active";
+  runtime.activeMission.autopilot.enabled = true;
+  runtime.activeMission.autopilot.mode = "autopilot";
+  runtime.activeMission.autopilot.lastStopReason = void 0;
+  runtime.activeMission.autopilot.lastStopMessage = void 0;
+  ensureActiveFeature(runtime.activeMission);
+  appendHistory(runtime.activeMission, { event: "mission_resumed" });
+  await saveMissionSafe(runtime.activeMission);
+  updateFooter(ctx, runtime.activeMission);
+  ctx.ui.notify("Resumed. /mission run for immediate autopilot turn.", "info");
+}
+async function handleClear(ctx, runtime) {
+  runtime.activeMission = null;
+  updateFooter(ctx, null);
+  ctx.ui.notify("Mission detached.", "info");
+}
+async function handleEdit(featureId, ctx, runtime) {
+  const m = runtime.activeMission;
+  if (!m || !featureId) return ctx.ui.notify("Usage: /mission edit <feature-id>", "warning");
+  const f = getFeatureById(m, featureId);
+  if (!f) return ctx.ui.notify(`Feature not found: ${featureId}`, "error");
+  if (!ctx.hasUI) return ctx.ui.notify(JSON.stringify(f, null, 2), "info");
+  const edited = await ctx.ui.editor("Edit feature JSON", JSON.stringify(f, null, 2));
+  if (!edited) return;
+  let parsed;
+  try {
+    parsed = JSON.parse(edited);
+  } catch (e) {
+    return ctx.ui.notify(`Invalid feature JSON: ${e instanceof Error ? e.message : String(e)}`, "error");
+  }
+  const { FeatureSchema: FeatureSchema2 } = await Promise.resolve().then(() => (init_types(), types_exports));
+  const validation = validate(FeatureSchema2, parsed);
+  if (!validation.valid) {
+    const errors = validation.errors.slice(0, 5).map((e) => `- ${e.path}: ${e.message}`).join("\n");
+    return ctx.ui.notify(`Invalid feature:
+${errors}`, "error");
+  }
+  Object.assign(f, parsed);
+  appendHistory(m, { event: "feature_edited", featureId });
+  await saveMissionSafe(m);
+  updateFooter(ctx, m);
+}
+async function forkFeatureInternally(m, reason, pi, ctx) {
+  const f = getActiveFeature(m);
+  if (!f) {
+    ctx.ui.notify("No active feature. Use /mission next to advance, then fork.", "warning");
+    return;
+  }
+  const sm = ctx.sessionManager;
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const parentLeafId = sm.getLeafId?.() ?? null;
+  const parentSessionFile = sm.getSessionFile?.();
+  const forkedId = `${f.id}-fork-${Date.now()}`;
+  const forked = cloneFeatureForFork(f, forkedId, `${f.title} [fork]`, `Fork: ${reason}`);
+  const milestone = getMilestoneById(m, f.milestoneId);
+  if (!milestone) {
+    ctx.ui.notify("Milestone not found.", "error");
+    return;
+  }
+  f.status = "blocked";
+  f.notes = appendForkNote(f.notes, [`Forked at ${createdAt}`, `Fork: ${forked.id}`, `Reason: ${reason}`, parentLeafId ? `Leaf: ${parentLeafId}` : "", parentSessionFile ? `Session: ${parentSessionFile}` : ""]);
+  pushSessionRef(f, `fork:${forked.id}`);
+  pushSessionRef(f, parentLeafId ? `leaf:${parentLeafId}` : void 0);
+  pushSessionRef(f, parentSessionFile ? `session:${parentSessionFile}` : void 0);
+  forked.notes = appendForkNote(forked.notes, [`Fork source: ${f.id}`, `Created: ${createdAt}`, `Reason: ${reason}`, parentSessionFile ? `Parent session: ${parentSessionFile}` : ""]);
+  pushSessionRef(forked, `parent-feature:${f.id}`);
+  pushSessionRef(forked, parentLeafId ? `parent-leaf:${parentLeafId}` : void 0);
+  pushSessionRef(forked, parentSessionFile ? `parent-session:${parentSessionFile}` : void 0);
+  milestone.features.push(forked);
+  m.activeFeatureId = forked.id;
+  m.status = "active";
+  appendHistory(m, { event: "feature_forked", featureId: f.id, note: reason, details: { forkedFeatureId: forked.id, parentLeafId, parentSessionFile, forkApiAvailable: typeof ctx.fork === "function" } });
+  await saveMissionSafe(m);
+  const kickoff = buildForkKickoffMessage(m.title, f, forked, reason, void 0, parentSessionFile);
+  let forkResult;
+  if (parentLeafId && typeof ctx.fork === "function") {
+    forkResult = await ctx.fork(parentLeafId, {
+      position: "at",
+      withSession: async (fc) => {
+        const fcCtx = fc;
+        const fsf = fc.sessionManager?.getSessionFile?.();
+        const pm = loadMissionFromDisk(m.id);
+        const pf = pm ? getFeatureById(pm, forked.id) : null;
+        if (pm && pf) {
+          pushSessionRef(pf, fsf ? `session:${fsf}` : void 0);
+          appendHistory(pm, { event: "feature_fork_session_created", featureId: forked.id, note: reason, details: { sourceFeatureId: f.id, forkSessionFile: fsf, parentLeafId } });
+          await saveMissionSafe(pm);
+        }
+        if (typeof fc.sendUserMessage === "function") await fc.sendUserMessage(kickoff);
+        else fc.ui.notify(`\u{1F33F} Fork: ${forked.title}
+
+${kickoff}`, "info");
+      }
+    });
+    if (!forkResult?.cancelled) return;
+  }
+  const manual = buildManualForkHandoff(m.title, f, forked, reason, parentLeafId, parentSessionFile);
+  ctx.ui.notify(`${manual}
+
+${kickoff}`, forkResult?.cancelled ? "warning" : "info");
+}
+async function handleFork(reason, ctx, runtime) {
+  const m = runtime.activeMission;
+  if (!m) return ctx.ui.notify("No active feature. Forks can only be created from an active feature.", "warning");
+  if (ctx.hasUI) reason = await ctx.ui.input("Alternative approach", reason || "Try a smaller/safer approach") || reason;
+  await forkFeatureInternally(m, reason || "Alternative approach", {}, ctx);
+}
+async function handleDashboard(ctx, runtime) {
+  const m = runtime.activeMission;
+  if (!m) return ctx.ui.notify("No active mission.", "warning");
+  if (!ctx.hasUI) {
+    ctx.ui.notify(statusText(m), "info");
+    return;
+  }
+  let selected = null;
+  const ui = ctx.ui;
+  if (typeof ui.custom === "function") {
+    await ui.custom(missionControlOverlay(m, (fid) => {
+      selected = fid;
+    }), { overlay: true });
+  }
+  if (selected) {
+    const f = getFeatureById(m, selected);
+    if (f && m.activeFeatureId !== selected) {
+      f.status = "active";
+      m.activeFeatureId = selected;
+      m.activeMilestoneId = f.milestoneId;
+      m.status = "active";
+      autoBlockBlockedFeatures(m);
+      appendHistory(m, { event: "feature_active", featureId: selected });
+      await saveMissionSafe(m);
+      updateFooter(ctx, m);
+      ctx.ui.notify(`\u27A1\uFE0F Activated: ${selected} \u2014 ${f.title}`, "info");
+    } else if (f) {
+      ctx.ui.notify(`Already active: ${selected} \u2014 ${f.title}`, "info");
+    }
+  }
+}
+async function handleDebug(id, ctx, runtime) {
+  const m = id ? loadMissionFromDisk(id) : runtime.activeMission;
+  if (!m) return ctx.ui.notify("No mission to debug.", "warning");
+  const history = readHistory(m.id).slice(-25);
+  ctx.ui.setWidget("pi-mission-debug", [
+    `Mission: ${m.title}`,
+    `Status: ${m.status}`,
+    `Active: ${m.activeFeatureId ?? "none"}`,
+    "\u2500".repeat(80),
+    ...history.map((h) => `${new Date(h.ts * 1e3).toISOString()} ${h.event} ${h.featureId ?? ""} ${h.note ?? ""}`)
+  ]);
+}
+async function handleMetrics(ctx, runtime) {
+  const summary = calculateMetricsSummary();
+  const sess = sessionMetrics.getMetricsSummary();
+  if (summary.totalMissions === 0) return ctx.ui.notify("No missions. /mission new <title>.", "info");
+  ctx.ui.notify([
+    "\u{1F4CA} Mission Metrics Summary",
+    "=".repeat(40),
+    `Total: ${summary.totalMissions}`,
+    `Completed: ${summary.completedMissions}`,
+    `Success: ${(summary.successRate * 100).toFixed(1)}%`,
+    `Avg tokens: ${summary.averageTokensPerMission.toFixed(0)}`,
+    `Avg features: ${summary.averageFeaturesPerMission.toFixed(1)}`,
+    `Avg time: ${(summary.averageCompletionTimeMs / 1e3 / 60).toFixed(1)} min`,
+    "",
+    "\u{1F4C8} Session",
+    "=".repeat(40),
+    sess
+  ].join("\n"), "info");
+  const metricsFile = path4.join(missionsRoot(), "metrics-export.json");
+  try {
+    await fs3.promises.mkdir(missionsRoot(), { recursive: true });
+    await fs3.promises.writeFile(metricsFile, JSON.stringify(listMissions().map(computeMissionMetrics), null, 2), "utf-8");
+    ctx.ui.notify(`\u{1F4C1} Exported: ${metricsFile}`, "info");
+  } catch (e) {
+    ctx.ui.notify(`Export failed: ${e instanceof Error ? e.message : String(e)}`, "warning");
+  }
+}
+async function handleHistory(filter, ctx, runtime) {
+  const m = runtime.activeMission;
+  if (!m) return ctx.ui.notify("No active mission. /mission load <id> first.", "warning");
+  const allEntries = readHistory(m.id);
+  if (!allEntries.length) return ctx.ui.notify("No history entries yet.", "info");
+  let entries = allEntries;
+  let label = "All events";
+  if (filter) {
+    const lf = filter.toLowerCase();
+    if (getFeatureById(m, filter)) {
+      entries = entries.filter((e) => e.featureId === filter);
+      label = `Feature ${filter}`;
+    } else {
+      const eventMatch = entries.filter((e) => e.event === filter);
+      if (eventMatch.length > 0) {
+        entries = eventMatch;
+        label = `Event: ${filter}`;
+      } else {
+        entries = entries.filter(
+          (e) => e.event.includes(lf) || (e.note ?? "").toLowerCase().includes(lf) || (e.featureId ?? "").toLowerCase().includes(lf)
+        );
+        label = `Search: "${filter.slice(0, 40)}"`;
+      }
+    }
+    if (!entries.length) return ctx.ui.notify(`No history entries matching "${filter}".`, "info");
+  }
+  const recent = entries.slice(-40);
+  const features = new Set(recent.map((e) => e.featureId).filter(Boolean));
+  const eventTypes = new Set(recent.map((e) => e.event));
+  const lines = [
+    `\u{1F4DC} Mission History \u2014 ${label} (${recent.length} of ${entries.length} entries)`,
+    `Features: ${[...features].join(", ") || "none"}`,
+    `Event types: ${[...eventTypes].join(", ")}`,
+    "\u2500".repeat(80)
+  ];
+  for (const h of recent) {
+    const ts = new Date(h.ts * 1e3).toISOString().replace("T", " ").slice(0, 19);
+    const evt = h.event.padEnd(24);
+    const fid = (h.featureId ?? "").padEnd(8);
+    const note = (h.note ?? "").slice(0, 60);
+    lines.push(`${ts}  ${evt} ${fid} ${note}`);
+  }
+  lines.push(
+    "\u2500".repeat(80),
+    "Filters: /mission history [feature_id|event_type|search_term]",
+    `Full log: ~/.pi/missions/${m.id}/history.jsonl`,
+    `jq replay: jq -r '.event + " " + (.featureId // "")' ~/.pi/missions/<id>/history.jsonl`
+  );
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+async function handleExport(filename, ctx, runtime) {
+  const m = runtime.activeMission;
+  if (!m) return ctx.ui.notify("No active mission.", "warning");
+  try {
+    const md = exportMarkdown(m);
+    if (filename) {
+      await fs3.promises.writeFile(filename, md, "utf-8");
+      ctx.ui.notify(`\u2705 Exported to ${filename}`, "info");
+    } else {
+      ctx.ui.notify(md, "info");
+    }
+  } catch (e) {
+    ctx.ui.notify(`Export failed: ${e instanceof Error ? e.message : String(e)}`, "warning");
+  }
+}
+async function handleWorker(featureId, ctx, runtime) {
+  const m = runtime.activeMission;
+  if (!m) return ctx.ui.notify("No active mission.", "warning");
+  const fid = featureId || m.activeFeatureId;
+  if (!fid) return ctx.ui.notify("No feature specified and no active feature.", "warning");
+  const f = getFeatureById(m, fid);
+  if (!f) return ctx.ui.notify(`Feature not found: ${fid}`, "error");
+  if (isWorkerRunning()) {
+    const aw = getActiveWorker();
+    const elapsed = aw ? Math.round((Date.now() - aw.startedAt) / 1e3) : 0;
+    return ctx.ui.notify(`Worker already running for ${aw?.featureId} (${elapsed}s). Use /mission worker-status.`, "warning");
+  }
+  f.status = "active";
+  m.activeFeatureId = f.id;
+  m.activeMilestoneId = f.milestoneId;
+  m.status = "active";
+  appendHistory(m, {
+    event: "worker_spawned",
+    featureId: f.id,
+    note: `Worker spawned for ${f.id} \u2014 ${f.title}`
+  });
+  await saveMissionSafe(m);
+  ctx.ui.notify(`\u{1F680} Worker spawned for ${f.id} \u2014 ${f.title}. Check /mission worker-status for progress.`, "info");
+  spawnWorker(m, { featureId: f.id }).then((result) => {
+    if ("error" in result) {
+      ctx.ui.notify(`\u274C Worker error: ${result.error}`, "error");
+      return;
+    }
+    const r = result;
+    const duration = Math.round(r.durationMs / 1e3);
+    const statusIcon = r.killed ? "\u23F1\uFE0F" : r.exitCode === 0 ? "\u2705" : "\u274C";
+    const lines = [
+      `${statusIcon} Worker finished for ${r.featureId}`,
+      `Exit: ${r.exitCode}${r.signal ? ` (${r.signal})` : ""} | Duration: ${duration}s`
+    ];
+    const outSummary = r.stdout.slice(-1500);
+    if (outSummary) lines.push("", "\u2500\u2500 Output (last 1500 chars) \u2500\u2500", outSummary);
+    ctx.ui.notify(lines.join("\n"), "info");
+  }).catch((err) => {
+    ctx.ui.notify(`\u274C Worker failed: ${err instanceof Error ? err.message : String(err)}`, "error");
+  });
+}
+async function handleWorkerStatus(ctx) {
+  const aw = getActiveWorker();
+  if (!aw) return ctx.ui.notify("No worker running.", "info");
+  const elapsed = Math.round((Date.now() - aw.startedAt) / 1e3);
+  const lines = [
+    `\u{1F527} Worker Status`,
+    `Feature: ${aw.featureId}`,
+    `Status: ${aw.status}`,
+    `Running: ${elapsed}s`
+  ];
+  if (aw.result) {
+    lines.push(
+      "",
+      "Last Result:",
+      `Exit: ${aw.result.exitCode}${aw.result.signal ? ` (${aw.result.signal})` : ""}`,
+      `Duration: ${Math.round(aw.result.durationMs / 1e3)}s`
+    );
+  }
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+async function handleKillWorker(ctx) {
+  const killed = killWorker();
+  if (!killed) return ctx.ui.notify("No worker running to kill.", "info");
+  ctx.ui.notify("\u{1F6D1} Worker killed.", "info");
+}
+async function handleMigrate(id, ctx, runtime) {
+  if (!id) {
+    const missions = listMissions();
+    if (!missions.length) return ctx.ui.notify("No missions found.", "info");
+    const lines = ["\u{1F4CB} Mission Schema Versions", "=".repeat(60)];
+    let needsMigration = 0;
+    for (const m of missions) {
+      const rawVersion2 = readRawSchemaVersion(m.id);
+      const versionStr = rawVersion2 !== null ? `v${rawVersion2}` : "?";
+      const status = rawVersion2 === SCHEMA_VERSION ? "\u2705" : rawVersion2 !== null ? "\u2B06\uFE0F" : "\u2753";
+      if (rawVersion2 !== null && rawVersion2 < SCHEMA_VERSION) needsMigration++;
+      lines.push(`${status} ${m.id.padEnd(28)} ${versionStr.padEnd(6)} ${m.title.slice(0, 30)}`);
+    }
+    lines.push(
+      "=".repeat(60),
+      `Current schema: v${SCHEMA_VERSION}`,
+      needsMigration > 0 ? `${needsMigration} mission(s) need migration. Use /mission migrate <id> to migrate.` : "All missions up to date."
+    );
+    ctx.ui.notify(lines.join("\n"), "info");
+    return;
+  }
+  const rawVersion = readRawSchemaVersion(id);
+  if (rawVersion === null) return ctx.ui.notify(`Mission not found: ${id}`, "error");
+  if (rawVersion >= SCHEMA_VERSION) {
+    return ctx.ui.notify(`Mission ${id} already at v${rawVersion} (current: v${SCHEMA_VERSION}). No migration needed.`, "info");
+  }
+  const rawCounts = readRawMissionCounts(id);
+  const current = loadMissionFromDisk(id);
+  if (!current) return ctx.ui.notify(`Could not load mission ${id}.`, "error");
+  const featuresBefore = rawCounts?.features ?? current.milestones.reduce((s, m) => s + m.features.length, 0);
+  const milestonesBefore = rawCounts?.milestones ?? current.milestones.length;
+  const preview = [
+    `\u2B06\uFE0F Migration preview for ${id}`,
+    "=".repeat(60),
+    `Title: ${current.title}`,
+    `Schema: v${rawVersion} \u2192 v${SCHEMA_VERSION}`,
+    `Status: ${current.status}`,
+    `Milestones: ${milestonesBefore}`,
+    `Features: ${featuresBefore}`,
+    "=".repeat(60),
+    "",
+    "Migration will:",
+    "- Set schemaVersion to v3",
+    rawVersion <= 1 ? "- Wrap flat features into a milestone if needed" : null,
+    rawVersion <= 2 ? "- Add default autopilot settings" : null,
+    "- Create a pre-migration backup",
+    "",
+    `Run /mission migrate ${id} confirm to proceed.`
+  ].filter(Boolean).join("\n");
+  ctx.ui.notify(preview, "info");
+}
+async function handleMigrateConfirm(id, ctx, runtime) {
+  if (!id) return ctx.ui.notify("Usage: /mission migrate <id> confirm", "warning");
+  const rawVersion = readRawSchemaVersion(id);
+  if (rawVersion === null) return ctx.ui.notify(`Mission not found: ${id}`, "error");
+  if (rawVersion >= SCHEMA_VERSION) {
+    return ctx.ui.notify(`Already at v${rawVersion}. No migration needed.`, "info");
+  }
+  const migrated = await migrateMissionOnDisk(id);
+  if (!migrated) return ctx.ui.notify(`Migration failed for ${id}.`, "error");
+  if (runtime.activeMission && runtime.activeMission.id === id) {
+    runtime.activeMission = migrated;
+  }
+  const fc = migrated.milestones.reduce((s, m) => s + m.features.length, 0);
+  ctx.ui.notify(
+    `\u2705 Migrated ${id} from v${rawVersion} to v${SCHEMA_VERSION}.
+Milestones: ${migrated.milestones.length}, Features: ${fc}
+Backup saved to ~/.pi/missions/${id}/plan.json.pre-migration-*.bak`,
+    "info"
+  );
+}
+
+// src/commands/index.ts
+function registerMissionCommand(pi, runtime) {
+  const subs = [
+    "start",
+    "new",
+    "list",
+    "load",
+    "run",
+    "pause",
+    "resume",
+    "stop",
+    "clear",
+    "status",
+    "autopilot",
+    "help",
+    "next",
+    "done",
+    "block",
+    "edit",
+    "fork",
+    "debug",
+    "dashboard",
+    "metrics",
+    "export",
+    "templates",
+    "history",
+    "worker",
+    "worker-status",
+    "kill-worker",
+    "migrate"
+  ];
+  pi.registerCommand("mission", {
+    description: `Mission management: ${subs.join("|")}`,
+    getArgumentCompletions: (prefix) => subs.filter((s) => s.startsWith(prefix)).map((s) => ({ value: s, label: s })),
+    handler: async (args, ctx) => {
+      const [sub = "status", ...rest] = args.trim().split(/\s+/).filter(Boolean);
+      switch (sub) {
+        case "start":
+        case "new":
+          return handleNew(rest.join(" "), ctx, pi, runtime);
+        case "list":
+          return handleList(ctx, pi, runtime);
+        case "load":
+          return handleLoad(rest[0], ctx, pi, runtime);
+        case "status":
+          return handleStatus(ctx, runtime);
+        case "help":
+          return handleHelp(ctx);
+        case "dashboard":
+          return handleDashboard(ctx, runtime);
+        case "next":
+          return handleNext(ctx, runtime);
+        case "done":
+          return handleDone(rest.join(" "), ctx, runtime);
+        case "block":
+          return handleBlock(rest.join(" "), ctx, runtime);
+        case "run":
+          return handleRun(ctx, pi, runtime);
+        case "pause":
+          return handlePause(ctx, runtime);
+        case "resume":
+          return handleResume(ctx, runtime);
+        case "stop":
+          return handleStop(ctx, runtime);
+        case "autopilot":
+          return handleAutopilot(ctx, runtime);
+        case "clear":
+          return handleClear(ctx, runtime);
+        case "edit":
+          return handleEdit(rest[0], ctx, runtime);
+        case "fork":
+          return handleFork(rest.join(" "), ctx, runtime);
+        case "debug":
+          return handleDebug(rest[0], ctx, runtime);
+        case "metrics":
+          return handleMetrics(ctx, runtime);
+        case "export":
+          return handleExport(rest[0], ctx, runtime);
+        case "templates":
+          return handleTemplates(rest[0], rest[1], rest.slice(2).join(" "), ctx, pi, runtime);
+        case "history":
+          return handleHistory(rest[0], ctx, runtime);
+        case "worker":
+          return handleWorker(rest[0], ctx, runtime);
+        case "worker-status":
+          return handleWorkerStatus(ctx);
+        case "kill-worker":
+          return handleKillWorker(ctx);
+        case "migrate":
+          if (rest[0] && rest[1] === "confirm") return handleMigrateConfirm(rest[0], ctx, runtime);
+          return handleMigrate(rest[0], ctx, runtime);
+        default:
+          return ctx.ui.notify(`Unknown /mission subcommand: ${sub}`, "warning");
+      }
+    }
+  });
+}
+function compactionCheckpoint(pi, runtime) {
+  if (!runtime.activeMission) return;
+  pi.appendEntry("pi-mission-compaction-checkpoint", {
+    missionId: runtime.activeMission.id,
+    summary: buildCompactionSummary(runtime.activeMission),
+    timestamp: Date.now()
+  });
+}
+function missionSummaryForTree(runtime) {
+  const mission = runtime.activeMission;
+  if (!mission) return null;
+  const active = getActiveFeature(mission);
+  return `Mission: ${mission.title}${active ? ` \u2014 Feature: ${active.title}` : ""}`;
+}
+function saveSessionLink(runtime, sessionFile) {
+  if (runtime.activeMission && sessionFile) {
+    const agent = process.env.CODING_AGENT || "unknown";
+    linkSession(runtime.activeMission, sessionFile, agent);
+  }
+}
+
+// src/core/extension.ts
+function latestActiveEntry(entries) {
+  for (const e of [...entries].reverse()) {
+    if (e.type === "pi-mission-active" && e.data && typeof e.data === "object") {
+      if (typeof e.data.missionId === "string") {
+        return {
+          missionId: e.data.missionId,
+          validationToken: typeof e.data.validationToken === "string" ? e.data.validationToken : void 0
+        };
+      }
+    }
+    if (e.type === "custom" && e.customType === "pi-mission-active" && e.data && typeof e.data === "object") {
+      if (typeof e.data.missionId === "string") {
+        return {
+          missionId: e.data.missionId,
+          validationToken: typeof e.data.validationToken === "string" ? e.data.validationToken : void 0
+        };
+      }
+    }
+  }
+  return null;
+}
+function hook(pi, event, handler) {
+  pi.on(event, handler);
+}
+function piMissions(pi) {
+  try {
+    const extDir = dirname2(fileURLToPath(import.meta.url));
+    const globalPath = resolve2(extDir, "..", "index.ts");
+    const cwd = typeof process.cwd === "function" ? process.cwd() : "";
+    const localPath = cwd ? resolve2(cwd, ".pi", "extensions", "pi-missions", "index.ts") : "";
+    let extensionPath = globalPath;
+    if (localPath && fs4.existsSync(localPath)) {
+      extensionPath = localPath;
+      const localDir = resolve2(cwd, ".pi", "extensions", "pi-missions");
+      process.env.PI_MISSIONS_PROJECT_DIR = localDir;
+    }
+    process.env.PI_MISSIONS_EXTENSION_PATH = extensionPath;
+  } catch {
+  }
+  const runtime = {
+    activeMission: null,
+    autoSaveInterval: null,
+    phaseToolCallCount: 0,
+    currentPhase: "execution",
+    lastFeatureId: void 0
+  };
+  function scheduleAutoSave(rt) {
+    if (!rt.autoSaveInterval) {
+      rt.autoSaveInterval = setInterval(async () => {
+        if (rt.activeMission?.status === "active") await saveMissionSafe(rt.activeMission);
+      }, 2 * 60 * 1e3);
+    }
+  }
+  registerMissionCommand(pi, runtime);
+  registerMissionTools(pi, runtime);
+  hook(pi, "session_start", async (...args) => {
+    const _event = args[0];
+    const ctx = args[1];
+    sessionMetrics.reset();
+    const entries = ctx.sessionManager.getEntries();
+    const active = latestActiveEntry(entries);
+    if (!active) {
+      const malformed = entries.some(
+        (e) => (e?.type === "pi-mission-active" || e?.type === "custom" && e?.customType === "pi-mission-active") && e?.data && typeof e.data === "object" && typeof e.data.missionId !== "string"
+      );
+      if (malformed) ctx.ui?.notify("\u26A0\uFE0F Ignoring invalid mission session entry.", "warning");
+      return;
+    }
+    const { missionId, validationToken } = active;
+    if (!isValidMissionId(missionId)) {
+      const fallback = loadMissionFromDisk(missionId);
+      if (!fallback) {
+        ctx.ui?.notify(`\u26A0\uFE0F Mission '${missionId}' not found on disk. /mission load.`, "warning");
+        return;
+      }
+      runtime.activeMission = fallback;
+      autoBlockBlockedFeatures(fallback);
+      updateFooter(ctx, fallback);
+      pi.setSessionName(`\u{1F3AF} ${fallback.title}`);
+      scheduleAutoSave(runtime);
+      return;
+    }
+    const mission = loadMissionFromDisk(missionId);
+    if (!mission) {
+      ctx.ui?.notify(`\u26A0\uFE0F Mission '${missionId}' not found on disk. /mission load.`, "warning");
+      return;
+    }
+    if (validationToken && validationToken !== mission.validationToken) {
+      ctx.ui?.notify("\u26A0\uFE0F Invalid mission event token.", "warning");
+      return;
+    }
+    runtime.activeMission = mission;
+    autoBlockBlockedFeatures(mission);
+    updateFooter(ctx, mission);
+    pi.setSessionName(`\u{1F3AF} ${mission.title}`);
+    scheduleAutoSave(runtime);
+  });
+  hook(pi, "resources_discover", async () => ({ skillPaths: [], promptPaths: [], themePaths: [] }));
+  hook(pi, "session_before_tree", async () => {
+    const summary = missionSummaryForTree(runtime);
+    if (!summary) return;
+    return { summary: { summary, details: { missionId: runtime.activeMission?.id } } };
+  });
+  hook(pi, "before_agent_start", async (..._args) => {
+    runtime.pendingCompletionAction = void 0;
+    runtime.pendingCompletionReason = void 0;
+    runtime.phaseToolCallCount = 0;
+    const mission = runtime.activeMission;
+    if (!mission || mission.status !== "active") return;
+    runtime.currentPhase = getMissionPhase(mission);
+    const feature = getActiveFeature(mission);
+    if (feature?.status === "active") {
+      runtime.lastFeatureId = feature.id;
+      getCompletionDetector().clearToolCallHistory();
+      getErrorRecoveryEngine().clearErrorsForFeature(feature.id);
+      getErrorRecoveryEngine().onAlert((alert) => {
+        if (!runtime.activeMission) return;
+        appendHistory(runtime.activeMission, {
+          event: "error_alert",
+          featureId: feature.id,
+          note: alert.message.slice(0, 200),
+          details: { alertType: alert.type, errorCategory: alert.record.category, errorSeverity: alert.record.severity, errorCount: alert.stats?.total }
+        });
+      });
+    }
+  });
+  hook(pi, "before_agent_start", async (...args) => {
+    const _event = args[0];
+    const ctx = args[1];
+    const mission = runtime.activeMission;
+    if (!mission || mission.status !== "active") return;
+    updateFooter(ctx, mission);
+    let lean = buildLeanContext(mission);
+    if (runtime.pendingCompletionAction === "ask_user") {
+      const reason = (runtime.pendingCompletionReason ?? "").replace(/^(Medium|Low) confidence - /i, "") || "completion is unclear";
+      lean += `
+
+\u{1F6A8} **STOP AND CALL THE TOOL**: ${reason}. Call **mission_ask_user** NOW. Do NOT describe \u2014 invoke the tool.`;
+    } else if (runtime.pendingCompletionAction === "suggest_done") {
+      const reason = runtime.pendingCompletionReason || "feature may be complete";
+      lean += `
+
+\u{1F4A1} ${reason}. Consider **mission_feature_done** if you have concrete evidence.`;
+    }
+    return { message: { customType: "pi-mission-context", content: lean, display: false } };
+  });
+  hook(pi, "tool_call", async (...args) => {
+    const event = args[0];
+    if (!runtime.activeMission) return;
+    runtime.currentPhase = getMissionPhase(runtime.activeMission);
+    const policyResult = enforceToolPolicy(
+      event.toolName,
+      runtime.currentPhase,
+      event.input,
+      runtime.activeMission.userPreferences?.allowBashInPlanning === true,
+      runtime.phaseToolCallCount
+    );
+    if (policyResult.blocked) return { block: true, reason: policyResult.reason };
+    runtime.phaseToolCallCount++;
+    const maxResult = enforceToolMax(runtime.currentPhase, runtime.phaseToolCallCount);
+    if (maxResult.blocked) return { block: true, reason: maxResult.reason };
+  });
+  hook(pi, "tool_result", async (...args) => {
+    const event = args[0];
+    if (!runtime.activeMission) return;
+    const mission = runtime.activeMission;
+    const feature = getActiveFeature(mission);
+    const detector = getCompletionDetector();
+    if (feature?.id && feature.id !== runtime.lastFeatureId) {
+      detector.clearToolCallHistory();
+      getErrorRecoveryEngine().clearErrorsForFeature(feature.id);
+      runtime.lastFeatureId = feature.id;
+    }
+    const success = !event.isError;
+    detector.recordToolCall(event.toolName, success);
+    sessionMetrics.recordToolCall(event.toolName, success);
+    if (!event.isError) {
+      getErrorRecoveryEngine().clearConsecutiveFailures(event.toolName, feature?.id);
+      return;
+    }
+    const recovery = getErrorRecoveryEngine();
+    const errorMessage = toolResultErrorMessage(event);
+    const { action, shouldRetry, retryAfter, record } = recovery.handleError({
+      toolName: event.toolName,
+      featureId: feature?.id,
+      missionId: mission.id,
+      timestamp: Date.now(),
+      errorType: "ToolResultError",
+      errorMessage
+    });
+    sessionMetrics.recordError(record.category);
+    appendHistory(mission, {
+      event: "error_detected",
+      featureId: feature?.id,
+      note: `${event.toolName} failed: ${errorMessage}`,
+      details: { category: record.category, severity: record.severity, action, shouldRetry, retryAfter, retryCount: record.retryCount }
+    });
+  });
+  pi.registerShortcut("ctrl+shift+m", {
+    description: "Open Mission Control dashboard",
+    handler: ((rawCtx) => handleDashboard(rawCtx, runtime))
+  });
+  pi.registerShortcut("ctrl+shift+d", {
+    description: "Mark current feature as done",
+    handler: (async (rawCtx) => {
+      const ctx = rawCtx;
+      const m = runtime.activeMission;
+      const f = m ? getActiveFeature(m) : null;
+      if (!m || !f) return ctx.ui?.notify("No active feature.", "warning");
+      let ok = true;
+      if (ctx.hasUI) ok = await ctx.ui.confirm("Feature done?", `Mark '${f.title}' as completed?`);
+      if (!ok) return;
+      f.status = "done";
+      f.completedAt = Date.now();
+      for (const ac of f.acceptance) if (!ac.waived) ac.verified = true;
+      const evidenceFile = saveEvidence(m, f, "Done via keyboard shortcut.");
+      appendHistory(m, { event: "feature_done", featureId: f.id, note: "Keyboard shortcut", details: { evidenceFile } });
+      autoBlockBlockedFeatures(m);
+      await saveMissionSafe(m);
+      updateFooter(ctx, m);
+      ctx.ui.notify(`\u2705 ${f.title} done!`, "info");
+    })
+  });
+  hook(pi, "turn_end", async (...args) => {
+    const _event = args[0];
+    const ctx = args[1];
+    const m = runtime.activeMission;
+    if (!m) return;
+    const usage = ctx.getContextUsage?.();
+    if (usage?.tokens !== void 0) {
+      const delta = Math.max(0, usage.tokens - m.lastContextTokens);
+      m.tokensUsed += delta;
+      m.lastContextTokens = usage.tokens;
+      if (m.tokensBudget && m.tokensUsed > m.tokensBudget * 0.8 && m.status === "active") {
+        m.status = "budget_limited";
+        ctx.ui.notify("\u26A0\uFE0F Token budget 80% used.", "warning");
+      }
+    }
+    const leafId = ctx.sessionManager.getLeafId?.();
+    const active = getActiveFeature(m);
+    if (leafId && active) pi.setLabel(leafId, `\u{1F3AF} ${active.title}`);
+    const detector = getCompletionDetector();
+    try {
+      const entries = ctx.sessionManager.getEntries();
+      const lastAsst = entries.filter((e) => e?.role === "assistant").slice(-1)[0];
+      const content = lastAsst?.content;
+      if (Array.isArray(content)) {
+        const text = content.filter((c) => c?.type === "text").map((c) => c.text ?? "").join("\n");
+        if (text) detector.recordTextOutput(text);
+      } else if (typeof content === "string") {
+        detector.recordTextOutput(content);
+      }
+    } catch {
+    }
+    if (active?.status === "active") {
+      const stuck = detector.detectStuck();
+      const textLoop = detector.detectTextLoop();
+      const effective = textLoop.isStuck ? textLoop : stuck;
+      if (effective.isStuck && effective.suggestedAction === "block_self") {
+        sessionMetrics.recordStuckDetection();
+        appendHistory(m, { event: "stuck_detected", featureId: active.id, note: effective.reason, details: { source: textLoop.isStuck ? "text_loop" : "tool_pattern" } });
+        active.status = "blocked";
+        active.notes = `Auto-blocked: ${effective.reason}`;
+        m.status = "blocked";
+        m.autopilot.enabled = false;
+        m.autopilot.lastStopReason = "blocked";
+        m.autopilot.lastStopMessage = effective.reason;
+        ctx.ui.notify(`\u{1F6AB} Auto-blocked: ${effective.reason}`, "warning");
+        await saveMissionSafe(m);
+      } else if (effective.isStuck) {
+        ctx.ui.notify(`\u26A0\uFE0F Stuck detected: ${effective.reason}. Consider mission_block_self.`, "warning");
+      }
+    }
+    await saveMissionSafe(m);
+    updateFooter(ctx, m);
+  });
+  hook(pi, "agent_end", async (...args) => {
+    const event = args[0];
+    const ctx = args[1];
+    const m = runtime.activeMission;
+    if (m?.autopilot?.enabled) {
+      await processAgentEndForAutopilot(pi, ctx, event, runtime);
+      return;
+    }
+    const feature = m ? getActiveFeature(m) : null;
+    if (!m || !feature || feature.status !== "active") return;
+    const text = (event.messages ?? []).flatMap((msg) => Array.isArray(msg.content) ? msg.content : []).filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => c.text).join("\n");
+    const detector = getCompletionDetector();
+    const detection = detector.detectCompletion(feature, text);
+    appendHistory(m, {
+      event: "completion_detection",
+      featureId: feature.id,
+      note: detection.reason,
+      details: { isComplete: detection.isComplete, confidence: detection.confidence, suggestedAction: detection.suggestedAction, signals: detection.signals }
+    });
+    if (detection.suggestedAction === "auto_done") {
+      const completed = completeActiveFeature(m, {
+        evidence: `Auto-completed: ${detection.reason}
+
+Signals:
+${detection.signals.map((s) => `- ${s.type}: ${s.evidence}`).join("\n")}`,
+        markAcceptanceVerified: true,
+        historyNote: "Auto-completed",
+        historyDetails: { auto: true }
+      });
+      if (!completed.ok) {
+        ctx.ui.notify(`Feature looks complete but cannot auto-complete: ${completed.reason}`, "info");
+        await saveMissionSafe(m);
+        updateFooter(ctx, m);
+        return;
+      }
+      sessionMetrics.recordFeatureCompleted();
+      const next = activateNextFeature(m, "Auto-advanced");
+      if (next.ok) {
+        sessionMetrics.recordAutoAdvance();
+        autoBlockBlockedFeatures(m);
+        const wallMs = completed.feature.startedAt && completed.feature.completedAt ? completed.feature.completedAt - completed.feature.startedAt : 0;
+        const isLarge = completed.feature.toolCallCount > 50 || wallMs > 6e5;
+        const handoffHint = isLarge ? `
+\u{1F91D} Large feature done (${completed.feature.toolCallCount} calls). Consider /handoff for a fresh session.` : "";
+        ctx.ui.notify(`\u2705 Auto-completed ${completed.feature.id}. Advanced to ${next.next.id} \u2014 ${next.next.title}${handoffHint}`, "info");
+      } else if (next.reason === "mission_complete") {
+        ctx.ui.notify("\u{1F389} Mission complete!", "info");
+      } else {
+        autoBlockBlockedFeatures(m);
+        ctx.ui.notify(`\u2705 Auto-completed ${completed.feature.id}. No pending features.`, "info");
+      }
+      await saveMissionSafe(m);
+      updateFooter(ctx, m);
+    } else if (detection.suggestedAction === "suggest_done") {
+      runtime.pendingCompletionAction = "suggest_done";
+      runtime.pendingCompletionReason = detection.reason;
+      ctx.ui.notify(`Feature '${feature.title}' may be complete (${detection.confidence}). ${detection.reason}`, "info");
+    } else if (detection.suggestedAction === "ask_user") {
+      runtime.pendingCompletionAction = "ask_user";
+      runtime.pendingCompletionReason = detection.reason;
+      ctx.ui.notify(`Feature '${feature.title}' not clear if complete (${detection.confidence}). Model will be prompted to use mission_ask_user.`, "info");
+    }
+  });
+  hook(pi, "session_before_compact", async () => compactionCheckpoint(pi, runtime));
+  hook(pi, "session_shutdown", async (...args) => {
+    const _event = args[0];
+    const ctx = args[1];
+    sessionMetrics.endSession();
+    if (runtime.autoSaveInterval) clearInterval(runtime.autoSaveInterval);
+    runtime.autoSaveInterval = null;
+    if (runtime.activeMission) {
+      saveSessionLink(runtime, ctx.sessionManager.getSessionFile?.());
+      await saveMissionSafe(runtime.activeMission);
+    }
+    updateFooter(ctx, null);
+  });
+}
+export {
+  piMissions as default
+};
+//# sourceMappingURL=index.js.map