squad-kit 0.3.0 → 0.6.0

package/dist/cli.js

@@ -169,6 +169,19 @@ function renderError(err) {
 `);
 }
 
+// src/core/cli-exit.ts
+var SquadExit = class extends Error {
+  constructor(exitCode, message) {
+    super(message ?? "");
+    this.exitCode = exitCode;
+  }
+  exitCode;
+  name = "SquadExit";
+};
+function isSquadExit(err) {
+  return err instanceof SquadExit;
+}
+
 // src/commands/init.ts
 import fs14 from "fs";
 import path6 from "path";
@@ -224,6 +237,7 @@ var SQUAD_ATTACHMENTS_PATTERN = ".squad/stories/**/attachments/";
 var SQUAD_TRASH_PATTERN = ".squad/.trash/";
 var SQUAD_LAST_RUN_PATTERN = ".squad/.last-run.json";
 var SQUAD_LAST_COPY_PROMPT_PATTERN = ".squad/.last-copy-prompt.md";
+var SQUAD_RUNS_PATTERN = ".squad/runs/";
 var MANAGED_BLOCK_HEADER = "# Managed by squad-kit \u2014 do not edit this block";
 var MANAGED_BLOCK_FOOTER = "# End squad-kit block";
 function ensureGitignore(repoRoot) {
@@ -234,7 +248,8 @@ function ensureGitignore(repoRoot) {
     SQUAD_ATTACHMENTS_PATTERN,
     SQUAD_TRASH_PATTERN,
     SQUAD_LAST_RUN_PATTERN,
-    SQUAD_LAST_COPY_PROMPT_PATTERN
+    SQUAD_LAST_COPY_PROMPT_PATTERN,
+    SQUAD_RUNS_PATTERN
   ];
   const allPresent = requiredPatterns.every((p) => text.includes(p));
   if (allPresent) return false;
@@ -276,15 +291,27 @@ var DEFAULT_CONFIG = {
   planner: void 0
 };
 var FORBIDDEN_KEYS = ["apikey", "api_key", "token", "secret", "credential", "credentials"];
-function rejectSecretsInYaml(node, configFile, path26 = []) {
+var DEFAULT_PLANNER_MAX_OUTPUT_TOKENS = 16384;
+var MIN_PLANNER_MAX_OUTPUT_TOKENS = 1024;
+var MAX_PLANNER_MAX_OUTPUT_TOKENS = 128e3;
+function clampPlannerMaxOut(raw) {
+  if (raw === void 0 || raw === null) return DEFAULT_PLANNER_MAX_OUTPUT_TOKENS;
+  const n = typeof raw === "number" ? raw : typeof raw === "string" ? Number.parseInt(raw, 10) : NaN;
+  if (!Number.isFinite(n) || n < 1) return DEFAULT_PLANNER_MAX_OUTPUT_TOKENS;
+  return Math.min(
+    MAX_PLANNER_MAX_OUTPUT_TOKENS,
+    Math.max(MIN_PLANNER_MAX_OUTPUT_TOKENS, Math.round(n))
+  );
+}
+function rejectSecretsInYaml(node, configFile, path34 = []) {
   if (node === null || typeof node !== "object") return;
   for (const [key, value] of Object.entries(node)) {
     if (FORBIDDEN_KEYS.includes(key.toLowerCase())) {
       throw new Error(
-        `Refusing to load ${configFile}: key "${[...path26, key].join(".")}" looks like a secret. Run \`squad config set planner\` or \`squad config set tracker\` to save it to .squad/secrets.yaml, then remove the key from config.yaml. Provider keys also work via ANTHROPIC_API_KEY / OPENAI_API_KEY / GOOGLE_API_KEY.`
+        `Refusing to load ${configFile}: key "${[...path34, key].join(".")}" looks like a secret. Run \`squad config set planner\` or \`squad config set tracker\` to save it to .squad/secrets.yaml, then remove the key from config.yaml. Provider keys also work via ANTHROPIC_API_KEY / OPENAI_API_KEY / GOOGLE_API_KEY.`
       );
     }
-    if (typeof value === "object") rejectSecretsInYaml(value, configFile, [...path26, key]);
+    if (typeof value === "object") rejectSecretsInYaml(value, configFile, [...path34, key]);
   }
 }
 function mergePlanner(base, override) {
@@ -305,7 +332,8 @@ function mergePlanner(base, override) {
     },
     cache: {
       enabled: override.cache?.enabled ?? base?.cache?.enabled ?? true
-    }
+    },
+    maxOutputTokens: clampPlannerMaxOut(override.maxOutputTokens ?? base?.maxOutputTokens)
   };
   if (merged.modelOverride) {
     const pruned = Object.fromEntries(
@@ -331,8 +359,7 @@ function validateModelOverride(mo, configFile) {
     }
   }
 }
-function loadConfig(configFile) {
-  const raw = fs3.readFileSync(configFile, "utf8");
+function parseConfig(raw, configFile) {
   let parsed;
   try {
     parsed = yaml.load(raw);
@@ -387,11 +414,17 @@ function loadConfig(configFile) {
   }
   return merged;
 }
+function loadConfig(configFile) {
+  const raw = fs3.readFileSync(configFile, "utf8");
+  return parseConfig(raw, configFile);
+}
 function serializeConfig(config2) {
   return yaml.dump(config2, { lineWidth: 100, noRefs: true, sortKeys: false });
 }
 function saveConfig(configFile, config2) {
-  fs3.writeFileSync(configFile, serializeConfig(config2), "utf8");
+  const body = serializeConfig(config2);
+  parseConfig(body, configFile);
+  fs3.writeFileSync(configFile, body, "utf8");
 }
 function mergeConfig(base, override) {
   return {
@@ -525,6 +558,19 @@ function resolveProviderKey(provider) {
 function readProviderKey(provider) {
   return resolveProviderKey(provider)?.value;
 }
+function readProviderKeyForPaths(paths, provider) {
+  const envVar = providerEnvVar(provider);
+  const envValue = process.env[envVar];
+  if (envValue) return envValue;
+  const fallback = process.env.SQUAD_PLANNER_API_KEY;
+  if (fallback) return fallback;
+  if (fs5.existsSync(paths.secretsFile)) {
+    const secrets = loadSecrets(paths.secretsFile);
+    const fromFile = secrets.planner?.[provider];
+    if (fromFile) return fromFile;
+  }
+  return void 0;
+}
 
 // src/utils/fs.ts
 import fs6 from "fs";
@@ -584,6 +630,9 @@ function render(template, vars) {
     return value === void 0 || value === null ? "" : String(value);
   });
 }
+function escapeTemplateValue(s) {
+  return s.replace(/\{\{/g, "{ {");
+}
 
 // src/commands/config/show.ts
 import fs7 from "fs";
@@ -856,7 +905,8 @@ function newPlannerBlock(provider) {
       maxContextBytes: 5e4,
       maxDurationSeconds: 180
     },
-    cache: { enabled: true }
+    cache: { enabled: true },
+    maxOutputTokens: DEFAULT_PLANNER_MAX_OUTPUT_TOKENS
   };
 }
 function mergePlannerKeyIntoSecrets(base, provider, key) {
@@ -1196,6 +1246,55 @@ var AzureDevOpsClient = class {
   baseUrl;
   apiVersion;
   webBase;
+  async searchIssues(query, opts) {
+    const limit = Math.min(50, Math.max(1, opts?.limit ?? 25));
+    const q = query.trim();
+    let wiql;
+    if (/^\d+$/.test(q)) {
+      wiql = `SELECT [System.Id] FROM WorkItems WHERE [System.Id] = ${q}`;
+    } else if (q.length === 0) {
+      wiql = "SELECT [System.Id] FROM WorkItems ORDER BY [System.ChangedDate] DESC";
+    } else {
+      const esc = q.replace(/'/g, "''");
+      wiql = `SELECT [System.Id] FROM WorkItems WHERE [System.Title] CONTAINS STRING '${esc}' ORDER BY [System.ChangedDate] DESC`;
+    }
+    const wiqlUrl = `${this.baseUrl}/wiql?api-version=${this.apiVersion}`;
+    let wiqlRes;
+    try {
+      wiqlRes = await fetch(wiqlUrl, {
+        method: "POST",
+        headers: { ...this.headers(), "content-type": "application/json" },
+        body: JSON.stringify({ query: `${wiql}` })
+      });
+    } catch (err) {
+      throw new TrackerError(`Azure DevOps search failed: ${err.message}`, "network");
+    }
+    if (!wiqlRes.ok) throw this.mapHttpError(wiqlRes.status, "search");
+    const wiqlBody = await wiqlRes.json();
+    const ids = (wiqlBody.workItems ?? []).slice(0, limit).map((w) => w.id);
+    if (ids.length === 0) return [];
+    const batchUrl = `${this.baseUrl}/workitems?ids=${ids.map(String).join(",")}&$expand=all&api-version=${this.apiVersion}`;
+    let batchRes;
+    try {
+      batchRes = await fetch(batchUrl, { headers: this.headers() });
+    } catch (err) {
+      throw new TrackerError(`Azure DevOps work items fetch failed: ${err.message}`, "network");
+    }
+    if (!batchRes.ok) throw this.mapHttpError(batchRes.status, "search");
+    const batchBody = await batchRes.json();
+    const value = batchBody.value ?? [];
+    return value.map((body) => {
+      const id = String(body.id ?? "");
+      const fields = body.fields ?? {};
+      return {
+        id,
+        title: fields["System.Title"] ?? "(no title)",
+        type: fields["System.WorkItemType"],
+        status: fields["System.State"],
+        url: `${this.webBase}/${id}`
+      };
+    });
+  }
   async fetchIssue(id) {
     const url = `${this.baseUrl}/workitems/${encodeURIComponent(id)}?$expand=all&api-version=${this.apiVersion}`;
     let res;
@@ -1217,6 +1316,7 @@ var AzureDevOpsClient = class {
       id: String(body.id ?? id),
       title: fields["System.Title"] ?? "(no title)",
       description: stripHtml(fields["System.Description"] ?? ""),
+      acceptanceCriteria: stripHtml(fields["Microsoft.VSTS.Common.AcceptanceCriteria"] ?? ""),
       url: `${this.webBase}/${body.id ?? id}`,
       labels: parseTags(fields["System.Tags"]),
       type: fields["System.WorkItemType"],
@@ -1245,7 +1345,7 @@ var AzureDevOpsClient = class {
     }
     if (status === 404) {
       return new TrackerError(
-        `Azure DevOps work item "${id}" not found in ${this.cfg.organization}/${this.cfg.project} (HTTP 404). Check the id and the organization/project in .squad/config.yaml.`,
+        id === "search" ? `Azure DevOps search failed (HTTP 404) in ${this.cfg.organization}/${this.cfg.project}.` : `Azure DevOps work item "${id}" not found in ${this.cfg.organization}/${this.cfg.project} (HTTP 404). Check the id and the organization/project in .squad/config.yaml.`,
         "not-found",
         status
       );
@@ -1253,7 +1353,11 @@ var AzureDevOpsClient = class {
     if (status === 429) {
       return new TrackerError(`Azure DevOps rate limit hit (HTTP 429). Wait a minute and retry.`, "rate-limited", status);
     }
-    return new TrackerError(`Azure DevOps request failed (HTTP ${status}).`, "other", status);
+    return new TrackerError(
+      id === "search" ? `Azure DevOps search failed (HTTP ${status}).` : `Azure DevOps request failed (HTTP ${status}).`,
+      "other",
+      status
+    );
   }
 };
 function parseTags(raw) {
@@ -1340,6 +1444,7 @@ var JiraClient = class {
       id: body.key ?? id,
       title: fields.summary ?? "(no title)",
       description,
+      acceptanceCriteria: "",
       url: `${this.baseUrl}/browse/${body.key ?? id}`,
       labels: Array.isArray(fields.labels) ? fields.labels : [],
       type: fields.issuetype?.name,
@@ -1349,6 +1454,40 @@ var JiraClient = class {
       fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
+  async searchIssues(query, opts) {
+    const limit = Math.min(50, Math.max(1, opts?.limit ?? 25));
+    const q = query.trim();
+    let jql;
+    if (/^[A-Z][A-Z0-9_]+-\d+$/i.test(q)) {
+      jql = `issuekey = "${q.toUpperCase()}"`;
+    } else if (q.length === 0) {
+      jql = "order by updated DESC";
+    } else {
+      const esc = q.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+      jql = `text ~ "${esc}" order by updated DESC`;
+    }
+    const url = `${this.baseUrl}/rest/api/3/search?jql=${encodeURIComponent(jql)}&fields=summary,status,issuetype&maxResults=${limit}`;
+    let res;
+    try {
+      res = await fetch(url, { headers: this.headers() });
+    } catch (err) {
+      throw new TrackerError(`Jira search failed: ${err.message}`, "network");
+    }
+    if (!res.ok) throw this.mapHttpError(res.status, "search");
+    const body = await res.json();
+    const issues = body.issues ?? [];
+    return issues.map((it) => {
+      const key = it.key ?? "";
+      const f = it.fields ?? {};
+      return {
+        id: key,
+        title: f.summary ?? "(no title)",
+        type: f.issuetype?.name,
+        status: f.status?.name,
+        url: `${this.baseUrl}/browse/${key}`
+      };
+    });
+  }
   async downloadAttachments(refs, targetDir, opts) {
     return downloadAttachmentsWith(refs, targetDir, this.headers(), opts);
   }
@@ -1368,7 +1507,7 @@ var JiraClient = class {
     }
     if (status === 404) {
       return new TrackerError(
-        `Jira issue "${id}" not found on ${this.cfg.host} (HTTP 404). Check the id and your workspace host.`,
+        id === "search" ? `Jira search not found (HTTP 404) on ${this.cfg.host}.` : `Jira issue "${id}" not found on ${this.cfg.host} (HTTP 404). Check the id and your workspace host.`,
         "not-found",
         status
       );
@@ -1376,7 +1515,11 @@ var JiraClient = class {
     if (status === 429) {
       return new TrackerError(`Jira rate limit hit (HTTP 429). Wait a minute and retry.`, "rate-limited", status);
     }
-    return new TrackerError(`Jira request failed (HTTP ${status}).`, "other", status);
+    return new TrackerError(
+      id === "search" ? `Jira search failed (HTTP ${status}).` : `Jira request failed (HTTP ${status}).`,
+      "other",
+      status
+    );
   }
 };
 function stripHtml2(html) {
@@ -1772,7 +1915,9 @@ async function runInit(opts) {
           maxFileReads: 25,
           maxContextBytes: 5e4,
           maxDurationSeconds: 180
-        }
+        },
+        cache: { enabled: true },
+        maxOutputTokens: DEFAULT_PLANNER_MAX_OUTPUT_TOKENS
       };
     }
   } else {
@@ -1798,7 +1943,9 @@ async function runInit(opts) {
           maxFileReads: 25,
           maxContextBytes: 5e4,
           maxDurationSeconds: 180
-        }
+        },
+        cache: { enabled: true },
+        maxOutputTokens: DEFAULT_PLANNER_MAX_OUTPUT_TOKENS
       };
     }
   }
@@ -1927,9 +2074,9 @@ Plan meta-prompts (\`generate-plan.md\`, \`story-skeleton.md\`) ship inside the
 }
 
 // src/commands/new-story.ts
-import fs16 from "fs";
-import path8 from "path";
-import { input as input3, select as select4 } from "@inquirer/prompts";
+import fs20 from "fs";
+import path12 from "path";
+import { input as input3, select as select5 } from "@inquirer/prompts";
 
 // src/core/stories.ts
 import fs15 from "fs";
@@ -1939,6 +2086,15 @@ function listFeatures(paths) {
   if (!fs15.existsSync(paths.storiesDir)) return [];
   return fs15.readdirSync(paths.storiesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
 }
+function listPlanFeatureNames(paths) {
+  const names = new Set(listFeatures(paths));
+  if (fs15.existsSync(paths.plansDir)) {
+    for (const e of fs15.readdirSync(paths.plansDir, { withFileTypes: true })) {
+      if (e.isDirectory()) names.add(e.name);
+    }
+  }
+  return [...names].sort();
+}
 function listAllStories(paths) {
   return listStories(paths);
 }
@@ -1969,11 +2125,14 @@ function listStories(paths, opts = {}) {
 function findPlanFor(plansDir, feature, storyId) {
   const featureDir = path7.join(plansDir, feature);
   if (!fs15.existsSync(featureDir)) return void 0;
+  const candidates = [];
   for (const entry of fs15.readdirSync(featureDir)) {
     if (!STORY_FILE.test(entry)) continue;
-    if (entry.includes(storyId)) return entry;
+    if (entry.includes(storyId)) candidates.push(entry);
   }
-  return void 0;
+  if (candidates.length === 0) return void 0;
+  const complete = candidates.find((e) => !e.endsWith(".partial.md"));
+  return complete ?? candidates[0];
 }
 function findStoryByIntake(records, intakePath) {
   const target = normalizeIntakePath(intakePath.trim());
@@ -1989,21 +2148,53 @@ function normalizeIntakePath(p) {
 }
 function readTitleHint(intakePath) {
   try {
-    const head = fs15.readFileSync(intakePath, "utf8").split("\n").slice(0, 3).join("\n");
-    const m = head.match(/>\s*\*\*Title hint \(from CLI\):\*\*\s*(.+?)\s*$/m);
-    return m?.[1]?.trim() || void 0;
+    const raw = fs15.readFileSync(intakePath, "utf8");
+    const head = raw.split("\n").slice(0, 30).join("\n");
+    const hintLine = head.match(/>\s*\*\*Title hint \(from CLI\):\*\*\s*(.+?)\s*$/m);
+    const fromHint = hintLine?.[1]?.trim();
+    if (fromHint) return fromHint;
+    const titleFence = raw.match(/(?:^|\n)## Title\b[\s\S]*?\n```(?:[\w-]*)?\s*\n([\s\S]*?)\n```/);
+    const fromFence = titleFence?.[1]?.trim();
+    if (fromFence) return fromFence;
+    return void 0;
   } catch {
     return void 0;
   }
 }
-function readPlanMetadata(planFileAbsPath) {
-  try {
-    const first = fs15.readFileSync(planFileAbsPath, "utf8").split("\n", 1)[0] ?? "";
-    const m = first.match(/^<!--\s*squad-kit:\s*generated by\s+([^\s,]+)/);
-    if (!m) return {};
-    const generatedBy = m[1];
+var PLAN_GENERATED_BY = /^<!--\s*squad-kit:\s*generated by\s+([^\s,]+)/;
+var PLAN_ANY_SQUAD = /^<!--\s*squad-kit:\s*(.+?)\s*-->$/;
+var MAX_FREEFORM_META_LEN = 96;
+function parsePlanMetadataLine(line2) {
+  const strict = line2.match(PLAN_GENERATED_BY);
+  if (strict) {
+    const generatedBy = strict[1];
+    const [provider, model] = generatedBy.split("/");
+    return { provider, model, generatedBy };
+  }
+  const any = line2.match(PLAN_ANY_SQUAD);
+  if (!any) return null;
+  const inner = any[1].trim();
+  const flex = inner.match(/^generated\s+by\s+([^\s,]+)/i);
+  if (flex) {
+    const generatedBy = flex[1];
     const [provider, model] = generatedBy.split("/");
     return { provider, model, generatedBy };
+  }
+  const short = inner.length > MAX_FREEFORM_META_LEN ? `${inner.slice(0, MAX_FREEFORM_META_LEN - 1)}\u2026` : inner;
+  return { generatedBy: short };
+}
+function readPlanMetadata(planFileAbsPath) {
+  try {
+    const raw = fs15.readFileSync(planFileAbsPath, "utf8").replace(/^\uFEFF/, "");
+    const lines = raw.split(/\n/);
+    const scan = Math.min(lines.length, 40);
+    for (let i = 0; i < scan; i++) {
+      const line2 = (lines[i] ?? "").replace(/\r$/, "").trim();
+      if (!line2) continue;
+      const parsed = parsePlanMetadataLine(line2);
+      if (parsed) return parsed;
+    }
+    return {};
   } catch {
     return {};
   }
@@ -2026,56 +2217,494 @@ function trackerIdForFilename(type, id) {
   return id;
 }
 
-// src/commands/new-story.ts
-function validateFeatureSlugForPrompt(v) {
-  const trimmed = v.trim();
-  if (!trimmed) return "Required.";
-  const s = slugify(trimmed);
-  if (!s) return "Required.";
-  if (s !== trimmed) return "Use lowercase kebab-case (letters, digits, hyphens).";
-  return true;
+// src/core/story-intake-helpers.ts
+import fs16 from "fs";
+import path8 from "path";
+function buildIntakeTemplateVars(args) {
+  const e = escapeTemplateValue;
+  const { config: config2, featureSlug, storyFolderName, trackerId, title, fetchedIssue } = args;
+  return {
+    featureSlug,
+    storyId: storyFolderName,
+    trackerType: config2.tracker.type,
+    trackerWorkItemId: e((fetchedIssue?.id ?? trackerId ?? "").trim()),
+    trackerWorkItemType: e((fetchedIssue?.type ?? "").trim()),
+    trackerStatus: e((fetchedIssue?.status ?? "").trim()),
+    trackerAssignee: e((fetchedIssue?.assignee ?? "").trim()),
+    trackerLabels: e((fetchedIssue?.labels ?? []).join(", ").trim()),
+    trackerTitle: e((title ?? "").trim()),
+    trackerDescription: e((fetchedIssue?.description ?? "").trim()),
+    trackerAcceptanceCriteria: e((fetchedIssue?.acceptanceCriteria ?? "").trim()),
+    projectRoots: (config2.project.projectRoots ?? ["."]).join(", "),
+    primaryLanguage: config2.project.primaryLanguage ?? ""
+  };
 }
-async function runNewStory(featureSlug, opts) {
-  const interactive = !opts.yes && Boolean(process.stdin.isTTY) && process.env.CI !== "true";
-  let featureSlugInput = featureSlug;
-  if (!featureSlugInput) {
-    if (!interactive) {
-      throw new Error(
-        "feature-slug is required. Run `squad new-story` in a TTY to pick interactively, or pass a slug like `squad new-story <feature-slug>`, or add `--yes` to fail fast in scripts."
-      );
+function buildSourcePreamble(issue, downloads, trackerType) {
+  const header = `> **Fetched from ${trackerType}:** [${issue.id}](${issue.url})  
+> *Fetched ${issue.fetchedAt}. Edit the sections below as needed; the planner reads this file verbatim.*
+
+`;
+  const metaLines = [];
+  metaLines.push(`**Title:** ${issue.title}`);
+  if (issue.type) metaLines.push(`**Type:** ${issue.type}`);
+  if (issue.status) metaLines.push(`**Status:** ${issue.status}`);
+  if (issue.assignee) metaLines.push(`**Assignee:** ${issue.assignee}`);
+  if (issue.labels.length > 0) metaLines.push(`**Labels:** ${issue.labels.join(", ")}`);
+  const description = issue.description.trim().length > 0 ? issue.description.trim() : "*(tracker returned an empty description)*";
+  const attachmentsTable = renderAttachmentsTable(downloads);
+  return [
+    header,
+    "## Source \u2014 work item (from tracker)",
+    "",
+    metaLines.join("  \n"),
+    "",
+    "### Description",
+    "",
+    description,
+    "",
+    attachmentsTable,
+    "",
+    "---",
+    ""
+  ].join("\n");
+}
+function renderAttachmentsTable(downloads) {
+  if (downloads.length === 0) return "### Attachments\n\nNone.";
+  const rows = downloads.map((d) => {
+    const sizeNum = (d.bytesWritten || d.source.size) / 1024;
+    const size = `${sizeNum | 0} KB`;
+    switch (d.outcome) {
+      case "written":
+        return `| \`attachments/${path8.basename(d.absolutePath)}\` | ${size} | downloaded |`;
+      case "skipped-oversize":
+        return `| ${d.source.filename} | ${size} | **skipped** \u2014 ${d.skipReason} |`;
+      case "skipped-error":
+        return `| ${d.source.filename} | \u2014 | **skipped** \u2014 ${d.skipReason} |`;
     }
-    const rootForPrompt = requireSquadRoot();
-    const pathsForPrompt = buildPaths(rootForPrompt);
-    const existing = listFeatures(pathsForPrompt);
-    if (existing.length > 0) {
-      const choice = await select4({
-        message: "Feature:",
-        choices: [
-          ...existing.map((f) => ({ name: f, value: f })),
-          { name: "\u2500\u2500\u2500 new feature \u2500\u2500\u2500", value: "__NEW__" }
-        ]
-      });
-      if (choice !== "__NEW__") {
-        featureSlugInput = choice;
+  });
+  return ["### Attachments", "", "| File | Size | Status |", "| ---- | ---- | ------ |", ...rows].join("\n");
+}
+function buildFallbackPreamble(reason, hint) {
+  const hintLine = hint ? `
+> Hint: ${hint}` : "";
+  return `> **Tracker auto-fetch skipped.**  
+> ${reason}${hintLine}
+
+---
+
+`;
+}
+function buildSkippedTrackerPreamble(trackerType) {
+  return [
+    "> **Source:** manual entry (tracker skipped via `--no-tracker`).",
+    `> Active tracker for this workspace: \`${trackerType}\` \u2014 this story is not linked. `,
+    "> Run `squad tracker link <story-path> <tracker-id>` later if you want to attach one.",
+    "",
+    ""
+  ].join("\n");
+}
+function ensureFeatureOverview(featurePlanDir, slug) {
+  fs16.mkdirSync(featurePlanDir, { recursive: true });
+  const overviewFile = path8.join(featurePlanDir, "00-overview.md");
+  if (fs16.existsSync(overviewFile)) return;
+  const template = readFile(path8.join(templatesDir(), "overview.md"));
+  writeFileSafe(overviewFile, render(template, { featureSlug: slug }), false);
+}
+
+// src/core/story-mutations.ts
+import fs19 from "fs";
+import path11 from "path";
+
+// src/commands/rm/shared.ts
+import fs18 from "fs";
+import path10 from "path";
+import { select as select4 } from "@inquirer/prompts";
+
+// src/core/sequence.ts
+import fs17 from "fs";
+import path9 from "path";
+var STORY_FILE2 = /^(\d{2,})-story-.+\.md$/;
+function scanPlans(plansDir) {
+  const used = [];
+  const seen = /* @__PURE__ */ new Map();
+  if (fs17.existsSync(plansDir)) {
+    for (const feature of fs17.readdirSync(plansDir, { withFileTypes: true })) {
+      if (!feature.isDirectory()) continue;
+      const featureDir = path9.join(plansDir, feature.name);
+      for (const entry of fs17.readdirSync(featureDir)) {
+        const match = entry.match(STORY_FILE2);
+        if (!match) continue;
+        const n = parseInt(match[1], 10);
+        used.push(n);
+        seen.set(n, (seen.get(n) ?? 0) + 1);
       }
     }
-    if (!featureSlugInput) {
-      featureSlugInput = (await input3({
-        message: "New feature slug (kebab-case):",
-        validate: validateFeatureSlugForPrompt
-      })).trim();
+  }
+  const duplicates = [...seen.entries()].filter(([, c]) => c > 1).map(([n]) => n);
+  const maxNumber = used.length ? Math.max(...used) : 0;
+  return { usedNumbers: used.sort((a, b) => a - b), maxNumber, duplicates, nextGlobal: maxNumber + 1 };
+}
+function formatSequence(n) {
+  return String(n).padStart(2, "0");
+}
+
+// src/commands/rm/shared.ts
+var STORY_PLAN = /^(\d{2,})-story-.+\.md$/;
+function canPromptForRm(opts) {
+  if (opts.yes) return false;
+  return isInteractive() && Boolean(process.stdin.isTTY);
+}
+function removeOverviewRow(featurePlanDir, storyId) {
+  const overview = path10.join(featurePlanDir, "00-overview.md");
+  if (!fs18.existsSync(overview)) return;
+  const src = fs18.readFileSync(overview, "utf8");
+  const lines = src.split("\n");
+  const filtered = lines.filter((line2) => {
+    if (!line2.startsWith("|")) return true;
+    if (line2.includes("NN") && line2.includes("File") && line2.includes("Title")) return true;
+    if (/^\|\s*-+/.test(line2)) return true;
+    return !line2.includes(storyId);
+  });
+  fs18.writeFileSync(overview, filtered.join("\n"), "utf8");
+}
+function removeOverviewRowForPlanFile(featurePlanDir, planBasename) {
+  const overview = path10.join(featurePlanDir, "00-overview.md");
+  if (!fs18.existsSync(overview)) return;
+  const src = fs18.readFileSync(overview, "utf8");
+  const token = `\`${planBasename}\``;
+  const lines = src.split("\n");
+  const filtered = lines.filter((line2) => {
+    if (!line2.startsWith("|")) return true;
+    if (line2.includes("NN") && line2.includes("File") && line2.includes("Title")) return true;
+    if (/^\|\s*-+/.test(line2)) return true;
+    return !line2.includes(token);
+  });
+  fs18.writeFileSync(overview, filtered.join("\n"), "utf8");
+}
+function trashOrDelete(absPaths, trashRoot, useTrash) {
+  if (!useTrash) {
+    for (const p of absPaths) fs18.rmSync(p, { recursive: true, force: true });
+    return { removed: absPaths };
+  }
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const bucket = path10.join(trashRoot, ts);
+  fs18.mkdirSync(bucket, { recursive: true });
+  for (const src of absPaths) {
+    const rel = path10.basename(src);
+    let dst = path10.join(bucket, rel);
+    let n = 0;
+    while (fs18.existsSync(dst)) {
+      n += 1;
+      dst = path10.join(bucket, `${n}_${rel}`);
     }
+    fs18.renameSync(src, dst);
   }
-  const slug = slugify(featureSlugInput);
-  if (!slug) {
-    throw new Error(
-      `Invalid feature slug: "${featureSlugInput}". Run \`squad new-story\` and use kebab-case (letters, digits, hyphens).`
-    );
+  return { removed: absPaths, trashed: bucket };
+}
+function renderPreview(kind, targets, opts) {
+  divider(`squad rm ${kind}`);
+  step(opts.dryRun ? "Dry run \u2014 nothing will be changed." : "About to remove:");
+  for (const t of targets) {
+    kv(t.kind, t.label, 6);
   }
-  const root = requireSquadRoot();
-  const paths = buildPaths(root);
-  const config2 = loadConfig(paths.configFile);
-  let noTracker = opts.tracker === false && config2.tracker.type !== "none";
+  if (opts.trash) {
+    info(`Items will move to ${path10.relative(process.cwd(), opts.trashRoot)}/<timestamp>/`);
+  } else if (!opts.dryRun) {
+    warning("This is a permanent delete. Pass --trash to move to .squad/.trash/ instead.");
+  }
+}
+function listAllPlanListEntries(paths, featureFilter) {
+  if (!fs18.existsSync(paths.plansDir)) return [];
+  const out = [];
+  for (const ent of fs18.readdirSync(paths.plansDir, { withFileTypes: true })) {
+    if (!ent.isDirectory()) continue;
+    if (featureFilter && ent.name !== featureFilter) continue;
+    const featureDir = path10.join(paths.plansDir, ent.name);
+    for (const name of fs18.readdirSync(featureDir)) {
+      if (!STORY_PLAN.test(name)) continue;
+      out.push({ feature: ent.name, file: name, abs: path10.join(featureDir, name) });
+    }
+  }
+  return out.sort((a, b) => (a.feature + a.file).localeCompare(b.feature + b.file));
+}
+async function pickStoryInteractive(paths, featureFilter) {
+  const stories = listAllStories(paths).filter((s) => !featureFilter || s.feature === featureFilter);
+  if (stories.length === 0) {
+    throw new Error("No stories to pick. Run `squad new-story` first, or `squad list` to verify paths.");
+  }
+  if (stories.length === 1) return stories[0];
+  const choice = await select4({
+    message: "Story to remove:",
+    choices: stories.map((s) => ({
+      name: `${s.feature}/${s.id}  \xB7  ${s.titleHint ?? s.id}`,
+      value: s
+    }))
+  });
+  return choice;
+}
+async function pickPlanInteractive(paths, featureFilter) {
+  const plans = listAllPlanListEntries(paths, featureFilter);
+  if (plans.length === 0) {
+    throw new Error("No plan files to pick. Run `squad new-plan` first, or `squad list` to see plans.");
+  }
+  if (plans.length === 1) return plans[0];
+  return select4({
+    message: "Plan file to remove:",
+    choices: plans.map((p) => ({
+      name: `${p.feature}/${p.file}`,
+      value: p
+    }))
+  });
+}
+async function pickFeatureInteractive(paths) {
+  const feats = listFeatures(paths);
+  if (feats.length === 0) {
+    throw new Error("No features to pick. Run `squad new-story` first, or `squad list` to see features.");
+  }
+  if (feats.length === 1) return feats[0];
+  return select4({
+    message: "Feature to remove:",
+    choices: feats.map((f) => ({ name: f, value: f }))
+  });
+}
+function resolveStoryFromArg(arg, stories, root) {
+  const t = arg.trim();
+  for (const s of stories) {
+    if (s.id === t) return s;
+    if (`${s.feature}/${s.id}` === t) return s;
+  }
+  const abs = path10.isAbsolute(t) ? t : path10.resolve(root, t);
+  const withIntake = t.endsWith("intake.md") ? abs : path10.join(abs, "intake.md");
+  return findStoryByIntake(stories, withIntake) ?? findStoryByIntake(stories, abs);
+}
+function isSequenceToken(s) {
+  return /^\d{1,4}$/.test(s) && s.length > 0;
+}
+function tryParsePlanFilePath(absPath, paths, featureFilter) {
+  if (!fs18.existsSync(absPath) || !STORY_PLAN.test(path10.basename(absPath))) return void 0;
+  const planRoot = fs18.realpathSync(path10.resolve(paths.plansDir));
+  const fileReal = fs18.realpathSync(path10.resolve(absPath));
+  const rel = path10.relative(planRoot, fileReal);
+  if (rel.startsWith("..") || path10.isAbsolute(rel)) return void 0;
+  const segs = rel.split(path10.sep);
+  if (segs.length < 2) return void 0;
+  const feature = segs[0];
+  const file = segs.slice(1).join(path10.sep);
+  if (featureFilter && feature !== featureFilter) return void 0;
+  return { feature, file, abs: path10.resolve(absPath) };
+}
+function resolvePlanFromArg(arg, paths, featureFilter) {
+  const t = arg.trim();
+  if (!t) return void 0;
+  const asPath = path10.isAbsolute(t) ? t : path10.resolve(process.cwd(), t);
+  const a = tryParsePlanFilePath(asPath, paths, featureFilter);
+  if (a) return a;
+  if (!path10.isAbsolute(t)) {
+    const under = tryParsePlanFilePath(path10.join(paths.plansDir, t), paths, featureFilter);
+    if (under) return under;
+  }
+  if (isSequenceToken(t)) {
+    const nn = formatSequence(parseInt(t, 10));
+    const prefix = `${nn}-`;
+    const cands = [];
+    for (const p of listAllPlanListEntries(paths, featureFilter)) {
+      if (p.file.startsWith(prefix)) cands.push(p);
+    }
+    if (cands.length === 1) return cands[0];
+    if (cands.length > 1) {
+      throw new Error(
+        `Multiple plans match sequence "${t}". Run \`squad rm plan\` in a TTY, or add \`--feature <slug>\` to disambiguate.`
+      );
+    }
+  }
+  return void 0;
+}
+function countOverviewDataRows(overviewContent) {
+  let n = 0;
+  for (const line2 of overviewContent.split("\n")) {
+    if (!line2.startsWith("|")) continue;
+    if (/^\|\s*-+/.test(line2)) continue;
+    if (line2.includes("NN") && line2.includes("File") && line2.includes("Title")) continue;
+    n++;
+  }
+  return n;
+}
+function featureStoriesDirEmpty(paths, feature) {
+  const d = path10.join(paths.storiesDir, feature);
+  if (!fs18.existsSync(d)) return true;
+  return fs18.readdirSync(d).length === 0;
+}
+
+// src/core/story-mutations.ts
+function writeNewStoryToDisk(input5) {
+  const { paths, config: config2, featureSlug, storyFolderName, id, title, noTracker, sourceBlock, fetchedIssue } = input5;
+  const storyDir = path11.join(paths.storiesDir, featureSlug, storyFolderName);
+  const intakeFile = path11.join(storyDir, "intake.md");
+  const attachmentsDir = path11.join(storyDir, "attachments");
+  if (fs19.existsSync(intakeFile)) {
+    const rel = path11.relative(paths.root, intakeFile);
+    throw new Error(
+      `Intake already exists: ${intakeFile}. Run \`squad new-plan ${rel}\` to plan it, or \`squad rm story\` to remove the story first.`
+    );
+  }
+  fs19.mkdirSync(attachmentsDir, { recursive: true });
+  const template = readBundledPrompt("intake.md");
+  const rendered = render(
+    template,
+    buildIntakeTemplateVars({
+      config: config2,
+      featureSlug,
+      storyFolderName,
+      trackerId: id,
+      title,
+      fetchedIssue
+    })
+  );
+  const skippedPreamble = noTracker && config2.tracker.type !== "none" && !sourceBlock ? buildSkippedTrackerPreamble(config2.tracker.type) : "";
+  writeFileSafe(intakeFile, skippedPreamble + sourceBlock + rendered, false);
+  ensureFeatureOverview(path11.join(paths.plansDir, featureSlug), featureSlug);
+  return { storyDir, intakePath: intakeFile, feature: featureSlug, id: storyFolderName };
+}
+function createStoryRecord(input5) {
+  const feature = slugify(input5.feature);
+  if (!feature) {
+    throw new Error(`Invalid feature slug: "${input5.feature}". Use kebab-case (letters, digits, hyphens).`);
+  }
+  const rawId = input5.trackerId?.trim() || void 0;
+  const noTracker = input5.config.tracker.type !== "none" && !rawId;
+  let id = rawId;
+  if (noTracker) id = void 0;
+  if (id && !validateTrackerId(input5.config.tracker.type, id)) {
+    throw new Error(
+      `Invalid tracker id "${id}" for tracker type "${input5.config.tracker.type}". Check the expected format, or \`squad config set tracker\` if the tracker type is wrong.`
+    );
+  }
+  const title = input5.title?.trim() || void 0;
+  const storyFolderName = id ? trackerIdForFilename(input5.config.tracker.type, id) : slugify(title ?? "");
+  if (!storyFolderName) {
+    throw new Error(
+      'Could not derive a story folder name. Pass a "title" when not linking a tracker id, or provide a "trackerId" to name the folder after it.'
+    );
+  }
+  return writeNewStoryToDisk({
+    paths: input5.paths,
+    config: input5.config,
+    featureSlug: feature,
+    storyFolderName,
+    id,
+    title,
+    noTracker,
+    sourceBlock: "",
+    fetchedIssue: void 0
+  });
+}
+async function createStoryRecordFromIssue(input5) {
+  const feature = slugify(input5.feature);
+  if (!feature) {
+    throw new Error(`Invalid feature slug: "${input5.feature}". Use kebab-case (letters, digits, hyphens).`);
+  }
+  const id = input5.issue.id.trim();
+  if (!validateTrackerId(input5.config.tracker.type, id)) {
+    throw new Error(
+      `Invalid tracker id "${id}" for tracker type "${input5.config.tracker.type}". Check the expected format, or \`squad config set tracker\` if the tracker type is wrong.`
+    );
+  }
+  const title = input5.issue.title;
+  const storyFolderName = trackerIdForFilename(input5.config.tracker.type, id);
+  const storyDir = path11.join(input5.paths.storiesDir, feature, storyFolderName);
+  const intakeFile = path11.join(storyDir, "intake.md");
+  const attachmentsDir = path11.join(storyDir, "attachments");
+  if (fs19.existsSync(intakeFile)) {
+    const rel = path11.relative(input5.paths.root, intakeFile);
+    throw new Error(
+      `Intake already exists: ${intakeFile}. Run \`squad new-plan ${rel}\` to plan it, or \`squad rm story\` to remove the story first.`
+    );
+  }
+  fs19.mkdirSync(attachmentsDir, { recursive: true });
+  let downloads = [];
+  if (input5.withAttachments && input5.issue.attachments.length > 0) {
+    downloads = await input5.client.downloadAttachments(input5.issue.attachments, attachmentsDir);
+  } else if (!input5.withAttachments && input5.issue.attachments.length > 0) {
+    downloads = input5.issue.attachments.map((source) => ({
+      source,
+      outcome: "skipped-error",
+      bytesWritten: 0,
+      skipReason: "not downloaded"
+    }));
+  }
+  const sourceBlock = buildSourcePreamble(input5.issue, downloads, input5.config.tracker.type);
+  return writeNewStoryToDisk({
+    paths: input5.paths,
+    config: input5.config,
+    featureSlug: feature,
+    storyFolderName,
+    id,
+    title,
+    noTracker: false,
+    sourceBlock,
+    fetchedIssue: input5.issue
+  });
+}
+function deleteStoryRecord(input5) {
+  const targets = [input5.story.storyDir];
+  if (input5.story.planFile) {
+    targets.push(path11.join(input5.paths.plansDir, input5.story.feature, input5.story.planFile));
+  }
+  const result = trashOrDelete(targets, input5.paths.trashDir, input5.trash);
+  removeOverviewRow(path11.join(input5.paths.plansDir, input5.story.feature), input5.story.id);
+  return result;
+}
+
+// src/commands/new-story.ts
+function validateFeatureSlugForPrompt(v) {
+  const trimmed = v.trim();
+  if (!trimmed) return "Required.";
+  const s = slugify(trimmed);
+  if (!s) return "Required.";
+  if (s !== trimmed) return "Use lowercase kebab-case (letters, digits, hyphens).";
+  return true;
+}
+async function runNewStory(featureSlug, opts) {
+  const interactive = !opts.yes && Boolean(process.stdin.isTTY) && process.env.CI !== "true";
+  let featureSlugInput = featureSlug;
+  if (!featureSlugInput) {
+    if (!interactive) {
+      throw new Error(
+        "feature-slug is required. Run `squad new-story` in a TTY to pick interactively, or pass a slug like `squad new-story <feature-slug>`, or add `--yes` to fail fast in scripts."
+      );
+    }
+    const rootForPrompt = requireSquadRoot();
+    const pathsForPrompt = buildPaths(rootForPrompt);
+    const existing = listFeatures(pathsForPrompt);
+    if (existing.length > 0) {
+      const choice = await select5({
+        message: "Feature:",
+        choices: [
+          ...existing.map((f) => ({ name: f, value: f })),
+          { name: "\u2500\u2500\u2500 new feature \u2500\u2500\u2500", value: "__NEW__" }
+        ]
+      });
+      if (choice !== "__NEW__") {
+        featureSlugInput = choice;
+      }
+    }
+    if (!featureSlugInput) {
+      featureSlugInput = (await input3({
+        message: "New feature slug (kebab-case):",
+        validate: validateFeatureSlugForPrompt
+      })).trim();
+    }
+  }
+  const slug = slugify(featureSlugInput);
+  if (!slug) {
+    throw new Error(
+      `Invalid feature slug: "${featureSlugInput}". Run \`squad new-story\` and use kebab-case (letters, digits, hyphens).`
+    );
+  }
+  const root = requireSquadRoot();
+  const paths = buildPaths(root);
+  const config2 = loadConfig(paths.configFile);
+  let noTracker = opts.tracker === false && config2.tracker.type !== "none";
   let id = opts.id;
   if (noTracker) id = void 0;
   let trackerNeedsId = !noTracker && config2.tracker.type !== "none" && config2.naming.includeTrackerId;
@@ -2086,7 +2715,7 @@ async function runNewStory(featureSlug, opts) {
         `Tracker "${config2.tracker.type}" is configured and naming.includeTrackerId is true. Run \`squad new-story <feature-slug> --id <tracker-id>\` to link now, or \`squad new-story <feature-slug> --no-tracker\` to skip the tracker for this story only.`
       );
     }
-    const mode = await select4({
+    const mode = await select5({
       message: `This workspace requires a ${config2.tracker.type} id for new stories. How do you want to proceed?`,
       choices: [
         { name: `Enter a ${config2.tracker.type} id now`, value: "enter" },
@@ -2132,21 +2761,23 @@ async function runNewStory(featureSlug, opts) {
       'Could not derive a story folder name. Pass `--title "<hint>"` when using `--no-tracker`, or `--id <tracker-id>` to name the folder after the tracker id.'
     );
   }
-  const storyDir = path8.join(paths.storiesDir, slug, storyFolderName);
-  const intakeFile = path8.join(storyDir, "intake.md");
-  const attachmentsDir = path8.join(storyDir, "attachments");
-  if (fs16.existsSync(intakeFile)) {
+  const storyDir = path12.join(paths.storiesDir, slug, storyFolderName);
+  const intakeFile = path12.join(storyDir, "intake.md");
+  const attachmentsDir = path12.join(storyDir, "attachments");
+  if (fs20.existsSync(intakeFile)) {
     throw new Error(
-      `Intake already exists: ${intakeFile}. Run \`squad new-plan ${path8.relative(root, intakeFile)}\` to plan it, or \`squad rm story\` to remove the story first.`
+      `Intake already exists: ${intakeFile}. Run \`squad new-plan ${path12.relative(root, intakeFile)}\` to plan it, or \`squad rm story\` to remove the story first.`
     );
   }
-  fs16.mkdirSync(attachmentsDir, { recursive: true });
+  fs20.mkdirSync(attachmentsDir, { recursive: true });
   let sourceBlock = "";
   let fetchedSummary;
+  let fetchedIssue;
   const shouldFetch = !noTracker && opts.fetch !== false && Boolean(id) && config2.tracker.type !== "none";
   if (shouldFetch) {
     const outcome = await tryFetchIssue(config2, id, opts, paths, attachmentsDir);
     if (outcome.outcome === "ok") {
+      fetchedIssue = outcome.issue;
       sourceBlock = buildSourcePreamble(outcome.issue, outcome.downloads, config2.tracker.type);
       if (!title) title = outcome.issue.title;
       const written = outcome.downloads.filter((d) => d.outcome === "written").length;
@@ -2157,28 +2788,25 @@ async function runNewStory(featureSlug, opts) {
       sourceBlock = buildFallbackPreamble(outcome.reason, outcome.hint);
     }
   }
-  const template = readBundledPrompt("intake.md");
-  const rendered = render(template, {
+  writeNewStoryToDisk({
+    paths,
+    config: config2,
     featureSlug: slug,
-    storyId: storyFolderName,
-    trackerType: config2.tracker.type,
-    projectRoots: (config2.project.projectRoots ?? ["."]).join(", "),
-    primaryLanguage: config2.project.primaryLanguage ?? ""
+    storyFolderName,
+    id,
+    title,
+    noTracker,
+    sourceBlock,
+    fetchedIssue
   });
-  const skippedPreamble = noTracker && config2.tracker.type !== "none" && !sourceBlock ? buildSkippedTrackerPreamble(config2.tracker.type) : "";
-  const titleHint = title ? `> **Title hint (from CLI):** ${title}
-
-` : "";
-  writeFileSafe(intakeFile, skippedPreamble + sourceBlock + titleHint + rendered, false);
-  ensureFeatureOverview(path8.join(paths.plansDir, slug), slug);
-  const relativePath = path8.relative(root, intakeFile);
-  const relAttachDir = path8.relative(root, attachmentsDir);
+  const relativePath = path12.relative(root, intakeFile);
+  const relAttachDir = path12.relative(root, attachmentsDir);
   success("Created intake");
   if (noTracker && config2.tracker.type !== "none") {
     warning("Created without a tracker link. Use `squad tracker link` later to attach one.");
   }
   kv("intake", relativePath, 11);
-  kv("attachments", relAttachDir + path8.sep, 11);
+  kv("attachments", relAttachDir + path12.sep, 11);
   if (fetchedSummary && fetchedSummary.written > 0) {
     kv("fetched", `${fetchedSummary.id} \xB7 ${fetchedSummary.written} attachments saved`, 11);
   }
@@ -2187,7 +2815,7 @@ async function runNewStory(featureSlug, opts) {
   info(`squad new-plan ${relativePath}`);
 }
 async function tryFetchIssue(config2, id, opts, paths, attachmentsDir) {
-  const secretsFromFile = fs16.existsSync(paths.secretsFile) ? loadSecrets(paths.secretsFile) : {};
+  const secretsFromFile = fs20.existsSync(paths.secretsFile) ? loadSecrets(paths.secretsFile) : {};
   const secrets = overlayTrackerEnv(secretsFromFile);
   const resolution = clientFor(config2, secrets);
   if (resolution.error) {
@@ -2242,82 +2870,11 @@ function explainTrackerErrorHint(err) {
 function truncate(s, n) {
   return s.length <= n ? s : s.slice(0, n - 1) + "\u2026";
 }
-function buildSourcePreamble(issue, downloads, trackerType) {
-  const header = `> **Fetched from ${trackerType}:** [${issue.id}](${issue.url})  
-> *Fetched ${issue.fetchedAt}. Edit the sections below as needed; the planner reads this file verbatim.*
-
-`;
-  const metaLines = [];
-  metaLines.push(`**Title:** ${issue.title}`);
-  if (issue.type) metaLines.push(`**Type:** ${issue.type}`);
-  if (issue.status) metaLines.push(`**Status:** ${issue.status}`);
-  if (issue.assignee) metaLines.push(`**Assignee:** ${issue.assignee}`);
-  if (issue.labels.length > 0) metaLines.push(`**Labels:** ${issue.labels.join(", ")}`);
-  const description = issue.description.trim().length > 0 ? issue.description.trim() : "*(tracker returned an empty description)*";
-  const attachmentsTable = renderAttachmentsTable(downloads);
-  return [
-    header,
-    "## Source \u2014 work item (from tracker)",
-    "",
-    metaLines.join("  \n"),
-    "",
-    "### Description",
-    "",
-    description,
-    "",
-    attachmentsTable,
-    "",
-    "---",
-    ""
-  ].join("\n");
-}
-function renderAttachmentsTable(downloads) {
-  if (downloads.length === 0) return "### Attachments\n\nNone.";
-  const rows = downloads.map((d) => {
-    const sizeNum = (d.bytesWritten || d.source.size) / 1024;
-    const size = `${sizeNum | 0} KB`;
-    switch (d.outcome) {
-      case "written":
-        return `| \`attachments/${path8.basename(d.absolutePath)}\` | ${size} | downloaded |`;
-      case "skipped-oversize":
-        return `| ${d.source.filename} | ${size} | **skipped** \u2014 ${d.skipReason} |`;
-      case "skipped-error":
-        return `| ${d.source.filename} | \u2014 | **skipped** \u2014 ${d.skipReason} |`;
-    }
-  });
-  return ["### Attachments", "", "| File | Size | Status |", "| ---- | ---- | ------ |", ...rows].join("\n");
-}
-function buildFallbackPreamble(reason, hint) {
-  const hintLine = hint ? `
-> Hint: ${hint}` : "";
-  return `> **Tracker auto-fetch skipped.**  
-> ${reason}${hintLine}
-
----
-
-`;
-}
-function buildSkippedTrackerPreamble(trackerType) {
-  return [
-    "> **Source:** manual entry (tracker skipped via `--no-tracker`).",
-    `> Active tracker for this workspace: \`${trackerType}\` \u2014 this story is not linked. `,
-    "> Run `squad tracker link <story-path> <tracker-id>` later if you want to attach one.",
-    "",
-    ""
-  ].join("\n");
-}
-function ensureFeatureOverview(featurePlanDir, slug) {
-  fs16.mkdirSync(featurePlanDir, { recursive: true });
-  const overviewFile = path8.join(featurePlanDir, "00-overview.md");
-  if (fs16.existsSync(overviewFile)) return;
-  const template = readFile(path8.join(templatesDir(), "overview.md"));
-  writeFileSafe(overviewFile, render(template, { featureSlug: slug }), false);
-}
 
 // src/commands/new-plan.ts
-import fs22 from "fs";
-import path15 from "path";
-import { confirm as confirm6, select as select5 } from "@inquirer/prompts";
+import fs26 from "fs";
+import path19 from "path";
+import { confirm as confirm6, select as select6 } from "@inquirer/prompts";
 
 // src/utils/clipboard.ts
 import { spawn, spawnSync } from "child_process";
@@ -2340,12 +2897,12 @@ async function copyToClipboard(text) {
   return { ok: false, reason: lastReason ?? "no working clipboard tool found" };
 }
 function tryCopy(cmd, text) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let child;
     try {
       child = spawn(cmd.command, cmd.args, { stdio: ["pipe", "ignore", "pipe"] });
     } catch (err) {
-      resolve({ ok: false, reason: `${cmd.command} failed to spawn: ${err.message}` });
+      resolve2({ ok: false, reason: `${cmd.command} failed to spawn: ${err.message}` });
       return;
     }
     let stderr = "";
@@ -2353,13 +2910,13 @@ function tryCopy(cmd, text) {
       stderr += chunk.toString();
     });
     child.on("error", (err) => {
-      resolve({ ok: false, reason: `${cmd.command} spawn error: ${err.message}` });
+      resolve2({ ok: false, reason: `${cmd.command} spawn error: ${err.message}` });
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve({ ok: true, tool: cmd.command });
+        resolve2({ ok: true, tool: cmd.command });
       } else {
-        resolve({
+        resolve2({
           ok: false,
           reason: `${cmd.command} exited with code ${code}${stderr ? `: ${stderr.trim().slice(0, 200)}` : ""}`
         });
@@ -2408,11 +2965,11 @@ function noCandidateReason() {
 }
 
 // src/planner/loop.ts
-import path10 from "path";
+import path15 from "path";
 
 // src/planner/tools.ts
-import fs17 from "fs";
-import path9 from "path";
+import fs21 from "fs";
+import path13 from "path";
 var READ_FILE_TOOL = {
   name: "read_file",
   description: "Read a UTF-8 text file from the project, returning its contents so you can plan against real code. Paths must be relative to the project root. Binary files and files outside the project are refused. You have a bounded context budget; prefer small, targeted reads.",
@@ -2431,15 +2988,15 @@ function readFileTool(root, budget, input5) {
   if (typeof raw !== "string" || raw.length === 0) {
     return error('read_file: missing or invalid "path" argument.');
   }
-  const resolved = path9.resolve(root, raw);
-  const relCheck = path9.relative(root, resolved);
-  if (relCheck.startsWith("..") || path9.isAbsolute(relCheck)) {
+  const resolved = path13.resolve(root, raw);
+  const relCheck = path13.relative(root, resolved);
+  if (relCheck.startsWith("..") || path13.isAbsolute(relCheck)) {
     return error(`read_file: path "${raw}" escapes the project root and was refused.`);
   }
-  if (!fs17.existsSync(resolved)) {
+  if (!fs21.existsSync(resolved)) {
     return error(`read_file: not found "${raw}".`);
   }
-  const stat = fs17.statSync(resolved);
+  const stat = fs21.statSync(resolved);
   if (stat.isDirectory()) {
     return error(`read_file: "${raw}" is a directory. Ask for a specific file path.`);
   }
@@ -2454,7 +3011,7 @@ function readFileTool(root, budget, input5) {
   }
   let buf;
   try {
-    buf = fs17.readFileSync(resolved);
+    buf = fs21.readFileSync(resolved);
   } catch (e) {
     return error(`read_file: failed to read "${raw}" (${e.message}).`);
   }
@@ -2619,7 +3176,8 @@ async function callAnthropic(req) {
       "anthropic-version": API_VERSION,
       "content-type": "application/json"
     },
-    body: JSON.stringify(body)
+    body: JSON.stringify(body),
+    signal: req.abort
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");
@@ -2757,7 +3315,8 @@ async function callOpenAI(req) {
       Authorization: `Bearer ${req.apiKey}`,
       "content-type": "application/json"
     },
-    body: JSON.stringify(body)
+    body: JSON.stringify(body),
+    signal: req.abort
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");
@@ -2875,7 +3434,8 @@ async function callGoogle(req) {
   const res = await fetch(url, {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify(body)
+    body: JSON.stringify(body),
+    signal: req.abort
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");
@@ -2965,9 +3525,91 @@ function prefixOf(provider, req) {
   return s.length > 0 ? s.slice(0, -1) : s;
 }
 
+// src/core/runs.ts
+import fs22 from "fs/promises";
+import path14 from "path";
+import { randomBytes } from "crypto";
+var RING_SIZE = 20;
+function newRunId() {
+  const ts = Date.now().toString(36).padStart(9, "0");
+  const rnd = randomBytes(8).toString("hex");
+  return `${ts}-${rnd}`;
+}
+async function appendRun(paths, rec) {
+  const dir = path14.join(paths.squadDir, "runs");
+  await fs22.mkdir(dir, { recursive: true });
+  const file = path14.join(dir, `${rec.runId}.json`);
+  await fs22.writeFile(file, JSON.stringify({ ...rec, version: 1 }, null, 2) + "\n", "utf8");
+  await pruneOldRuns(dir);
+}
+async function pruneOldRuns(dir) {
+  const entries = (await fs22.readdir(dir)).filter((n) => n.endsWith(".json"));
+  if (entries.length <= RING_SIZE) return;
+  entries.sort();
+  const drop = entries.slice(0, entries.length - RING_SIZE);
+  await Promise.all(drop.map((n) => fs22.rm(path14.join(dir, n), { force: true })));
+}
+async function listRuns(paths) {
+  const dir = path14.join(paths.squadDir, "runs");
+  let entries;
+  try {
+    entries = await fs22.readdir(dir);
+  } catch {
+    return [];
+  }
+  const files = entries.filter((n) => n.endsWith(".json")).sort().reverse();
+  const out = [];
+  for (const f of files) {
+    try {
+      const raw = await fs22.readFile(path14.join(dir, f), "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version === 1) out.push(parsed);
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/planner/session-limits.ts
+var DEFAULT_PLANNER_MAX_ITERATIONS = 40;
+var PLANNER_MARKDOWN_CONTINUATION_USER = "Your previous reply was cut off because it hit the per-response output token limit for this request. Continue the Markdown plan from the exact cut-off only: write the remainder, do not repeat headings or paragraphs already sent. When the plan is complete, use end_turn without unnecessary tool calls.";
+
+// src/planner/events.ts
+var PlannerEventBus = class {
+  listeners = /* @__PURE__ */ new Set();
+  emit(e) {
+    for (const fn of this.listeners) {
+      try {
+        fn(e);
+      } catch {
+      }
+    }
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+};
+
 // src/planner/loop.ts
 var MAX_RATE_LIMIT_RETRY_SEC = 90;
-var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var defaultSleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+function isAbortError(e) {
+  return e instanceof Error && e.name === "AbortError";
+}
+async function sleepWithAbort(ms, sleepFn, abort) {
+  if (!abort) {
+    await sleepFn(ms);
+    return;
+  }
+  if (abort.aborted) throw new DOMException("Aborted", "AbortError");
+  await Promise.race([
+    sleepFn(ms),
+    new Promise((_, reject) => {
+      abort.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")), { once: true });
+    })
+  ]);
+}
 function buildPlannerRunStats(budget, turns, runStartedAt) {
   const u = budget.snapshot().usage;
   const cacheRead = u.cacheReadTokens ?? 0;
@@ -2986,18 +3628,130 @@ function buildPlannerRunStats(budget, turns, runStartedAt) {
     durationMs: Date.now() - runStartedAt
   };
 }
+function readBudgetishError(result) {
+  return result.isError && (/budget/i.test(result.content) || /max file reads/i.test(result.content));
+}
+function extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut) {
+  input5.budget.extendSession();
+  maxIter.current += baseMaxIter;
+  maxOut.current += baseMaxOut;
+}
+function recordUsageAndEmit(bus, input5, runId, turn, usage) {
+  input5.budget.recordUsage(usage);
+  input5.onUsage?.(usage);
+  bus.emit({ kind: "usage", runId, turn, usage });
+  const u = input5.budget.snapshot().usage;
+  const cacheRead = u.cacheReadTokens ?? 0;
+  const cacheCreate = u.cacheCreationTokens ?? 0;
+  if (cacheRead > 0 || cacheCreate > 0) {
+    const inTok = u.inputTokens;
+    const totalInput = inTok + cacheRead;
+    const cacheHitRatio = totalInput === 0 ? 0 : Math.round(cacheRead / totalInput * 100) / 100;
+    bus.emit({
+      kind: "cache_summary",
+      runId,
+      turn,
+      cacheHitRatio,
+      cacheReadTokens: cacheRead,
+      cacheCreationTokens: cacheCreate
+    });
+  }
+}
+function cancelledOutput(input5, bus, runId, accumulatedText, budgetExhausted, iterations, runStartedAt) {
+  bus.emit({ kind: "cancelled", runId });
+  return {
+    planText: accumulatedText,
+    budgetExhausted,
+    timedOut: false,
+    finishedNormally: false,
+    iterations,
+    stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
+    userCancelled: true
+  };
+}
 async function runPlanner(input5) {
   const runStartedAt = Date.now();
-  const maxIter = input5.maxIterations ?? 40;
+  const bus = input5.events ?? new PlannerEventBus();
+  const runId = input5.runId ?? newRunId();
+  const cacheEnabled = input5.cacheEnabled ?? true;
+  bus.emit({
+    kind: "started",
+    runId,
+    provider: input5.provider.name,
+    model: input5.model,
+    cacheEnabled
+  });
+  const baseMaxIter = input5.maxIterations ?? DEFAULT_PLANNER_MAX_ITERATIONS;
+  const maxIter = { current: baseMaxIter };
+  const baseMaxOut = input5.maxOutputTokens ?? DEFAULT_PLANNER_MAX_OUTPUT_TOKENS;
+  const maxOut = { current: baseMaxOut };
   const turns = [{ role: "user", text: input5.userPrompt }];
   let accumulatedText = "";
   let iterations = 0;
   let budgetExhausted = false;
   let finishedNormally = false;
   let prevRequestPrefix;
-  while (iterations < maxIter) {
+  const decide = input5.decideOnLimit;
+  const sleepFn = input5.sleep ?? defaultSleep;
+  const limitCtx = (kind) => ({
+    kind,
+    budgetSnapshot: input5.budget.snapshot(),
+    iterations,
+    maxIterations: maxIter.current,
+    maxOutputTokens: maxOut.current
+  });
+  for (; ; ) {
+    if (input5.abort?.aborted) {
+      return cancelledOutput(input5, bus, runId, accumulatedText, budgetExhausted, iterations, runStartedAt);
+    }
+    if (iterations >= maxIter.current) {
+      if (decide) {
+        const d = await decide(limitCtx("max_iterations"));
+        if (d === "cancel") {
+          return {
+            planText: accumulatedText,
+            budgetExhausted,
+            timedOut: false,
+            finishedNormally: false,
+            iterations,
+            stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
+            incompleteKind: "max_iterations",
+            userCancelled: true
+          };
+        }
+        extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut);
+        continue;
+      }
+      return {
+        planText: accumulatedText,
+        budgetExhausted,
+        timedOut: false,
+        finishedNormally: false,
+        iterations,
+        stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
+        incompleteKind: "max_iterations"
+      };
+    }
     iterations += 1;
     if (input5.budget.timedOut()) {
+      if (decide) {
+        const d = await decide(limitCtx("wall_clock"));
+        if (d === "cancel") {
+          return {
+            planText: accumulatedText,
+            budgetExhausted,
+            timedOut: true,
+            finishedNormally: false,
+            iterations,
+            stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
+            incompleteKind: "wall_clock",
+            userCancelled: true
+          };
+        }
+        extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut);
+        iterations -= 1;
+        continue;
+      }
       return {
         planText: accumulatedText,
         budgetExhausted,
@@ -3008,6 +3762,24 @@ async function runPlanner(input5) {
       };
     }
     if (input5.budget.overCost()) {
+      if (decide) {
+        const d = await decide(limitCtx("cost_cap"));
+        if (d === "cancel") {
+          return {
+            planText: accumulatedText,
+            budgetExhausted,
+            timedOut: false,
+            finishedNormally: false,
+            iterations,
+            stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
+            incompleteKind: "cost_cap",
+            userCancelled: true
+          };
+        }
+        extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut);
+        iterations -= 1;
+        continue;
+      }
       return {
         planText: accumulatedText,
         budgetExhausted: true,
@@ -3017,15 +3789,20 @@ async function runPlanner(input5) {
         stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt)
       };
     }
+    if (iterations >= 2) {
+      bus.emit({ kind: "turn_started", runId, turn: iterations });
+    }
     const request = {
       systemPrompt: input5.systemPrompt,
       model: input5.model,
       tools: [READ_FILE_TOOL],
       turns,
       apiKey: input5.apiKey,
-      maxOutputTokens: 8192,
-      cacheEnabled: input5.cacheEnabled ?? true
+      maxOutputTokens: maxOut.current,
+      cacheEnabled,
+      abort: input5.abort
     };
+    bus.emit({ kind: "request_sent", runId, turn: iterations });
     if (process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test" && prevRequestPrefix !== void 0) {
       const currentPrefix = prefixOf(input5.provider.name, request);
       if (!currentPrefix.startsWith(prevRequestPrefix)) {
@@ -3035,10 +3812,17 @@ async function runPlanner(input5) {
         );
       }
     }
-    let response = await input5.provider.send(request);
+    let response;
+    try {
+      response = await input5.provider.send(request);
+    } catch (e) {
+      if (isAbortError(e)) {
+        return cancelledOutput(input5, bus, runId, accumulatedText, budgetExhausted, iterations, runStartedAt);
+      }
+      throw e;
+    }
     if (response.usage) {
-      input5.budget.recordUsage(response.usage);
-      input5.onUsage?.(response.usage);
+      recordUsageAndEmit(bus, input5, runId, iterations, response.usage);
     }
     let retriedRateLimit = false;
     let retrySkippedReason;
@@ -3049,11 +3833,25 @@ async function runPlanner(input5) {
       } else {
         const waitSec = Math.min(asked ?? 10, MAX_RATE_LIMIT_RETRY_SEC);
         input5.onRateLimit?.(waitSec);
-        await (input5.sleep ?? defaultSleep)(waitSec * 1e3);
-        response = await input5.provider.send(request);
+        bus.emit({ kind: "rate_limit", runId, turn: iterations, waitSec });
+        try {
+          await sleepWithAbort(waitSec * 1e3, sleepFn, input5.abort);
+        } catch (e) {
+          if (isAbortError(e)) {
+            return cancelledOutput(input5, bus, runId, accumulatedText, budgetExhausted, iterations, runStartedAt);
+          }
+          throw e;
+        }
+        try {
+          response = await input5.provider.send(request);
+        } catch (e) {
+          if (isAbortError(e)) {
+            return cancelledOutput(input5, bus, runId, accumulatedText, budgetExhausted, iterations, runStartedAt);
+          }
+          throw e;
+        }
         if (response.usage) {
-          input5.budget.recordUsage(response.usage);
-          input5.onUsage?.(response.usage);
+          recordUsageAndEmit(bus, input5, runId, iterations, response.usage);
         }
         retriedRateLimit = true;
       }
@@ -3065,18 +3863,42 @@ async function runPlanner(input5) {
     if (response.text) {
       accumulatedText += response.text;
       input5.onAssistantText?.(response.text);
+      bus.emit({ kind: "assistant_text", runId, turn: iterations, delta: response.text });
     }
     if (response.stopReason === "max_tokens" && !response.toolCalls?.length) {
+      bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: response.stopReason });
+      if (decide) {
+        const d = await decide(limitCtx("max_output_tokens"));
+        if (d === "cancel") {
+          return {
+            planText: accumulatedText,
+            budgetExhausted,
+            timedOut: false,
+            finishedNormally: false,
+            iterations,
+            stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
+            incompleteKind: "max_output_tokens",
+            userCancelled: true
+          };
+        }
+        extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut);
+        turns.push({ role: "assistant", text: response.text ?? "" });
+        turns.push({ role: "user", text: PLANNER_MARKDOWN_CONTINUATION_USER });
+        iterations -= 1;
+        continue;
+      }
       return {
         planText: accumulatedText,
         budgetExhausted,
         timedOut: false,
         finishedNormally: false,
         iterations,
-        stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt)
+        stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
+        incompleteKind: "max_output_tokens"
       };
     }
     if (response.stopReason === "end_turn" || !response.toolCalls?.length) {
+      bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: response.stopReason });
       finishedNormally = true;
       return {
         planText: accumulatedText,
@@ -3093,36 +3915,68 @@ async function runPlanner(input5) {
       toolCalls: response.toolCalls
     });
     const toolResults = [];
-    for (const tc of response.toolCalls) {
+    const toolCalls = response.toolCalls;
+    for (let i = 0; i < toolCalls.length; i += 1) {
+      const tc = toolCalls[i];
       if (tc.name !== READ_FILE_TOOL.name) {
         toolResults.push({ toolCallId: tc.id, content: `unknown tool "${tc.name}"`, isError: true });
         continue;
       }
       const before = input5.budget.snapshot().bytes;
-      const result = readFileTool(input5.root, input5.budget, tc.input);
+      let result = readFileTool(input5.root, input5.budget, tc.input);
       const after = input5.budget.snapshot().bytes;
-      input5.onToolCall?.(tc, after - before, after);
-      if (result.isError && (/budget/i.test(result.content) || /max file reads/i.test(result.content))) {
-        budgetExhausted = true;
+      const bytesLoaded = after - before;
+      input5.onToolCall?.(tc, bytesLoaded, after);
+      bus.emit({
+        kind: "tool_call",
+        runId,
+        turn: iterations,
+        toolCall: tc,
+        bytesLoaded,
+        totalBytes: after
+      });
+      if (readBudgetishError(result)) {
+        if (decide) {
+          const d = await decide(limitCtx("file_or_context_reads"));
+          if (d === "cancel") {
+            toolResults.push({ toolCallId: tc.id, content: result.content, isError: true });
+            for (let j = i + 1; j < toolCalls.length; j += 1) {
+              const t2 = toolCalls[j];
+              toolResults.push({
+                toolCallId: t2.id,
+                content: t2.name === READ_FILE_TOOL.name ? "read_file: not executed (planning session stopped after file/context budget)." : `unknown tool "${t2.name}"`,
+                isError: true
+              });
+            }
+            turns.push({ role: "user", toolResults });
+            return {
+              planText: accumulatedText,
+              budgetExhausted: false,
+              timedOut: false,
+              finishedNormally: false,
+              iterations,
+              stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt),
+              incompleteKind: "budget_reads",
+              userCancelled: true
+            };
+          }
+          extendAllSessionLimits(input5, maxIter, maxOut, baseMaxIter, baseMaxOut);
+          result = readFileTool(input5.root, input5.budget, tc.input);
+        } else {
+          budgetExhausted = true;
+        }
       }
       toolResults.push({ toolCallId: tc.id, content: result.content, isError: result.isError });
     }
     turns.push({ role: "user", toolResults });
     if (budgetExhausted) {
-      turns.push({
-        role: "user",
-        text: "Budget is exhausted. Finalise the plan with the information you already have. Do not call any more tools. Output the complete plan markdown now."
-      });
-    }
-  }
-  return {
-    planText: accumulatedText,
-    budgetExhausted,
-    timedOut: false,
-    finishedNormally: false,
-    iterations,
-    stats: buildPlannerRunStats(input5.budget, iterations, runStartedAt)
-  };
+      turns.push({
+        role: "user",
+        text: "Budget is exhausted. Finalise the plan with the information you already have. Do not call any more tools. Output the complete plan markdown now."
+      });
+    }
+    bus.emit({ kind: "turn_complete", runId, turn: iterations, stopReason: response.stopReason });
+  }
 }
 function firstByteDiff(a, b) {
   const n = Math.min(a.length, b.length);
@@ -3151,6 +4005,84 @@ function composePlannerError(providerName, response, retriedRateLimit, retrySkip
   return new Error(`${base} Run \`squad doctor\` to diagnose, or retry \u2014 most 5xx errors are transient.`);
 }
 
+// src/planner/planner-limit-messages.ts
+function printPlannerApiCostNotice() {
+  blank();
+  step("Billing");
+  info(
+    "`squad new-plan --api` sends your intake and repo context to the configured provider. Each model round is billed like any other API usage (input tokens, output tokens, and cache-related tokens when applicable). Choosing \u201CContinue\u201D after a limit runs more rounds and usually increases cost."
+  );
+  blank();
+}
+function kindTitle(kind) {
+  switch (kind) {
+    case "max_output_tokens":
+      return "Output length limit (single response)";
+    case "max_iterations":
+      return "Model round limit";
+    case "wall_clock":
+      return "Wall-clock time limit";
+    case "cost_cap":
+      return "Estimated cost cap";
+    case "file_or_context_reads":
+      return "File read or context size limit";
+  }
+}
+function kindDetail(ctx) {
+  const snap = ctx.budgetSnapshot;
+  const cost = snap.usage.costUsd !== void 0 ? `Estimated spend so far: about $${snap.usage.costUsd.toFixed(2)} (provider-reported when available).` : "Estimated spend so far: not reported by the provider for this run.";
+  switch (ctx.kind) {
+    case "max_output_tokens":
+      return [
+        `The model hit the per-request output cap (${ctx.maxOutputTokens} completion tokens). Long plans can stop mid-markdown even though the session is otherwise healthy.`,
+        "You can continue: squad-kit will ask the model to append the rest of the plan in a follow-up request (extra tokens apply).",
+        cost
+      ];
+    case "max_iterations":
+      return [
+        `The planner reached its round cap (${ctx.maxIterations} model turns) without a clean stop.`,
+        "Continuing raises the round cap and file/time budgets for this run by another full slice from your config.",
+        cost
+      ];
+    case "wall_clock":
+      return [
+        "The configured wall-clock budget for this planning session elapsed before the model finished.",
+        "Continuing adds another slice of time (and read/output/round limits) from your planner budget.",
+        cost
+      ];
+    case "cost_cap":
+      return [
+        "Spending crossed the optional `planner.budget.maxCostUsd` ceiling for this session.",
+        "Continuing raises that ceiling for this run by another slice from config (if a cap is set).",
+        cost
+      ];
+    case "file_or_context_reads":
+      return [
+        "A `read_file` call could not run because the file-read count or total read-bytes budget was exhausted.",
+        "Continuing extends read, context, time, round, and output limits for this session so the model can read again or finish without reads.",
+        cost
+      ];
+  }
+}
+function printPlannerLimitExplanation(ctx) {
+  warning(kindTitle(ctx.kind));
+  for (const line2 of kindDetail(ctx)) {
+    info(line2);
+  }
+  kv("session so far", `${snapSummary(ctx)}`, 18);
+}
+function snapSummary(ctx) {
+  const s = ctx.budgetSnapshot;
+  return `${s.reads} reads \xB7 ${(s.bytes / 1024).toFixed(1)} KB read context \xB7 ${s.usage.inputTokens} in / ${s.usage.outputTokens} out tokens`;
+}
+function printPlannerLimitNextSteps() {
+  blank();
+  step("If you stop here");
+  info("An incomplete plan is saved as `*.partial.md` with front matter `squad-kit-plan-status: partial`.");
+  info("Fix limits in `.squad/config.yaml` (`planner.budget`, `planner.maxOutputTokens`) or run again when ready.");
+  blank();
+}
+
 // src/planner/providers/index.ts
 function providerFor(name) {
   switch (name) {
@@ -3167,18 +4099,35 @@ function providerFor(name) {
 var Budget = class {
   constructor(cfg) {
     this.cfg = cfg;
+    this.maxFileReadsAllowed = cfg.maxFileReads;
+    this.maxContextBytesAllowed = cfg.maxContextBytes;
+    this.maxWallSeconds = cfg.maxDurationSeconds;
+    this.maxCostUsdCeiling = cfg.maxCostUsd;
   }
   cfg;
   reads = 0;
   bytes = 0;
   startedAt = Date.now();
   totalUsage = { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
+  maxFileReadsAllowed;
+  maxContextBytesAllowed;
+  maxWallSeconds;
+  maxCostUsdCeiling;
+  /** Add another slice of the original config limits (used when the user chooses to continue a planner session). */
+  extendSession() {
+    this.maxFileReadsAllowed += this.cfg.maxFileReads;
+    this.maxContextBytesAllowed += this.cfg.maxContextBytes;
+    this.maxWallSeconds += this.cfg.maxDurationSeconds;
+    if (this.cfg.maxCostUsd !== void 0) {
+      this.maxCostUsdCeiling = (this.maxCostUsdCeiling ?? 0) + this.cfg.maxCostUsd;
+    }
+  }
   canRead(nextFileBytes) {
-    if (this.reads >= this.cfg.maxFileReads) {
-      return { ok: false, reason: `max file reads (${this.cfg.maxFileReads}) reached` };
+    if (this.reads >= this.maxFileReadsAllowed) {
+      return { ok: false, reason: `max file reads (${this.maxFileReadsAllowed}) reached` };
     }
-    if (this.bytes + nextFileBytes > this.cfg.maxContextBytes) {
-      return { ok: false, reason: `context budget (${this.cfg.maxContextBytes} bytes) would be exceeded` };
+    if (this.bytes + nextFileBytes > this.maxContextBytesAllowed) {
+      return { ok: false, reason: `context budget (${this.maxContextBytesAllowed} bytes) would be exceeded` };
     }
     return { ok: true };
   }
@@ -3194,11 +4143,11 @@ var Budget = class {
     this.totalUsage.cacheReadTokens = (this.totalUsage.cacheReadTokens ?? 0) + (u.cacheReadTokens ?? 0);
   }
   timedOut() {
-    return (Date.now() - this.startedAt) / 1e3 > this.cfg.maxDurationSeconds;
+    return (Date.now() - this.startedAt) / 1e3 > this.maxWallSeconds;
   }
   overCost() {
-    if (this.cfg.maxCostUsd === void 0) return false;
-    return (this.totalUsage.costUsd ?? 0) > this.cfg.maxCostUsd;
+    if (this.maxCostUsdCeiling === void 0) return false;
+    return (this.totalUsage.costUsd ?? 0) > this.maxCostUsdCeiling;
   }
   snapshot() {
     return {
@@ -3211,8 +4160,8 @@ var Budget = class {
 };
 
 // src/core/repo-map.ts
-import fs18 from "fs";
-import path11 from "path";
+import fs23 from "fs";
+import path16 from "path";
 import ignore from "ignore";
 var DEFAULT_IGNORES = [
   "node_modules",
@@ -3236,10 +4185,10 @@ function buildRepoMap(root, opts = {}) {
 }
 function buildIgnore(root) {
   const ig = ignore().add(DEFAULT_IGNORES);
-  const gitignore = path11.join(root, ".gitignore");
-  if (fs18.existsSync(gitignore)) {
+  const gitignore = path16.join(root, ".gitignore");
+  if (fs23.existsSync(gitignore)) {
     try {
-      ig.add(fs18.readFileSync(gitignore, "utf8"));
+      ig.add(fs23.readFileSync(gitignore, "utf8"));
     } catch {
     }
   }
@@ -3249,15 +4198,15 @@ function walk2(root, dir, ig, out, max, includeHidden) {
   if (out.length >= max) return;
   let entries;
   try {
-    entries = fs18.readdirSync(dir, { withFileTypes: true });
+    entries = fs23.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (out.length >= max) return;
     if (!includeHidden && entry.name.startsWith(".") && entry.name !== ".squad") continue;
-    const abs = path11.join(dir, entry.name);
-    const rel = path11.relative(root, abs);
+    const abs = path16.join(dir, entry.name);
+    const rel = path16.relative(root, abs);
     if (!rel || ig.ignores(rel) || entry.isDirectory() && ig.ignores(rel + "/")) continue;
     if (entry.isDirectory()) {
       walk2(root, abs, ig, out, max, includeHidden);
@@ -3305,42 +4254,21 @@ function composeUserPrompt(args) {
 }
 
 // src/planner/writer.ts
-import fs20 from "fs";
-import path13 from "path";
-
-// src/core/sequence.ts
-import fs19 from "fs";
-import path12 from "path";
-var STORY_FILE2 = /^(\d{2,})-story-.+\.md$/;
-function scanPlans(plansDir) {
-  const used = [];
-  const seen = /* @__PURE__ */ new Map();
-  if (fs19.existsSync(plansDir)) {
-    for (const feature of fs19.readdirSync(plansDir, { withFileTypes: true })) {
-      if (!feature.isDirectory()) continue;
-      const featureDir = path12.join(plansDir, feature.name);
-      for (const entry of fs19.readdirSync(featureDir)) {
-        const match = entry.match(STORY_FILE2);
-        if (!match) continue;
-        const n = parseInt(match[1], 10);
-        used.push(n);
-        seen.set(n, (seen.get(n) ?? 0) + 1);
-      }
-    }
-  }
-  const duplicates = [...seen.entries()].filter(([, c]) => c > 1).map(([n]) => n);
-  const maxNumber = used.length ? Math.max(...used) : 0;
-  return { usedNumbers: used.sort((a, b) => a - b), maxNumber, duplicates, nextGlobal: maxNumber + 1 };
-}
-function formatSequence(n) {
-  return String(n).padStart(2, "0");
+import fs24 from "fs";
+import path17 from "path";
+function planFileSlugParts(config2, story) {
+  const baseSlug = slugify(story.id);
+  const trackerId = config2.naming.includeTrackerId && config2.tracker.type !== "none" ? trackerIdForFilename(config2.tracker.type, story.id) : "";
+  const trackerPart = trackerId && trackerId.toLowerCase() !== baseSlug ? `-${trackerId}` : "";
+  return { baseSlug, trackerPart };
 }
-
-// src/planner/writer.ts
 function writePlanFile(input5) {
   const { paths, config: config2, story } = input5;
-  const featurePlanDir = path13.join(paths.plansDir, story.feature);
-  fs20.mkdirSync(featurePlanDir, { recursive: true });
+  const featurePlanDir = path17.join(paths.plansDir, story.feature);
+  fs24.mkdirSync(featurePlanDir, { recursive: true });
+  if (input5.partial) {
+    return writePartialPlanFile(input5, featurePlanDir, paths, config2, story);
+  }
   const existing = findExistingPlan(featurePlanDir, story.id);
   let targetPath;
   let nn;
@@ -3351,34 +4279,65 @@ function writePlanFile(input5) {
     overwrote = true;
   } else {
     nn = scanPlans(paths.plansDir).nextGlobal;
-    const titleHintSlug = story.titleHint ? slugify(story.titleHint) : "";
-    const baseSlug = titleHintSlug || slugify(story.id);
-    const trackerId = config2.naming.includeTrackerId && config2.tracker.type !== "none" ? trackerIdForFilename(config2.tracker.type, story.id) : "";
-    const trackerPart = trackerId && trackerId !== baseSlug ? `-${trackerId}` : "";
-    targetPath = path13.join(featurePlanDir, `${formatSequence(nn)}-story-${baseSlug}${trackerPart}.md`);
+    const { baseSlug, trackerPart } = planFileSlugParts(config2, story);
+    targetPath = path17.join(featurePlanDir, `${formatSequence(nn)}-story-${baseSlug}${trackerPart}.md`);
+  }
+  const body = `${input5.metadataHeader.trimEnd()}
+
+${input5.planBodyMarkdown.trimStart()}
+`;
+  fs24.writeFileSync(targetPath, body, "utf8");
+  upsertOverviewRow(featurePlanDir, story.feature, nn, path17.basename(targetPath), story, false);
+  return { planFile: targetPath, sequenceNumber: nn, overwrote };
+}
+function writePartialPlanFile(input5, featurePlanDir, paths, config2, story) {
+  const existingPartial = findExistingPartialPlan(featurePlanDir, story.id);
+  let targetPath;
+  let nn;
+  let overwrote = false;
+  if (existingPartial) {
+    targetPath = existingPartial.absPath;
+    nn = existingPartial.nn;
+    overwrote = true;
+  } else {
+    nn = scanPlans(paths.plansDir).nextGlobal;
+    const { baseSlug, trackerPart } = planFileSlugParts(config2, story);
+    targetPath = path17.join(featurePlanDir, `${formatSequence(nn)}-story-${baseSlug}${trackerPart}.partial.md`);
   }
   const body = `${input5.metadataHeader.trimEnd()}
 
 ${input5.planBodyMarkdown.trimStart()}
 `;
-  fs20.writeFileSync(targetPath, body, "utf8");
-  upsertOverviewRow(featurePlanDir, story.feature, nn, path13.basename(targetPath), story);
+  fs24.writeFileSync(targetPath, body, "utf8");
+  upsertOverviewRow(featurePlanDir, story.feature, nn, path17.basename(targetPath), story, true);
   return { planFile: targetPath, sequenceNumber: nn, overwrote };
 }
 function findExistingPlan(featureDir, storyId) {
-  if (!fs20.existsSync(featureDir)) return void 0;
+  if (!fs24.existsSync(featureDir)) return void 0;
   const pattern = /^(\d{2,})-story-.+\.md$/;
-  for (const entry of fs20.readdirSync(featureDir)) {
+  for (const entry of fs24.readdirSync(featureDir)) {
+    if (entry.endsWith(".partial.md")) continue;
     const m = entry.match(pattern);
     if (!m) continue;
-    if (entry.includes(storyId)) return { absPath: path13.join(featureDir, entry), nn: parseInt(m[1], 10) };
+    if (entry.includes(storyId)) return { absPath: path17.join(featureDir, entry), nn: parseInt(m[1], 10) };
   }
   return void 0;
 }
-function upsertOverviewRow(featureDir, feature, nn, filename, story) {
-  const overviewPath = path13.join(featureDir, "00-overview.md");
-  const row = `| ${formatSequence(nn)} | \`${filename}\` | ${story.titleHint ?? story.id} | ${story.id} | \u2014 |`;
-  if (!fs20.existsSync(overviewPath)) {
+function findExistingPartialPlan(featureDir, storyId) {
+  if (!fs24.existsSync(featureDir)) return void 0;
+  const pattern = /^(\d{2,})-story-.+\.partial\.md$/;
+  for (const entry of fs24.readdirSync(featureDir)) {
+    const m = entry.match(pattern);
+    if (!m) continue;
+    if (entry.includes(storyId)) return { absPath: path17.join(featureDir, entry), nn: parseInt(m[1], 10) };
+  }
+  return void 0;
+}
+function upsertOverviewRow(featureDir, feature, nn, filename, story, isPartial) {
+  const overviewPath = path17.join(featureDir, "00-overview.md");
+  const titleCell = isPartial ? `${story.titleHint ?? story.id} (partial)` : story.titleHint ?? story.id;
+  const row = `| ${formatSequence(nn)} | \`${filename}\` | ${titleCell} | ${story.id} | \u2014 |`;
+  if (!fs24.existsSync(overviewPath)) {
     const content = `# ${feature} \u2014 plan overview
 
 Entry point for the **${feature}** feature. Stories execute in order by their \`NN\` prefix.
@@ -3389,10 +4348,10 @@ Entry point for the **${feature}** feature. Stories execute in order by their \`
 |----|------|-------|------------|------------|
 ${row}
 `;
-    fs20.writeFileSync(overviewPath, content, "utf8");
+    fs24.writeFileSync(overviewPath, content, "utf8");
     return;
   }
-  const current = fs20.readFileSync(overviewPath, "utf8");
+  const current = fs24.readFileSync(overviewPath, "utf8");
   const lines = current.split("\n");
   const existingIdx = lines.findIndex((l) => l.includes(`\`${filename}\``) || l.includes(`| ${formatSequence(nn)} |`));
   if (existingIdx >= 0) {
@@ -3401,7 +4360,7 @@ ${row}
     const tableEnd = findTableEnd(lines);
     lines.splice(tableEnd, 0, row);
   }
-  fs20.writeFileSync(overviewPath, lines.join("\n"), "utf8");
+  fs24.writeFileSync(overviewPath, lines.join("\n"), "utf8");
 }
 function findTableEnd(lines) {
   let inTable = false;
@@ -3423,20 +4382,39 @@ function buildMetadataHeader(args) {
     `${args.inputTokens} in / ${args.outputTokens} out tokens`,
     args.costUsd !== void 0 ? `~$${args.costUsd.toFixed(2)}` : null
   ].filter(Boolean);
-  return `<!-- squad-kit: ${parts.join(", ")} -->`;
+  const line1 = `<!-- squad-kit: ${parts.join(", ")} -->`;
+  if (args.planStatus === "partial") {
+    return `${line1}
+
+---
+squad-kit-plan-status: partial
+---`;
+  }
+  return line1;
+}
+
+// src/core/copy-plan-prompt.ts
+function buildCopyPlanPromptMarkdown(config2, intakeContent) {
+  const metaPromptTemplate = readBundledPrompt("generate-plan.md");
+  return render(metaPromptTemplate, {
+    projectRoots: (config2.project.projectRoots ?? ["."]).join(", "),
+    primaryLanguage: config2.project.primaryLanguage ?? "",
+    trackerType: config2.tracker.type,
+    intakeContent
+  });
 }
 
 // src/core/last-run.ts
-import fs21 from "fs/promises";
-import path14 from "path";
+import fs25 from "fs/promises";
+import path18 from "path";
 async function writeLastRun(paths, rec) {
-  const file = path14.join(paths.squadDir, ".last-run.json");
-  await fs21.writeFile(file, JSON.stringify({ ...rec, version: 1 }, null, 2) + "\n", "utf8");
+  const file = path18.join(paths.squadDir, ".last-run.json");
+  await fs25.writeFile(file, JSON.stringify({ ...rec, version: 1 }, null, 2) + "\n", "utf8");
 }
 async function readLastRun(paths) {
-  const file = path14.join(paths.squadDir, ".last-run.json");
+  const file = path18.join(paths.squadDir, ".last-run.json");
   try {
-    const raw = await fs21.readFile(file, "utf8");
+    const raw = await fs25.readFile(file, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1) return void 0;
     return parsed;
@@ -3496,8 +4474,8 @@ async function runNewPlan(intakePath, opts) {
   }
 }
 function resolveFromPath(intakePath, stories, root) {
-  const resolved = path15.resolve(intakePath.trim());
-  if (!fs22.existsSync(resolved)) {
+  const resolved = path19.resolve(intakePath.trim());
+  if (!fs26.existsSync(resolved)) {
     throw new Error(
       `Intake not found: ${resolved}. Run \`squad list\` to see intakes, or \`squad new-story\` to create one first.`
     );
@@ -3509,7 +4487,7 @@ function resolveFromPath(intakePath, stories, root) {
   );
 }
 function relativeStoriesDir(root) {
-  return path15.relative(root, path15.join(root, ".squad", "stories"));
+  return path19.relative(root, path19.join(root, ".squad", "stories"));
 }
 async function pickStory(stories, opts) {
   const candidates = opts.all ? stories : stories.filter((s) => !s.planFile);
@@ -3532,7 +4510,7 @@ async function pickStory(stories, opts) {
       "No intake path provided and not running interactively. Run `squad new-plan` with a path to intake.md, or `squad new-plan` in a TTY to pick, or add `--yes` with an explicit path in CI."
     );
   }
-  const pick = await select5({
+  const pick = await select6({
     message: "Pick a story to plan:",
     pageSize: Math.min(10, candidates.length),
     choices: candidates.map((s) => ({
@@ -3540,7 +4518,7 @@ async function pickStory(stories, opts) {
       value: s.intakePath
     }))
   });
-  return candidates.find((s) => path15.resolve(s.intakePath) === path15.resolve(pick));
+  return candidates.find((s) => path19.resolve(s.intakePath) === path19.resolve(pick));
 }
 function formatLabel(s) {
   const head = `${s.feature} / ${s.id}`;
@@ -3561,7 +4539,19 @@ async function confirmOverwrite(story, interactive, yes) {
   const go = await confirm6({ message: "Proceed and regenerate?", default: false });
   return go;
 }
-async function emitViaApi(story, paths, config2, _opts) {
+function printPlannerRunIncompleteSummary(result, relPlanFile) {
+  blank();
+  warning("Planning stopped before the model reported a clean completion.");
+  kv("saved", relPlanFile, 8);
+  if (result.userCancelled) kv("stopped", "you chose not to continue after a limit", 8);
+  if (result.timedOut) kv("timed out", "yes", 8);
+  if (result.budgetExhausted) kv("read budget", "exhausted (model was asked to finalise)", 8);
+  if (result.incompleteKind) kv("detail", result.incompleteKind, 8);
+  blank();
+  info("The file uses the `.partial.md` suffix and YAML `squad-kit-plan-status: partial`.");
+  info("Raise limits in `.squad/config.yaml` (`planner.budget`, `planner.maxOutputTokens`) or re-run when ready.");
+}
+async function emitViaApi(story, paths, config2, opts) {
   const planner = config2.planner;
   if (!planner?.enabled) {
     throw new Error(
@@ -3586,6 +4576,10 @@ async function emitViaApi(story, paths, config2, _opts) {
     `${planner.budget.maxFileReads} reads \xB7 ${(planner.budget.maxContextBytes / 1024).toFixed(0)} KB \xB7 ${planner.budget.maxDurationSeconds}s`
   );
   blank();
+  const interactive = !opts.yes && Boolean(process.stdin.isTTY);
+  if (interactive) {
+    printPlannerApiCostNotice();
+  }
   const mapSpinner = spinner("building repo map\u2026");
   const repoMap = buildRepoMap(paths.root);
   mapSpinner.succeed(
@@ -3602,33 +4596,65 @@ async function emitViaApi(story, paths, config2, _opts) {
   const sessionSpinner = { current: null };
   const startedAt = Date.now();
   const cacheEnabled = planner.cache?.enabled ?? true;
-  const result = await runPlanner({
-    root: paths.root,
-    provider,
-    model,
-    apiKey,
-    systemPrompt,
-    userPrompt,
-    budget,
-    cacheEnabled,
-    onToolCall: (tc, bytes, total) => {
-      const p = tc.input.path ?? "<unknown>";
-      sessionSpinner.current?.succeed(
-        `read ${p}  (${(bytes / 1024).toFixed(1)} KB \xB7 ${(total / 1024).toFixed(1)} KB / ${(planner.budget.maxContextBytes / 1024).toFixed(0)} KB)`
-      );
-      sessionSpinner.current = spinner(`reading next file\u2026`);
-    },
-    onAssistantText: () => {
-      sessionSpinner.current?.succeed("planner thinking complete (this chunk)");
-      sessionSpinner.current = spinner("thinking\u2026");
-    },
-    onRateLimit: (waitSec) => {
-      sessionSpinner.current?.stop();
-      warning(`${planner.provider} rate limit hit \u2014 retrying in ${waitSec}s`);
-      sessionSpinner.current = spinner("waiting for rate limit to reset\u2026");
+  const runId = newRunId();
+  const bus = new PlannerEventBus();
+  const unsubscribe = bus.subscribe((e) => {
+    switch (e.kind) {
+      case "tool_call": {
+        const p = e.toolCall.input.path ?? "<unknown>";
+        sessionSpinner.current?.succeed(
+          `read ${p}  (${(e.bytesLoaded / 1024).toFixed(1)} KB \xB7 ${(e.totalBytes / 1024).toFixed(1)} KB / ${(planner.budget.maxContextBytes / 1024).toFixed(0)} KB)`
+        );
+        sessionSpinner.current = spinner("reading next file\u2026");
+        break;
+      }
+      case "assistant_text":
+        sessionSpinner.current?.succeed("planner thinking complete (this chunk)");
+        sessionSpinner.current = spinner("thinking\u2026");
+        break;
+      case "rate_limit":
+        sessionSpinner.current?.stop();
+        warning(`${planner.provider} rate limit hit \u2014 retrying in ${e.waitSec}s`);
+        sessionSpinner.current = spinner("waiting for rate limit to reset\u2026");
+        break;
+      case "usage":
+        break;
+      default:
+        break;
     }
   });
-  sessionSpinner.current?.stop();
+  const decideOnLimit = interactive ? async (ctx) => {
+    printPlannerLimitExplanation(ctx);
+    const ans = await select6({
+      message: "Continue this planning session? (Continuing sends more API requests and is billed.)",
+      choices: [
+        { name: "Continue \u2014 extend limits for this run", value: "continue" },
+        { name: "Stop \u2014 save partial plan and exit", value: "cancel" }
+      ]
+    });
+    if (ans === "cancel") printPlannerLimitNextSteps();
+    return ans;
+  } : void 0;
+  let result;
+  try {
+    result = await runPlanner({
+      root: paths.root,
+      provider,
+      model,
+      apiKey,
+      systemPrompt,
+      userPrompt,
+      budget,
+      maxOutputTokens: planner.maxOutputTokens,
+      cacheEnabled,
+      decideOnLimit,
+      events: bus,
+      runId
+    });
+  } finally {
+    unsubscribe();
+    sessionSpinner.current?.stop();
+  }
   if (!result.planText.trim()) {
     throw new Error(
       "Planner returned no plan text. Run `squad doctor` to check provider and models, or `squad new-plan --copy` to avoid the API."
@@ -3636,6 +4662,7 @@ async function emitViaApi(story, paths, config2, _opts) {
   }
   const snap = budget.snapshot();
   const elapsedMs = Date.now() - startedAt;
+  const success2 = result.finishedNormally && !result.timedOut && !result.userCancelled;
   const header = buildMetadataHeader({
     provider: planner.provider,
     model,
@@ -3644,15 +4671,18 @@ async function emitViaApi(story, paths, config2, _opts) {
     inputTokens: snap.usage.inputTokens,
     outputTokens: snap.usage.outputTokens,
     durationMs: elapsedMs,
-    costUsd: snap.usage.costUsd
+    costUsd: snap.usage.costUsd,
+    planStatus: success2 ? void 0 : "partial"
   });
   const { planFile, sequenceNumber, overwrote } = writePlanFile({
     paths,
     config: config2,
     story,
     planBodyMarkdown: result.planText,
-    metadataHeader: header
+    metadataHeader: header,
+    partial: !success2
   });
+  const relPlan = path19.relative(paths.root, planFile);
   try {
     await writeLastRun(paths, {
       stats: result.stats,
@@ -3660,11 +4690,26 @@ async function emitViaApi(story, paths, config2, _opts) {
       provider: planner.provider,
       model
     });
+    await appendRun(paths, {
+      runId,
+      provider: planner.provider,
+      model,
+      feature: story.feature,
+      storyId: story.id,
+      startedAt: new Date(startedAt).toISOString(),
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      success: success2,
+      partial: !success2,
+      planFile: relPlan,
+      stats: result.stats,
+      cacheEnabled,
+      durationMs: elapsedMs
+    });
   } catch {
   }
   blank();
-  summaryBox(" plan generated ", [
-    { key: "file", value: path15.relative(paths.root, planFile) },
+  summaryBox(success2 ? " plan generated " : " plan saved (incomplete) ", [
+    { key: "file", value: relPlan },
     { key: "nn", value: String(sequenceNumber).padStart(2, "0") },
     { key: "model", value: `${planner.provider}/${model}` },
     { key: "reads", value: `${snap.reads} files \xB7 ${(snap.bytes / 1024).toFixed(1)} KB` },
@@ -3673,29 +4718,32 @@ async function emitViaApi(story, paths, config2, _opts) {
       value: `${snap.usage.inputTokens} in \xB7 ${snap.usage.outputTokens} out${snap.usage.costUsd !== void 0 ? `  \u2248 $${snap.usage.costUsd.toFixed(2)}` : ""}`
     },
     { key: "cache", value: formatPlannerCacheLine({ cacheEnabled, stats: result.stats }) },
+    {
+      key: "max out",
+      value: `${planner.maxOutputTokens ?? DEFAULT_PLANNER_MAX_OUTPUT_TOKENS} tok/req`
+    },
     { key: "time", value: `${Math.round(elapsedMs / 1e3)}s` },
-    { key: "action", value: overwrote ? "overwrote existing plan" : "new plan" }
+    {
+      key: "action",
+      value: success2 ? overwrote ? "overwrote existing plan" : "new plan" : "partial plan (review limits)"
+    }
   ]);
-  if (result.budgetExhausted) warning("Budget exhausted mid-plan. Review and, if needed, re-run with a larger budget.");
-  if (result.timedOut) warning("Planner timed out; plan may be incomplete.");
-  if (!result.finishedNormally && !result.budgetExhausted && !result.timedOut) {
-    warning("Planner did not reach end_turn. Inspect the plan carefully.");
+  if (!success2) {
+    printPlannerRunIncompleteSummary(result, relPlan);
+    throw new SquadExit(2);
+  }
+  if (result.budgetExhausted) {
+    info("Note: file-read budget was reached; the model finalised without further reads.");
   }
   blank();
-  info(`next  \u2192  open a new agent chat and attach only ${path15.basename(planFile)}`);
+  info(`next  \u2192  open a new agent chat and attach only ${path19.basename(planFile)}`);
 }
 async function emitCopyPrompt(story, paths, config2, clipboard) {
   const intakeContent = readFile(story.intakePath);
-  const metaPromptTemplate = readBundledPrompt("generate-plan.md");
-  const composed = render(metaPromptTemplate, {
-    projectRoots: (config2.project.projectRoots ?? ["."]).join(", "),
-    primaryLanguage: config2.project.primaryLanguage ?? "",
-    trackerType: config2.tracker.type,
-    intakeContent
-  });
-  const promptFile = path15.join(paths.squadDir, ".last-copy-prompt.md");
-  fs22.writeFileSync(promptFile, composed, "utf8");
-  const relPromptFile = path15.relative(paths.root, promptFile);
+  const composed = buildCopyPlanPromptMarkdown(config2, intakeContent);
+  const promptFile = path19.join(paths.squadDir, ".last-copy-prompt.md");
+  fs26.writeFileSync(promptFile, composed, "utf8");
+  const relPromptFile = path19.relative(paths.root, promptFile);
   const bytes = Buffer.byteLength(composed, "utf8");
   const estTokens = Math.round(bytes / 4);
   const clipResult = clipboard ? await copyToClipboard(composed) : { ok: false, reason: "clipboard disabled (--no-clipboard)" };
@@ -3753,7 +4801,7 @@ function printModelBanner(config2) {
 }
 
 // src/commands/status.ts
-import fs23 from "fs";
+import fs27 from "fs";
 var kw = 28;
 function probeTrackerCredential(config2, overlay) {
   const { client, error: error2 } = clientFor(config2, overlay);
@@ -3779,7 +4827,7 @@ async function runStatus() {
   const scan = scanPlans(paths.plansDir);
   const storyCount = listStories(paths).length;
   const planCount = scan.usedNumbers.length;
-  const secrets = fs23.existsSync(paths.secretsFile) ? loadSecrets(paths.secretsFile) : {};
+  const secrets = fs27.existsSync(paths.secretsFile) ? loadSecrets(paths.secretsFile) : {};
   const overlay = overlayTrackerEnv(secrets);
   banner();
   step("squad-kit status");
@@ -3833,13 +4881,13 @@ function buildTrackerLine(config2, overlay) {
 }
 
 // src/commands/list.ts
-import path16 from "path";
+import path20 from "path";
 async function runList(opts) {
   const root = requireSquadRoot();
   const paths = buildPaths(root);
   const records = listStories(paths, { feature: opts.feature });
   const rows = records.map((r) => {
-    const planAbs = r.planFile ? path16.join(paths.plansDir, r.feature, r.planFile) : void 0;
+    const planAbs = r.planFile ? path20.join(paths.plansDir, r.feature, r.planFile) : void 0;
     const meta = planAbs ? readPlanMetadata(planAbs) : void 0;
     return {
       feature: r.feature,
@@ -3859,7 +4907,7 @@ async function runList(opts) {
     r.id,
     r.hasIntake ? "yes" : "\u2014",
     r.planFile ?? theme_exports.dim("\u2014"),
-    r.meta?.generatedBy ?? (r.planFile ? "copy-paste" : theme_exports.dim("\u2014"))
+    r.meta?.generatedBy ?? (r.planFile ? theme_exports.dim("not recorded") : theme_exports.dim("\u2014"))
   ]);
   printTable([header, ...table]);
 }
@@ -3878,9 +4926,9 @@ function stripAnsi(s) {
 }
 
 // src/commands/tracker-link.ts
-import fs24 from "fs";
-import path17 from "path";
-import { input as input4, select as select6 } from "@inquirer/prompts";
+import fs28 from "fs";
+import path21 from "path";
+import { input as input4, select as select7 } from "@inquirer/prompts";
 async function runTrackerLink(storyPath, trackerId, opts = {}) {
   const root = requireSquadRoot();
   const paths = buildPaths(root);
@@ -3897,7 +4945,7 @@ async function runTrackerLink(storyPath, trackerId, opts = {}) {
     if (stories.length === 0) {
       throw new Error("No stories found under .squad/stories/. Create one with `squad new-story` first.");
     }
-    resolvedStoryPath = await select6({
+    resolvedStoryPath = await select7({
       message: "Story to link:",
       choices: stories.map((s) => ({
         name: `${s.feature}/${s.id}`,
@@ -3926,17 +4974,17 @@ async function runTrackerLink(storyPath, trackerId, opts = {}) {
       `Invalid tracker id "${resolvedTrackerId}" for tracker type "${config2.tracker.type}". Run \`squad config show\` to review the expected format, or \`squad config set tracker\` if the type is wrong.`
     );
   }
-  const resolved = path17.resolve(resolvedStoryPath);
-  const intakeFile = resolved.endsWith("intake.md") ? resolved : path17.join(resolved, "intake.md");
-  if (!fs24.existsSync(intakeFile)) {
+  const resolved = path21.resolve(resolvedStoryPath);
+  const intakeFile = resolved.endsWith("intake.md") ? resolved : path21.join(resolved, "intake.md");
+  if (!fs28.existsSync(intakeFile)) {
     throw new Error(
       `intake.md not found at ${intakeFile}. Run \`squad list\` to see valid paths, or \`squad new-story\` to create a story first.`
     );
   }
-  const content = fs24.readFileSync(intakeFile, "utf8");
+  const content = fs28.readFileSync(intakeFile, "utf8");
   const updated = upsertTrackerId(content, resolvedTrackerId);
-  fs24.writeFileSync(intakeFile, updated, "utf8");
-  success(`Linked tracker id ${resolvedTrackerId} \u2192 ${path17.relative(root, intakeFile)}`);
+  fs28.writeFileSync(intakeFile, updated, "utf8");
+  success(`Linked tracker id ${resolvedTrackerId} \u2192 ${path21.relative(root, intakeFile)}`);
   blank();
   step("Next:");
   info("1) Review the intake \u2014 the Source block at the top now carries the tracker id.");
@@ -3953,9 +5001,9 @@ function upsertTrackerId(content, id) {
 `;
 }
 
-// src/commands/doctor.ts
-import fs25 from "fs";
-import path18 from "path";
+// src/commands/doctor-engine.ts
+import fs29 from "fs";
+import path22 from "path";
 async function gatherContext(paths) {
   const ctx = { hasLegacyPromptsDir: false };
   try {
@@ -3964,29 +5012,29 @@ async function gatherContext(paths) {
     ctx.configError = err;
   }
   try {
-    ctx.secrets = fs25.existsSync(paths.secretsFile) ? loadSecrets(paths.secretsFile) : {};
+    ctx.secrets = fs29.existsSync(paths.secretsFile) ? loadSecrets(paths.secretsFile) : {};
   } catch (err) {
     ctx.secretsError = err;
   }
-  ctx.hasLegacyPromptsDir = fs25.existsSync(paths.promptsDir);
+  ctx.hasLegacyPromptsDir = fs29.existsSync(paths.promptsDir);
   return ctx;
 }
 function gitignoreHasManagedBlock(repoRoot) {
-  const gitignore = path18.join(repoRoot, ".gitignore");
-  return fs25.existsSync(gitignore) && fs25.readFileSync(gitignore, "utf8").includes(".squad/secrets.yaml");
+  const gitignore = path22.join(repoRoot, ".gitignore");
+  return fs29.existsSync(gitignore) && fs29.readFileSync(gitignore, "utf8").includes(".squad/secrets.yaml");
 }
 function gitignoreHasTrashPattern(repoRoot) {
-  const gitignore = path18.join(repoRoot, ".gitignore");
-  return fs25.existsSync(gitignore) && fs25.readFileSync(gitignore, "utf8").includes(SQUAD_TRASH_PATTERN);
+  const gitignore = path22.join(repoRoot, ".gitignore");
+  return fs29.existsSync(gitignore) && fs29.readFileSync(gitignore, "utf8").includes(SQUAD_TRASH_PATTERN);
 }
 async function checkDirStructure(paths, _ctx, fix) {
-  const need = [paths.squadDir, paths.storiesDir, paths.plansDir].filter((p) => !fs25.existsSync(p));
+  const need = [paths.squadDir, paths.storiesDir, paths.plansDir].filter((p) => !fs29.existsSync(p));
   if (need.length === 0) {
     return { id: "dirs", name: ".squad/ directory structure", status: "ok" };
   }
   if (fix) {
     for (const p of need) {
-      fs25.mkdirSync(p, { recursive: true });
+      fs29.mkdirSync(p, { recursive: true });
     }
     return { id: "dirs", name: ".squad/ directory structure", status: "ok", detail: "repaired" };
   }
@@ -3994,7 +5042,7 @@ async function checkDirStructure(paths, _ctx, fix) {
     id: "dirs",
     name: ".squad/ directory structure",
     status: "warn",
-    detail: `missing: ${need.map((p) => path18.relative(paths.root, p)).join(", ")}`,
+    detail: `missing: ${need.map((p) => path22.relative(paths.root, p)).join(", ")}`,
     fixable: true,
     fixHint: "squad doctor --fix"
   };
@@ -4049,15 +5097,15 @@ async function checkSecretsPermissions(paths, _ctx, fix) {
   if (process.platform === "win32") {
     return { id: "secrets-perms", name: ".squad/secrets.yaml permissions", status: "skip", detail: "Windows" };
   }
-  if (!fs25.existsSync(paths.secretsFile)) {
+  if (!fs29.existsSync(paths.secretsFile)) {
     return { id: "secrets-perms", name: ".squad/secrets.yaml permissions", status: "ok", detail: "not present" };
   }
-  const mode = fs25.statSync(paths.secretsFile).mode & 511;
+  const mode = fs29.statSync(paths.secretsFile).mode & 511;
   if (mode === 384) {
     return { id: "secrets-perms", name: ".squad/secrets.yaml permissions", status: "ok" };
   }
   if (fix) {
-    fs25.chmodSync(paths.secretsFile, 384);
+    fs29.chmodSync(paths.secretsFile, 384);
     return { id: "secrets-perms", name: ".squad/secrets.yaml permissions", status: "ok", detail: "repaired" };
   }
   return {
@@ -4078,7 +5126,7 @@ async function checkSecretsParseable(_paths, ctx) {
       detail: ctx.secretsError.message
     };
   }
-  if (!fs25.existsSync(_paths.secretsFile)) {
+  if (!fs29.existsSync(_paths.secretsFile)) {
     return { id: "secrets-yaml", name: ".squad/secrets.yaml parseable", status: "ok", detail: "not present" };
   }
   return { id: "secrets-yaml", name: ".squad/secrets.yaml parseable", status: "ok" };
@@ -4460,6 +5508,8 @@ function summarise(checks) {
     skip: checks.filter((c) => c.status === "skip").length
   };
 }
+
+// src/commands/doctor.ts
 function colorForStatus(s) {
   switch (s) {
     case "ok":
@@ -4552,23 +5602,23 @@ async function runDoctor(opts) {
 }
 
 // src/commands/migrate.ts
-import fs26 from "fs";
-import path19 from "path";
+import fs30 from "fs";
+import path23 from "path";
 import { confirm as confirm7 } from "@inquirer/prompts";
 var LEGACY_PROMPTS_MIGRATION = {
   id: "legacy-prompts",
   name: "Remove legacy .squad/prompts/",
-  isApplied: (paths) => !fs26.existsSync(paths.promptsDir),
-  describe: (paths) => `delete ${path19.relative(paths.root, paths.promptsDir)} (prompts are now bundled in squad-kit)`,
+  isApplied: (paths) => !fs30.existsSync(paths.promptsDir),
+  describe: (paths) => `delete ${path23.relative(paths.root, paths.promptsDir)} (prompts are now bundled in squad-kit)`,
   apply: (paths) => {
     const target = paths.promptsDir;
-    if (!target.includes(path19.sep + ".squad" + path19.sep + "prompts")) {
+    if (!target.includes(path23.sep + ".squad" + path23.sep + "prompts")) {
       throw new Error(
         `Refusing to delete suspicious path: ${target}. This is a safety check \u2014 run \`squad doctor\` if .squad/ paths look wrong.`
       );
     }
-    if (fs26.existsSync(target)) {
-      fs26.rmSync(target, { recursive: true, force: true });
+    if (fs30.existsSync(target)) {
+      fs30.rmSync(target, { recursive: true, force: true });
     }
   }
 };
@@ -4576,8 +5626,8 @@ var GITIGNORE_MIGRATION = {
   id: "gitignore",
   name: "Ensure .gitignore managed block",
   isApplied: (paths) => {
-    const f = path19.join(paths.root, ".gitignore");
-    return fs26.existsSync(f) && fs26.readFileSync(f, "utf8").includes(".squad/secrets.yaml");
+    const f = path23.join(paths.root, ".gitignore");
+    return fs30.existsSync(f) && fs30.readFileSync(f, "utf8").includes(".squad/secrets.yaml");
   },
   describe: () => "add squad-kit managed block to .gitignore",
   apply: (paths) => {
@@ -4589,23 +5639,23 @@ var SECRETS_PERMS_MIGRATION = {
   name: "Tighten .squad/secrets.yaml permissions",
   isApplied: (paths) => {
     if (process.platform === "win32") return true;
-    if (!fs26.existsSync(paths.secretsFile)) return true;
-    const st = fs26.statSync(paths.secretsFile);
+    if (!fs30.existsSync(paths.secretsFile)) return true;
+    const st = fs30.statSync(paths.secretsFile);
     return (st.mode & 511) === 384;
   },
-  describe: (paths) => `chmod 0600 ${path19.relative(paths.root, paths.secretsFile)}`,
+  describe: (paths) => `chmod 0600 ${path23.relative(paths.root, paths.secretsFile)}`,
   apply: (paths) => {
     if (process.platform === "win32") return;
-    if (fs26.existsSync(paths.secretsFile)) fs26.chmodSync(paths.secretsFile, 384);
+    if (fs30.existsSync(paths.secretsFile)) fs30.chmodSync(paths.secretsFile, 384);
   }
 };
 var PLANNER_BUDGET_DEFAULTS_MIGRATION = {
   id: "planner-budget-defaults",
   name: "Backfill planner.budget defaults in config.yaml",
   isApplied: (paths) => {
-    if (!fs26.existsSync(paths.configFile)) return true;
+    if (!fs30.existsSync(paths.configFile)) return true;
     try {
-      const raw = fs26.readFileSync(paths.configFile, "utf8");
+      const raw = fs30.readFileSync(paths.configFile, "utf8");
       if (!/^\s*planner:/m.test(raw)) return true;
       if (/^\s*budget:/m.test(raw)) return true;
       const cfg = loadConfig(paths.configFile);
@@ -4624,9 +5674,9 @@ var CONFIG_NORMALIZE_MIGRATION = {
   id: "config-normalize",
   name: "Normalise .squad/config.yaml formatting",
   isApplied: (paths) => {
-    if (!fs26.existsSync(paths.configFile)) return true;
+    if (!fs30.existsSync(paths.configFile)) return true;
     try {
-      const raw = fs26.readFileSync(paths.configFile, "utf8");
+      const raw = fs30.readFileSync(paths.configFile, "utf8");
       const cfg = loadConfig(paths.configFile);
       return raw.trim() === serializeConfig(cfg).trim();
     } catch {
@@ -4635,7 +5685,7 @@ var CONFIG_NORMALIZE_MIGRATION = {
   },
   describe: () => "rewrite config.yaml with canonical YAML formatting (drops comments)",
   apply: (paths) => {
-    if (!fs26.existsSync(paths.configFile)) return;
+    if (!fs30.existsSync(paths.configFile)) return;
     const cfg = loadConfig(paths.configFile);
     saveConfig(paths.configFile, cfg);
   }
@@ -4716,8 +5766,8 @@ import process3 from "process";
 import { confirm as confirm8 } from "@inquirer/prompts";
 
 // src/core/package-info.ts
-import fs27 from "fs";
-import path20 from "path";
+import fs31 from "fs";
+import path24 from "path";
 function changelogBlobUrl(repositoryUrl, version) {
   let base = repositoryUrl;
   if (!base) base = "https://github.com/AzmSquad/squad-kit";
@@ -4728,9 +5778,9 @@ function changelogBlobUrl(repositoryUrl, version) {
 }
 function readInstalledPackage() {
   const root = packageRoot();
-  const pkgFile = path20.join(root, "package.json");
-  const pkg = JSON.parse(fs27.readFileSync(pkgFile, "utf8"));
-  const isDevInstall = fs27.existsSync(path20.join(root, "src"));
+  const pkgFile = path24.join(root, "package.json");
+  const pkg = JSON.parse(fs31.readFileSync(pkgFile, "utf8"));
+  const isDevInstall = fs31.existsSync(path24.join(root, "src"));
   return {
     name: pkg.name,
     version: pkg.version,
@@ -4770,7 +5820,7 @@ function isNewer(a, b) {
 }
 
 // src/core/package-manager.ts
-import path21 from "path";
+import path25 from "path";
 import process2 from "process";
 function detectPackageManager(installRoot) {
   const ua = process2.env.npm_config_user_agent;
@@ -4781,11 +5831,11 @@ function detectPackageManager(installRoot) {
     if (ua.startsWith("npm/")) return { pm: "npm", reason: "npm_config_user_agent" };
   }
   const root = installRoot.toLowerCase();
-  if (root.includes(`${path21.sep}pnpm${path21.sep}`) || root.includes(`${path21.sep}.pnpm${path21.sep}`))
+  if (root.includes(`${path25.sep}pnpm${path25.sep}`) || root.includes(`${path25.sep}.pnpm${path25.sep}`))
     return { pm: "pnpm", reason: `install path contains pnpm` };
-  if (root.includes(`${path21.sep}.yarn${path21.sep}`) || root.includes(`${path21.sep}yarn${path21.sep}`))
+  if (root.includes(`${path25.sep}.yarn${path25.sep}`) || root.includes(`${path25.sep}yarn${path25.sep}`))
     return { pm: "yarn", reason: `install path contains yarn` };
-  if (root.includes(`${path21.sep}.bun${path21.sep}`) || root.includes(`${path21.sep}bun${path21.sep}`))
+  if (root.includes(`${path25.sep}.bun${path25.sep}`) || root.includes(`${path25.sep}bun${path25.sep}`))
     return { pm: "bun", reason: `install path contains bun` };
   return { pm: "npm", reason: "default fallback" };
 }
@@ -4850,244 +5900,1069 @@ async function runUpgrade(opts) {
     info(`Run to upgrade: ${cmd} ${args.join(" ")}`);
     return;
   }
-  if (!opts.yes) {
-    const interactive = Boolean(process3.stdin.isTTY) && process3.env.CI !== "true";
-    if (!interactive) {
-      failure(
-        `Refusing to run a global install without --yes. Run \`squad upgrade --yes\` in non-interactive mode, or run manually: ${cmd} ${args.join(" ")}`
-      );
-      process3.exit(1);
+  if (!opts.yes) {
+    const interactive = Boolean(process3.stdin.isTTY) && process3.env.CI !== "true";
+    if (!interactive) {
+      failure(
+        `Refusing to run a global install without --yes. Run \`squad upgrade --yes\` in non-interactive mode, or run manually: ${cmd} ${args.join(" ")}`
+      );
+      process3.exit(1);
+    }
+    const go = await confirm8({ message: `Run "${cmd} ${args.join(" ")}"?`, default: true });
+    if (!go) {
+      info("Cancelled. No changes applied.");
+      return;
+    }
+  }
+  blank();
+  info(`Running: ${cmd} ${args.join(" ")}`);
+  const exitCode = await spawnInherit(cmd, args);
+  if (exitCode !== 0) {
+    failure(
+      `${cmd} exited with code ${exitCode}. Upgrade may be incomplete \u2014 run \`squad doctor\` and re-run \`squad upgrade\` if needed.`
+    );
+    process3.exit(exitCode);
+  }
+  blank();
+  success(`Upgraded to ${latest}.`);
+  info("Run `squad migrate` to update your .squad/ structure if needed.");
+}
+function spawnInherit(cmd, args) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn2(cmd, args, { stdio: "inherit", shell: process3.platform === "win32" });
+    child.on("exit", (code) => resolve2(code ?? 0));
+    child.on("error", (err) => reject(err));
+  });
+}
+
+// src/commands/console.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { resolve } from "path";
+import open from "open";
+
+// src/console/server.ts
+import { createServer } from "net";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { secureHeaders } from "hono/secure-headers";
+
+// src/console/api/stories.ts
+import fs32 from "fs";
+import { z } from "zod";
+
+// src/utils/path-safety.ts
+import path26 from "path";
+function isInside(abs, parent) {
+  const a = path26.resolve(abs) + path26.sep;
+  const p = path26.resolve(parent) + path26.sep;
+  return a.startsWith(p);
+}
+
+// src/console/api/stories.ts
+var CreateBody = z.object({
+  feature: z.string().min(1).max(80),
+  title: z.string().max(200).optional(),
+  trackerId: z.string().max(80).optional()
+});
+var PatchBody = z.object({
+  intakeContent: z.string().min(1).max(1e6)
+});
+function safeFeatureParam(feature) {
+  return feature.length > 0 && !feature.includes("/") && !feature.includes("..") && slugify(feature) === feature;
+}
+function mountStoriesApi(app, opts) {
+  app.get("/api/stories", (c) => {
+    const feature = c.req.query("feature") ?? void 0;
+    const stories = listStories(opts.paths, { feature });
+    return c.json(
+      stories.map((s) => ({
+        feature: s.feature,
+        id: s.id,
+        intakePath: s.intakePath,
+        storyDir: s.storyDir,
+        planFile: s.planFile ?? null,
+        titleHint: s.titleHint ?? null
+      }))
+    );
+  });
+  app.get("/api/stories/:feature/:id", (c) => {
+    const { feature, id } = c.req.param();
+    if (!safeFeatureParam(feature)) return c.json({ error: "forbidden" }, 403);
+    const stories = listStories(opts.paths, { feature });
+    const hit = stories.find((s) => s.id === id);
+    if (!hit) return c.json({ error: "not_found" }, 404);
+    if (!isInside(hit.intakePath, opts.paths.storiesDir)) return c.json({ error: "forbidden" }, 403);
+    let intakeContent = "";
+    try {
+      intakeContent = fs32.readFileSync(hit.intakePath, "utf8");
+    } catch {
+    }
+    return c.json({
+      feature: hit.feature,
+      id: hit.id,
+      intakePath: hit.intakePath,
+      storyDir: hit.storyDir,
+      planFile: hit.planFile ?? null,
+      titleHint: hit.titleHint ?? null,
+      intakeContent
+    });
+  });
+  app.post("/api/stories", async (c) => {
+    const body = CreateBody.safeParse(await c.req.json());
+    if (!body.success) return c.json({ error: "invalid_body", issues: body.error.issues }, 400);
+    const cfg = loadConfig(opts.paths.configFile);
+    let created;
+    try {
+      created = createStoryRecord({
+        paths: opts.paths,
+        config: cfg,
+        feature: body.data.feature,
+        title: body.data.title,
+        trackerId: body.data.trackerId
+      });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (/already exists|Intake already exists/.test(msg)) {
+        return c.json({ error: "conflict", message: msg }, 409);
+      }
+      return c.json({ error: "invalid_request", message: msg }, 400);
+    }
+    return c.json(created, 201);
+  });
+  app.patch("/api/stories/:feature/:id", async (c) => {
+    const body = PatchBody.safeParse(await c.req.json());
+    if (!body.success) return c.json({ error: "invalid_body", issues: body.error.issues }, 400);
+    const { feature, id } = c.req.param();
+    if (!safeFeatureParam(feature)) return c.json({ error: "forbidden" }, 403);
+    const stories = listStories(opts.paths, { feature });
+    const hit = stories.find((s) => s.id === id);
+    if (!hit) return c.json({ error: "not_found" }, 404);
+    if (!isInside(hit.intakePath, opts.paths.storiesDir)) return c.json({ error: "forbidden" }, 403);
+    fs32.writeFileSync(hit.intakePath, body.data.intakeContent, "utf8");
+    return c.json({ ok: true });
+  });
+  app.delete("/api/stories/:feature/:id", (c) => {
+    const trash = c.req.query("trash") === "1";
+    const { feature, id } = c.req.param();
+    if (!safeFeatureParam(feature)) return c.json({ error: "forbidden" }, 403);
+    const stories = listStories(opts.paths, { feature });
+    const hit = stories.find((s) => s.id === id);
+    if (!hit) return c.json({ error: "not_found" }, 404);
+    if (!isInside(hit.storyDir, opts.paths.storiesDir)) return c.json({ error: "forbidden" }, 403);
+    const result = deleteStoryRecord({ paths: opts.paths, story: hit, trash });
+    return c.json(result);
+  });
+}
+
+// src/console/api/plans.ts
+import fs33 from "fs";
+import path27 from "path";
+import { z as z2 } from "zod";
+import { diffLines } from "diff";
+var DiffQuery = z2.object({
+  feature: z2.string().min(1).max(80),
+  a: z2.string().min(1).max(200),
+  b: z2.string().min(1).max(200)
+});
+function safeFeatureParam2(feature) {
+  return feature.length > 0 && !feature.includes("/") && !feature.includes("..") && slugify(feature) === feature;
+}
+function mountPlansApi(app, opts) {
+  app.get("/api/plans", (c) => {
+    const out = [];
+    for (const feature of listPlanFeatureNames(opts.paths)) {
+      const featureDir = path27.join(opts.paths.plansDir, feature);
+      if (!fs33.existsSync(featureDir)) continue;
+      for (const entry of fs33.readdirSync(featureDir)) {
+        if (!entry.endsWith(".md") || entry === "00-index.md") continue;
+        const abs = path27.join(featureDir, entry);
+        out.push({ feature, planFile: entry, metadata: readPlanMetadata(abs) });
+      }
+    }
+    return c.json(out);
+  });
+  app.get("/api/plans/:feature/:planFile", (c) => {
+    const { feature, planFile } = c.req.param();
+    if (!safeFeatureParam2(feature)) return c.json({ error: "forbidden" }, 403);
+    const abs = path27.resolve(path27.join(opts.paths.plansDir, feature, planFile));
+    if (!isInside(abs, opts.paths.plansDir)) return c.json({ error: "forbidden" }, 403);
+    if (!fs33.existsSync(abs)) return c.json({ error: "not_found" }, 404);
+    const content = fs33.readFileSync(abs, "utf8");
+    return c.json({
+      feature,
+      planFile,
+      content,
+      absPath: abs,
+      metadata: readPlanMetadata(abs)
+    });
+  });
+  app.get("/api/plans/diff", (c) => {
+    const parse = DiffQuery.safeParse({
+      feature: c.req.query("feature"),
+      a: c.req.query("a"),
+      b: c.req.query("b")
+    });
+    if (!parse.success) return c.json({ error: "invalid_query", issues: parse.error.issues }, 400);
+    const { feature, a, b } = parse.data;
+    if (!safeFeatureParam2(feature)) return c.json({ error: "forbidden" }, 403);
+    const featureDir = path27.join(opts.paths.plansDir, feature);
+    const aAbs = path27.join(featureDir, a);
+    const bAbs = path27.join(featureDir, b);
+    if (!isInside(aAbs, opts.paths.plansDir) || !isInside(bAbs, opts.paths.plansDir)) {
+      return c.json({ error: "forbidden" }, 403);
+    }
+    if (!fs33.existsSync(aAbs) || !fs33.existsSync(bAbs)) return c.json({ error: "not_found" }, 404);
+    const aText = fs33.readFileSync(aAbs, "utf8");
+    const bText = fs33.readFileSync(bAbs, "utf8");
+    const changes = diffLines(aText, bText);
+    return c.json({ feature, a, b, changes });
+  });
+  app.delete("/api/plans/:feature/:planFile", (c) => {
+    const trash = c.req.query("trash") === "1";
+    const { feature, planFile } = c.req.param();
+    if (!safeFeatureParam2(feature)) return c.json({ error: "forbidden" }, 403);
+    const abs = path27.join(opts.paths.plansDir, feature, planFile);
+    if (!isInside(abs, opts.paths.plansDir)) return c.json({ error: "forbidden" }, 403);
+    if (!fs33.existsSync(abs)) return c.json({ error: "not_found" }, 404);
+    if (trash) {
+      const result = trashOrDelete([abs], opts.paths.trashDir, true);
+      removeOverviewRowForPlanFile(path27.join(opts.paths.plansDir, feature), planFile);
+      return c.json({ ok: true, trashed: result.trashed });
+    }
+    fs33.rmSync(abs);
+    removeOverviewRowForPlanFile(path27.join(opts.paths.plansDir, feature), planFile);
+    return c.json({ ok: true });
+  });
+}
+
+// src/console/api/config.ts
+import { z as z3 } from "zod";
+var ConfigBody = z3.object({}).passthrough();
+function mountConfigApi(app, opts) {
+  app.get("/api/config", (c) => {
+    const config2 = loadConfig(opts.paths.configFile);
+    return c.json(config2);
+  });
+  app.put("/api/config", async (c) => {
+    const body = ConfigBody.safeParse(await c.req.json());
+    if (!body.success) return c.json({ error: "invalid_body", issues: body.error.issues }, 400);
+    try {
+      saveConfig(opts.paths.configFile, body.data);
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ error: "invalid_config", detail: err.message }, 400);
+    }
+  });
+}
+
+// src/console/api/meta.ts
+function mountMetaApi(app, opts) {
+  app.get("/api/meta", async (c) => {
+    const config2 = loadConfig(opts.paths.configFile);
+    const lastRun = await readLastRun(opts.paths);
+    return c.json({
+      version: "0.6.0",
+      root: opts.paths.root,
+      project: config2.project,
+      planner: config2.planner ? { provider: config2.planner.provider, enabled: config2.planner.enabled } : null,
+      tracker: { type: config2.tracker.type },
+      lastRun
+    });
+  });
+  app.get("/api/last-run", async (c) => {
+    const lastRun = await readLastRun(opts.paths);
+    return c.json(lastRun ?? null);
+  });
+}
+
+// src/console/api/runs.ts
+import { streamSSE } from "hono/streaming";
+import { z as z4 } from "zod";
+import path28 from "path";
+import fs34 from "fs";
+var active = /* @__PURE__ */ new Map();
+var EVENT_BUF_CAP = 512;
+var StartBody = z4.object({
+  feature: z4.string().min(1),
+  storyId: z4.string().min(1)
+});
+function emptyStats(durationMs) {
+  return {
+    turns: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
+    cacheHitRatio: 0,
+    durationMs
+  };
+}
+function mountRunsApi(app, opts) {
+  app.get("/api/runs", async (c) => c.json(await listRuns(opts.paths)));
+  app.get("/api/runs/active", (c) => {
+    const rows = [...active.values()].map((r) => ({
+      runId: r.runId,
+      feature: r.feature,
+      storyId: r.storyId,
+      startedAt: r.startedAt
+    }));
+    return c.json(rows);
+  });
+  app.post("/api/runs", async (c) => {
+    const body = StartBody.safeParse(await c.req.json());
+    if (!body.success) return c.json({ error: "invalid_body", issues: body.error.issues }, 400);
+    const cfg = loadConfig(opts.paths.configFile);
+    if (!cfg.planner?.enabled) {
+      return c.json({ error: "planner_disabled", detail: "Run `squad config set planner` first." }, 400);
+    }
+    const apiKey = readProviderKeyForPaths(opts.paths, cfg.planner.provider);
+    if (!apiKey) {
+      return c.json(
+        {
+          error: "missing_credentials",
+          detail: `Set ${providerEnvVar(cfg.planner.provider)} or save a key via the Secrets tab.`
+        },
+        400
+      );
+    }
+    const stories = listStories(opts.paths, { feature: body.data.feature });
+    const story = stories.find((s) => s.id === body.data.storyId);
+    if (!story) return c.json({ error: "not_found" }, 404);
+    const runId = newRunId();
+    const eventBuffer = [];
+    const bus = new PlannerEventBus();
+    bus.subscribe((e) => {
+      eventBuffer.push(e);
+      if (eventBuffer.length > EVENT_BUF_CAP) eventBuffer.splice(0, eventBuffer.length - EVENT_BUF_CAP);
+    });
+    const controller = new AbortController();
+    const startedAt = Date.now();
+    const done = (async () => {
+      const cfgFresh = loadConfig(opts.paths.configFile);
+      const planner = cfgFresh.planner;
+      const provider = providerFor(planner.provider);
+      const model = modelFor(planner.provider, "plan", planner.modelOverride);
+      const budget = new Budget(planner.budget);
+      const cacheEnabled = planner.cache?.enabled ?? true;
+      const repoMap = buildRepoMap(opts.paths.root);
+      const systemPrompt = composeSystemPrompt({
+        projectRoots: cfgFresh.project.projectRoots ?? ["."],
+        primaryLanguage: cfgFresh.project.primaryLanguage ?? "",
+        trackerType: cfgFresh.tracker.type,
+        repoMap
+      });
+      const userPrompt = composeUserPrompt({
+        intakeContent: fs34.readFileSync(story.intakePath, "utf8")
+      });
+      let result;
+      try {
+        result = await runPlanner({
+          root: opts.paths.root,
+          provider,
+          model,
+          apiKey,
+          systemPrompt,
+          userPrompt,
+          budget,
+          maxOutputTokens: planner.maxOutputTokens,
+          cacheEnabled,
+          events: bus,
+          runId,
+          abort: controller.signal
+        });
+      } catch (err) {
+        const durationMs = Date.now() - startedAt;
+        bus.emit({ kind: "error", runId, message: err.message });
+        bus.emit({
+          kind: "done",
+          runId,
+          success: false,
+          planFile: null,
+          partial: true,
+          stats: emptyStats(durationMs),
+          durationMs
+        });
+        return;
+      }
+      const runSuccess = result.finishedNormally && !result.timedOut && !result.userCancelled;
+      let planFile = null;
+      if (result.planText.trim()) {
+        const snap = budget.snapshot();
+        const header = buildMetadataHeader({
+          provider: planner.provider,
+          model,
+          reads: snap.reads,
+          bytes: snap.bytes,
+          inputTokens: snap.usage.inputTokens,
+          outputTokens: snap.usage.outputTokens,
+          durationMs: Date.now() - startedAt,
+          costUsd: snap.usage.costUsd,
+          planStatus: runSuccess ? void 0 : "partial"
+        });
+        const out = writePlanFile({
+          paths: opts.paths,
+          config: cfgFresh,
+          story,
+          planBodyMarkdown: result.planText,
+          metadataHeader: header,
+          partial: !runSuccess
+        });
+        planFile = path28.relative(opts.paths.root, out.planFile);
+      }
+      try {
+        await writeLastRun(opts.paths, {
+          stats: result.stats,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          provider: planner.provider,
+          model
+        });
+        await appendRun(opts.paths, {
+          runId,
+          provider: planner.provider,
+          model,
+          feature: story.feature,
+          storyId: story.id,
+          startedAt: new Date(startedAt).toISOString(),
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          success: runSuccess,
+          partial: !runSuccess,
+          planFile,
+          stats: result.stats,
+          cacheEnabled,
+          durationMs: Date.now() - startedAt
+        });
+      } catch {
+      }
+      bus.emit({
+        kind: "done",
+        runId,
+        success: runSuccess,
+        planFile,
+        partial: !runSuccess,
+        stats: result.stats,
+        durationMs: Date.now() - startedAt
+      });
+    })().finally(() => {
+      active.delete(runId);
+    });
+    active.set(runId, { runId, bus, controller, feature: story.feature, storyId: story.id, startedAt, done, eventBuffer });
+    return c.json({ runId, eventStream: `/api/runs/${runId}/stream` }, 202);
+  });
+  app.get("/api/runs/:runId/stream", (c) => {
+    const runId = c.req.param("runId");
+    const run = active.get(runId);
+    return streamSSE(c, async (stream) => {
+      if (!run) {
+        await stream.writeSSE({ event: "error", data: JSON.stringify({ message: "unknown run" }) });
+        await stream.writeSSE({ event: "closed", data: "{}" });
+        return;
+      }
+      let idx = 0;
+      let resolveWaiter = null;
+      const notify = () => resolveWaiter?.();
+      const unsubscribe = run.bus.subscribe(() => notify());
+      const ka = setInterval(() => stream.writeSSE({ event: "ping", data: "{}" }).catch(() => {
+      }), 15e3);
+      let closed = false;
+      stream.onAbort(() => {
+        closed = true;
+        unsubscribe();
+        clearInterval(ka);
+      });
+      try {
+        while (!closed) {
+          while (idx < run.eventBuffer.length) {
+            const e = run.eventBuffer[idx++];
+            await stream.writeSSE({ event: e.kind, data: JSON.stringify(e) });
+            if (e.kind === "done") {
+              await stream.writeSSE({ event: "closed", data: JSON.stringify({ ok: true }) });
+              clearInterval(ka);
+              unsubscribe();
+              return;
+            }
+          }
+          await new Promise((resolve2) => {
+            resolveWaiter = resolve2;
+          });
+          resolveWaiter = null;
+        }
+      } finally {
+        clearInterval(ka);
+        unsubscribe();
+      }
+    });
+  });
+  app.delete("/api/runs/:runId", (c) => {
+    const runId = c.req.param("runId");
+    const run = active.get(runId);
+    if (!run) return c.json({ error: "not_found" }, 404);
+    run.controller.abort();
+    return c.json({ ok: true });
+  });
+}
+
+// src/console/api/secrets.ts
+import { z as z5 } from "zod";
+
+// src/core/mask-token.ts
+function maskToken(t) {
+  if (!t) return null;
+  if (t.length <= 8) return "\u2022\u2022\u2022\u2022" + t.slice(-2);
+  return t.slice(0, 4) + "\u2026" + t.slice(-4);
+}
+
+// src/console/api/secrets.ts
+var PROVIDERS = ["anthropic", "openai", "google"];
+function mountSecretsApi(app, opts) {
+  app.get("/api/secrets", (c) => {
+    const s = loadSecrets(opts.paths.secretsFile);
+    return c.json({
+      planner: {
+        anthropic: maskToken(s.planner?.anthropic),
+        openai: maskToken(s.planner?.openai),
+        google: maskToken(s.planner?.google)
+      },
+      tracker: {
+        jira: {
+          host: s.tracker?.jira?.host ?? null,
+          email: s.tracker?.jira?.email ?? null,
+          token: maskToken(s.tracker?.jira?.token)
+        },
+        azure: {
+          organization: s.tracker?.azure?.organization ?? null,
+          project: s.tracker?.azure?.project ?? null,
+          pat: maskToken(s.tracker?.azure?.pat)
+        }
+      }
+    });
+  });
+  const PutBody = z5.object({
+    planner: z5.object({
+      anthropic: z5.string().optional(),
+      openai: z5.string().optional(),
+      google: z5.string().optional()
+    }).optional(),
+    tracker: z5.object({
+      jira: z5.object({
+        host: z5.string().optional(),
+        email: z5.string().optional(),
+        token: z5.string().optional()
+      }).optional(),
+      azure: z5.object({
+        organization: z5.string().optional(),
+        project: z5.string().optional(),
+        pat: z5.string().optional()
+      }).optional()
+    }).optional()
+  });
+  app.put("/api/secrets", async (c) => {
+    const parse = PutBody.safeParse(await c.req.json());
+    if (!parse.success) return c.json({ error: "invalid_body", issues: parse.error.issues }, 400);
+    const current = loadSecrets(opts.paths.secretsFile);
+    const merged = mergeSecrets(current, parse.data);
+    saveSecrets(opts.paths.secretsFile, merged);
+    return c.json({ ok: true });
+  });
+  for (const p of PROVIDERS) {
+    app.post(`/api/secrets/test/${p}`, async (c) => {
+      const s = loadSecrets(opts.paths.secretsFile);
+      const key = s.planner?.[p];
+      if (!key) return c.json({ ok: false, detail: `${p} key not saved` }, 400);
+      const result = await fetchProviderModelIds(p, key);
+      if (result.ok) return c.json({ ok: true, modelCount: result.ids.size });
+      return c.json({ ok: false, status: result.status, detail: result.body.slice(0, 200) }, 200);
+    });
+  }
+  app.post("/api/secrets/test/jira", async (c) => {
+    const cfg = loadConfig(opts.paths.configFile);
+    const s = loadSecrets(opts.paths.secretsFile);
+    return c.json(await probeJiraConnectivity(s, cfg));
+  });
+  app.post("/api/secrets/test/azure", async (c) => {
+    const cfg = loadConfig(opts.paths.configFile);
+    const s = loadSecrets(opts.paths.secretsFile);
+    return c.json(await probeAzureConnectivity(s, cfg));
+  });
+}
+
+// src/console/api/tracker.ts
+import { z as z6 } from "zod";
+var SearchQuery = z6.object({ q: z6.string().max(500) });
+var ImportBody = z6.object({
+  issueId: z6.string().min(1),
+  feature: z6.string().min(1).max(80),
+  withAttachments: z6.boolean().optional()
+});
+function mountTrackerApi(app, opts) {
+  app.get("/api/tracker/search", async (c) => {
+    const q = SearchQuery.safeParse({ q: c.req.query("q") });
+    if (!q.success) return c.json({ error: "invalid_query" }, 400);
+    const cfg = loadConfig(opts.paths.configFile);
+    const secrets = overlayTrackerEnv(loadSecrets(opts.paths.secretsFile));
+    const { client, error: error2 } = clientFor(cfg, secrets);
+    if (!client) {
+      return c.json({ error: error2?.kind ?? "unsupported", detail: error2?.detail ?? "" }, 400);
     }
-    const go = await confirm8({ message: `Run "${cmd} ${args.join(" ")}"?`, default: true });
-    if (!go) {
-      info("Cancelled. No changes applied.");
-      return;
+    try {
+      const results = await client.searchIssues(q.data.q);
+      return c.json({ ok: true, results });
+    } catch (err) {
+      if (err instanceof TrackerError) {
+        return c.json({ ok: false, kind: err.kind, status: err.statusCode, detail: err.message }, 200);
+      }
+      return c.json({ ok: false, detail: err.message }, 200);
     }
-  }
-  blank();
-  info(`Running: ${cmd} ${args.join(" ")}`);
-  const exitCode = await spawnInherit(cmd, args);
-  if (exitCode !== 0) {
-    failure(
-      `${cmd} exited with code ${exitCode}. Upgrade may be incomplete \u2014 run \`squad doctor\` and re-run \`squad upgrade\` if needed.`
-    );
-    process3.exit(exitCode);
-  }
-  blank();
-  success(`Upgraded to ${latest}.`);
-  info("Run `squad migrate` to update your .squad/ structure if needed.");
+  });
+  app.post("/api/tracker/import", async (c) => {
+    const body = ImportBody.safeParse(await c.req.json());
+    if (!body.success) return c.json({ error: "invalid_body", issues: body.error.issues }, 400);
+    const cfg = loadConfig(opts.paths.configFile);
+    const secrets = overlayTrackerEnv(loadSecrets(opts.paths.secretsFile));
+    const { client, error: error2 } = clientFor(cfg, secrets);
+    if (!client) {
+      return c.json({ error: error2?.kind ?? "unsupported", detail: error2?.detail ?? "" }, 400);
+    }
+    try {
+      const issue = await client.fetchIssue(body.data.issueId);
+      const created = await createStoryRecordFromIssue({
+        paths: opts.paths,
+        feature: body.data.feature,
+        issue,
+        withAttachments: body.data.withAttachments ?? true,
+        client,
+        config: cfg
+      });
+      return c.json(created, 201);
+    } catch (err) {
+      if (err instanceof TrackerError) return c.json({ error: err.kind, detail: err.message }, 502);
+      return c.json({ error: "fetch_failed", detail: err.message }, 500);
+    }
+  });
 }
-function spawnInherit(cmd, args) {
-  return new Promise((resolve, reject) => {
-    const child = spawn2(cmd, args, { stdio: "inherit", shell: process3.platform === "win32" });
-    child.on("exit", (code) => resolve(code ?? 0));
-    child.on("error", (err) => reject(err));
+
+// src/commands/doctor-api.ts
+async function gatherContextForApi(paths) {
+  return gatherContext(paths);
+}
+async function runAllChecksForApi(paths, ctx, fix) {
+  return runAllChecks(paths, ctx, fix);
+}
+
+// src/console/api/doctor.ts
+function mountDoctorApi(app, opts) {
+  app.get("/api/doctor", async (c) => {
+    const ctx = await gatherContextForApi(opts.paths);
+    const checks = await runAllChecksForApi(opts.paths, ctx, false);
+    return c.json({ root: opts.paths.root, checks, summary: summarise(checks) });
+  });
+  app.post("/api/doctor/fix", async (c) => {
+    const ctx = await gatherContextForApi(opts.paths);
+    const checks = await runAllChecksForApi(opts.paths, ctx, true);
+    return c.json({ root: opts.paths.root, checks, summary: summarise(checks) });
   });
 }
 
-// src/commands/rm/shared.ts
-import fs28 from "fs";
-import path22 from "path";
-import { select as select7 } from "@inquirer/prompts";
-var STORY_PLAN = /^(\d{2,})-story-.+\.md$/;
-function canPromptForRm(opts) {
-  if (opts.yes) return false;
-  return isInteractive() && Boolean(process.stdin.isTTY);
+// src/console/api/copy-plan-prompt.ts
+function mountCopyPlanPromptApi(app, opts) {
+  app.get("/api/copy-plan-prompt", (c) => {
+    const feature = (c.req.query("feature") ?? "").trim();
+    const storyId = (c.req.query("storyId") ?? "").trim();
+    if (!feature || !storyId) {
+      return c.json({ error: "bad_request", detail: "Query params `feature` and `storyId` are required." }, 400);
+    }
+    const stories = listStories(opts.paths, { feature });
+    const hit = stories.find((s) => s.feature === feature && s.id === storyId);
+    if (!hit) {
+      return c.json({ error: "not_found", detail: `No story intake for feature "${feature}" and id "${storyId}".` }, 404);
+    }
+    const config2 = loadConfig(opts.paths.configFile);
+    const intakeContent = readFile(hit.intakePath);
+    const prompt = buildCopyPlanPromptMarkdown(config2, intakeContent);
+    const bytes = Buffer.byteLength(prompt, "utf8");
+    return c.json({
+      prompt,
+      feature: hit.feature,
+      storyId: hit.id,
+      bytes,
+      estTokensApprox: Math.round(bytes / 4)
+    });
+  });
 }
-function removeOverviewRow(featurePlanDir, storyId) {
-  const overview = path22.join(featurePlanDir, "00-overview.md");
-  if (!fs28.existsSync(overview)) return;
-  const src = fs28.readFileSync(overview, "utf8");
-  const lines = src.split("\n");
-  const filtered = lines.filter((line2) => {
-    if (!line2.startsWith("|")) return true;
-    if (line2.includes("NN") && line2.includes("File") && line2.includes("Title")) return true;
-    if (/^\|\s*-+/.test(line2)) return true;
-    return !line2.includes(storyId);
+
+// src/console/api/dashboard.ts
+function mountDashboardApi(app, opts) {
+  app.get("/api/dashboard", async (c) => {
+    const cfg = loadConfig(opts.paths.configFile);
+    const lastRun = await readLastRun(opts.paths) ?? null;
+    const runs = await listRuns(opts.paths);
+    const stories = listStories(opts.paths);
+    return c.json({
+      version: "0.6.0",
+      root: opts.paths.root,
+      project: cfg.project,
+      planner: cfg.planner ? { provider: cfg.planner.provider, enabled: cfg.planner.enabled } : null,
+      tracker: { type: cfg.tracker.type },
+      lastRun,
+      runs: runs.map((r) => ({
+        runId: r.runId,
+        startedAt: r.startedAt,
+        durationMs: r.durationMs,
+        success: r.success,
+        partial: r.partial,
+        inputTokens: r.stats.inputTokens,
+        outputTokens: r.stats.outputTokens,
+        cacheHitRatio: r.stats.cacheHitRatio
+      })),
+      storyCounts: countStories(stories),
+      stories: stories.map((s) => ({
+        feature: s.feature,
+        id: s.id,
+        intakePath: s.intakePath,
+        storyDir: s.storyDir,
+        planFile: s.planFile ?? null,
+        titleHint: s.titleHint ?? null
+      }))
+    });
   });
-  fs28.writeFileSync(overview, filtered.join("\n"), "utf8");
 }
-function removeOverviewRowForPlanFile(featurePlanDir, planBasename) {
-  const overview = path22.join(featurePlanDir, "00-overview.md");
-  if (!fs28.existsSync(overview)) return;
-  const src = fs28.readFileSync(overview, "utf8");
-  const token = `\`${planBasename}\``;
-  const lines = src.split("\n");
-  const filtered = lines.filter((line2) => {
-    if (!line2.startsWith("|")) return true;
-    if (line2.includes("NN") && line2.includes("File") && line2.includes("Title")) return true;
-    if (/^\|\s*-+/.test(line2)) return true;
-    return !line2.includes(token);
+function countStories(stories) {
+  const total = stories.length;
+  const planned = stories.filter((s) => !!s.planFile).length;
+  return { total, planned, unplanned: total - planned };
+}
+
+// src/console/api/projects.ts
+import fs35 from "fs/promises";
+import path29 from "path";
+import os from "os";
+var MAX = 10;
+function recentFilePath() {
+  return path29.join(os.homedir(), ".squad", "recent-projects.json");
+}
+async function loadRecent() {
+  const RECENT_FILE = recentFilePath();
+  try {
+    const raw = await fs35.readFile(RECENT_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.slice(0, MAX) : [];
+  } catch {
+    return [];
+  }
+}
+async function saveRecent(list) {
+  const RECENT_FILE = recentFilePath();
+  await fs35.mkdir(path29.dirname(RECENT_FILE), { recursive: true });
+  await fs35.writeFile(RECENT_FILE, JSON.stringify(list.slice(0, MAX), null, 2) + "\n", "utf8");
+}
+function mountProjectsApi(app, opts) {
+  app.get("/api/projects/recent", async (c) => c.json(await loadRecent()));
+  app.post("/api/projects/touch", async (c) => {
+    const list = await loadRecent();
+    const filtered = list.filter((p) => p.root !== opts.paths.root);
+    filtered.unshift({ root: opts.paths.root, lastOpenedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    await saveRecent(filtered);
+    return c.json({ ok: true });
   });
-  fs28.writeFileSync(overview, filtered.join("\n"), "utf8");
 }
-function trashOrDelete(absPaths, trashRoot, useTrash) {
-  if (!useTrash) {
-    for (const p of absPaths) fs28.rmSync(p, { recursive: true, force: true });
-    return { removed: absPaths };
-  }
-  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const bucket = path22.join(trashRoot, ts);
-  fs28.mkdirSync(bucket, { recursive: true });
-  for (const src of absPaths) {
-    const rel = path22.basename(src);
-    let dst = path22.join(bucket, rel);
-    let n = 0;
-    while (fs28.existsSync(dst)) {
-      n += 1;
-      dst = path22.join(bucket, `${n}_${rel}`);
-    }
-    fs28.renameSync(src, dst);
-  }
-  return { removed: absPaths, trashed: bucket };
+
+// src/console/api/index.ts
+function mountApi(app, opts) {
+  mountMetaApi(app, opts);
+  mountDashboardApi(app, opts);
+  mountProjectsApi(app, opts);
+  mountStoriesApi(app, opts);
+  mountPlansApi(app, opts);
+  mountConfigApi(app, opts);
+  mountRunsApi(app, opts);
+  mountSecretsApi(app, opts);
+  mountTrackerApi(app, opts);
+  mountDoctorApi(app, opts);
+  mountCopyPlanPromptApi(app, opts);
 }
-function renderPreview(kind, targets, opts) {
-  divider(`squad rm ${kind}`);
-  step(opts.dryRun ? "Dry run \u2014 nothing will be changed." : "About to remove:");
-  for (const t of targets) {
-    kv(t.kind, t.label, 6);
-  }
-  if (opts.trash) {
-    info(`Items will move to ${path22.relative(process.cwd(), opts.trashRoot)}/<timestamp>/`);
-  } else if (!opts.dryRun) {
-    warning("This is a permanent delete. Pass --trash to move to .squad/.trash/ instead.");
+
+// src/console/static-assets.ts
+import fs36 from "fs";
+import path30 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Readable } from "stream";
+function pathnameForStatic(c) {
+  const rawUrl = c.env.incoming?.url;
+  if (typeof rawUrl === "string" && rawUrl.startsWith("/")) {
+    const pathOnly = rawUrl.split("?", 1)[0] ?? rawUrl;
+    try {
+      return decodeURIComponent(pathOnly);
+    } catch {
+      return pathOnly;
+    }
   }
+  try {
+    return decodeURIComponent(new URL(c.req.url).pathname);
+  } catch {
+    return new URL(c.req.url).pathname;
+  }
+}
+function mountStaticAssets(app, _opts) {
+  const distDir = resolveConsoleUiDist();
+  app.get("/logo.svg", (c) => serveFile(c, distDir, "logo.svg", "image/svg+xml"));
+  app.get("/favicon.ico", (c) => serveFile(c, distDir, "favicon.ico", "image/x-icon"));
+  app.get("*", (c) => {
+    const pathname = pathnameForStatic(c);
+    if (pathname.startsWith("/assets/")) {
+      return assetResponse(c, distDir, pathname);
+    }
+    if (c.req.path.startsWith("/api/") || c.req.path.startsWith("/healthz")) return c.notFound();
+    if (!distDir) return c.text("UI not built. Run `pnpm -C console-ui build`.", 404);
+    const indexHtml = path30.join(distDir, "index.html");
+    if (!fs36.existsSync(indexHtml)) return c.text("UI not built", 404);
+    return c.html(fs36.readFileSync(indexHtml, "utf8"), 200, { "cache-control": "no-store" });
+  });
 }
-function listAllPlanListEntries(paths, featureFilter) {
-  if (!fs28.existsSync(paths.plansDir)) return [];
-  const out = [];
-  for (const ent of fs28.readdirSync(paths.plansDir, { withFileTypes: true })) {
-    if (!ent.isDirectory()) continue;
-    if (featureFilter && ent.name !== featureFilter) continue;
-    const featureDir = path22.join(paths.plansDir, ent.name);
-    for (const name of fs28.readdirSync(featureDir)) {
-      if (!STORY_PLAN.test(name)) continue;
-      out.push({ feature: ent.name, file: name, abs: path22.join(featureDir, name) });
+function assetResponse(c, distDir, pathname) {
+  if (!distDir) return c.text("UI not built", 404);
+  const rel = pathname.replace(/^\//, "");
+  const abs = path30.normalize(path30.join(distDir, rel));
+  if (!isInside2(abs, distDir)) return c.text("forbidden", 403);
+  if (!fs36.existsSync(abs) || !fs36.statSync(abs).isFile()) return c.text("not found", 404);
+  const body = Readable.toWeb(fs36.createReadStream(abs));
+  return new Response(body, {
+    headers: {
+      "content-type": contentTypeFor(abs),
+      "cache-control": "public, max-age=31536000, immutable"
     }
+  });
+}
+function serveFile(c, distDir, name, ct) {
+  if (!distDir) return c.text("UI not built", 404);
+  const abs = path30.join(distDir, name);
+  if (!fs36.existsSync(abs)) return c.text("not found", 404);
+  return new Response(fs36.readFileSync(abs), {
+    headers: { "content-type": ct, "cache-control": "public, max-age=86400" }
+  });
+}
+function contentTypeFor(p) {
+  if (p.endsWith(".js")) return "application/javascript; charset=utf-8";
+  if (p.endsWith(".css")) return "text/css; charset=utf-8";
+  if (p.endsWith(".html")) return "text/html; charset=utf-8";
+  if (p.endsWith(".svg")) return "image/svg+xml";
+  if (p.endsWith(".png")) return "image/png";
+  if (p.endsWith(".woff2")) return "font/woff2";
+  if (p.endsWith(".json")) return "application/json";
+  return "application/octet-stream";
+}
+function isInside2(abs, parent) {
+  const a = path30.resolve(abs) + path30.sep;
+  const p = path30.resolve(parent) + path30.sep;
+  return a.startsWith(p);
+}
+function resolveConsoleUiDist() {
+  const fromEnv = process.env.SQUAD_CONSOLE_UI_DIST;
+  if (fromEnv && fs36.existsSync(path30.join(fromEnv, "index.html"))) return fromEnv;
+  const candidates = [
+    fileURLToPath2(new URL("./console-ui/", import.meta.url)),
+    // dist/cli.js → dist/console-ui/
+    fileURLToPath2(new URL("../../dist/console-ui/", import.meta.url)),
+    // src/console/*.ts → project/dist/console-ui/
+    fileURLToPath2(new URL("../console-ui/dist/", import.meta.url)),
+    // dist/cli.js → project/console-ui/dist
+    fileURLToPath2(new URL("../../console-ui/dist/", import.meta.url))
+    // src/console/*.ts → project/console-ui/dist
+  ];
+  for (const c of candidates) {
+    if (fs36.existsSync(path30.join(c, "index.html"))) return c;
   }
-  return out.sort((a, b) => (a.feature + a.file).localeCompare(b.feature + b.file));
+  return null;
 }
-async function pickStoryInteractive(paths, featureFilter) {
-  const stories = listAllStories(paths).filter((s) => !featureFilter || s.feature === featureFilter);
-  if (stories.length === 0) {
-    throw new Error("No stories to pick. Run `squad new-story` first, or `squad list` to verify paths.");
+
+// src/console/auth.ts
+function authMiddleware(expected) {
+  return async (c, next) => {
+    const presented = readPresentedToken(c.req.raw);
+    if (!presented || !timingSafeEqualHex(presented, expected)) {
+      return c.json({ error: "unauthorized", detail: "missing or invalid session token" }, 401);
+    }
+    await next();
+  };
+}
+function readPresentedToken(req) {
+  const auth = req.headers.get("authorization");
+  if (auth && auth.toLowerCase().startsWith("bearer ")) {
+    return auth.slice("bearer ".length).trim();
   }
-  if (stories.length === 1) return stories[0];
-  const choice = await select7({
-    message: "Story to remove:",
-    choices: stories.map((s) => ({
-      name: `${s.feature}/${s.id}  \xB7  ${s.titleHint ?? s.id}`,
-      value: s
-    }))
-  });
-  return choice;
+  const url = new URL(req.url);
+  return url.searchParams.get("t");
 }
-async function pickPlanInteractive(paths, featureFilter) {
-  const plans = listAllPlanListEntries(paths, featureFilter);
-  if (plans.length === 0) {
-    throw new Error("No plan files to pick. Run `squad new-plan` first, or `squad list` to see plans.");
+function timingSafeEqualHex(a, b) {
+  if (a.length !== b.length) return false;
+  let mismatch = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
   }
-  if (plans.length === 1) return plans[0];
-  return select7({
-    message: "Plan file to remove:",
-    choices: plans.map((p) => ({
-      name: `${p.feature}/${p.file}`,
-      value: p
-    }))
+  return mismatch === 0;
+}
+
+// src/console/server.ts
+async function startConsoleServer(opts) {
+  const bindPort = opts.requestedPort === 0 ? await reserveEphemeralPort() : await findFreePortFromBase(opts.requestedPort);
+  const app = new Hono();
+  app.get(
+    "/healthz",
+    (c) => c.json(
+      { ok: true, version: "0.6.0", port: bindPort },
+      200,
+      {
+        "cache-control": "no-store"
+      }
+    )
+  );
+  app.use(
+    "*",
+    secureHeaders({
+      contentSecurityPolicy: {
+        defaultSrc: ["'self'"],
+        styleSrc: ["'self'", "'unsafe-inline'"],
+        imgSrc: ["'self'", "data:"],
+        connectSrc: ["'self'"],
+        scriptSrc: ["'self'"],
+        frameAncestors: ["'none'"]
+      },
+      referrerPolicy: "no-referrer"
+    })
+  );
+  app.use("*", cors({ origin: "http://127.0.0.1:" + bindPort }));
+  app.use("/api/*", authMiddleware(opts.token));
+  mountApi(app, { paths: opts.paths });
+  mountStaticAssets(app, { paths: opts.paths });
+  const nodeServer = serve({ fetch: app.fetch, hostname: "127.0.0.1", port: bindPort });
+  let resolveDone = () => {
+  };
+  const done = new Promise((resolve2) => {
+    resolveDone = resolve2;
   });
+  const actualPort = (() => {
+    const addr = nodeServer.address();
+    if (addr && typeof addr === "object") return addr.port;
+    return bindPort;
+  })();
+  const shutdown = (onClose) => {
+    nodeServer.close((err) => {
+      onClose(err);
+    });
+  };
+  const stop = () => {
+    shutdown((err) => {
+      if (err) warning(`server close: ${err.message}`);
+      resolveDone();
+    });
+  };
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  return {
+    port: actualPort,
+    done,
+    close: () => new Promise((resolve2, reject) => {
+      shutdown((err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve2();
+        resolveDone();
+      });
+    })
+  };
 }
-async function pickFeatureInteractive(paths) {
-  const feats = listFeatures(paths);
-  if (feats.length === 0) {
-    throw new Error("No features to pick. Run `squad new-story` first, or `squad list` to see features.");
-  }
-  if (feats.length === 1) return feats[0];
-  return select7({
-    message: "Feature to remove:",
-    choices: feats.map((f) => ({ name: f, value: f }))
+function reserveEphemeralPort() {
+  return new Promise((resolve2, reject) => {
+    const s = createServer();
+    s.once("error", reject);
+    s.listen(0, "127.0.0.1", () => {
+      const addr = s.address();
+      s.close((closeErr) => {
+        if (closeErr) {
+          reject(closeErr);
+          return;
+        }
+        if (addr && typeof addr === "object") {
+          resolve2(addr.port);
+        } else {
+          reject(new Error("Could not determine ephemeral port"));
+        }
+      });
+    });
   });
 }
-function resolveStoryFromArg(arg, stories, root) {
-  const t = arg.trim();
-  for (const s of stories) {
-    if (s.id === t) return s;
-    if (`${s.feature}/${s.id}` === t) return s;
+async function findFreePortFromBase(start, attempts = 20) {
+  for (let i = 0; i < attempts; i += 1) {
+    const candidate = start + i;
+    if (await isPortFree(candidate)) return candidate;
   }
-  const abs = path22.isAbsolute(t) ? t : path22.resolve(root, t);
-  const withIntake = t.endsWith("intake.md") ? abs : path22.join(abs, "intake.md");
-  return findStoryByIntake(stories, withIntake) ?? findStoryByIntake(stories, abs);
-}
-function isSequenceToken(s) {
-  return /^\d{1,4}$/.test(s) && s.length > 0;
+  throw new Error(
+    `Could not find a free port in [${start}, ${start + attempts - 1}]. Pass \`--port <n>\` to pick another base.`
+  );
 }
-function tryParsePlanFilePath(absPath, paths, featureFilter) {
-  if (!fs28.existsSync(absPath) || !STORY_PLAN.test(path22.basename(absPath))) return void 0;
-  const planRoot = fs28.realpathSync(path22.resolve(paths.plansDir));
-  const fileReal = fs28.realpathSync(path22.resolve(absPath));
-  const rel = path22.relative(planRoot, fileReal);
-  if (rel.startsWith("..") || path22.isAbsolute(rel)) return void 0;
-  const segs = rel.split(path22.sep);
-  if (segs.length < 2) return void 0;
-  const feature = segs[0];
-  const file = segs.slice(1).join(path22.sep);
-  if (featureFilter && feature !== featureFilter) return void 0;
-  return { feature, file, abs: path22.resolve(absPath) };
+function isPortFree(port) {
+  return new Promise((resolve2) => {
+    const probe = createServer();
+    probe.once("error", () => resolve2(false));
+    probe.once("listening", () => probe.close(() => resolve2(true)));
+    probe.listen(port, "127.0.0.1");
+  });
 }
-function resolvePlanFromArg(arg, paths, featureFilter) {
-  const t = arg.trim();
-  if (!t) return void 0;
-  const asPath = path22.isAbsolute(t) ? t : path22.resolve(process.cwd(), t);
-  const a = tryParsePlanFilePath(asPath, paths, featureFilter);
-  if (a) return a;
-  if (!path22.isAbsolute(t)) {
-    const under = tryParsePlanFilePath(path22.join(paths.plansDir, t), paths, featureFilter);
-    if (under) return under;
+
+// src/commands/console.ts
+var DEFAULT_PORT = 4571;
+async function runConsole(opts) {
+  const root = requireSquadRoot();
+  const paths = buildPaths(root);
+  loadConfig(paths.configFile);
+  const portOpt = opts.port;
+  const requestedPort = portOpt !== void 0 && !Number.isNaN(portOpt) && portOpt >= 0 ? portOpt : DEFAULT_PORT;
+  const token = opts.token ?? randomBytes2(32).toString("hex");
+  const server = await startConsoleServer({ paths, requestedPort, token });
+  const url = `http://127.0.0.1:${server.port}/?t=${token}`;
+  banner();
+  divider("squad console");
+  summaryBox(" squad console ", [
+    { key: "project", value: resolve(paths.root) },
+    { key: "url", value: url },
+    { key: "token", value: `${token.slice(0, 8)}\u2026` },
+    { key: "port", value: String(server.port) }
+  ]);
+  if (server.port !== requestedPort) {
+    warning(`port ${requestedPort} was busy \u2014 bound to ${server.port} instead`);
   }
-  if (isSequenceToken(t)) {
-    const nn = formatSequence(parseInt(t, 10));
-    const prefix = `${nn}-`;
-    const cands = [];
-    for (const p of listAllPlanListEntries(paths, featureFilter)) {
-      if (p.file.startsWith(prefix)) cands.push(p);
-    }
-    if (cands.length === 1) return cands[0];
-    if (cands.length > 1) {
-      throw new Error(
-        `Multiple plans match sequence "${t}". Run \`squad rm plan\` in a TTY, or add \`--feature <slug>\` to disambiguate.`
-      );
+  blank();
+  step("Next:");
+  info("1) Pick a story in the Stories tab.");
+  info('2) Click "Generate plan" to start a planning run live.');
+  info("3) Press Ctrl-C in this terminal to stop the server when you're done.");
+  if (opts.open !== false) {
+    try {
+      await open(url);
+    } catch {
+      warning("Could not open a browser automatically. Copy the URL above into your browser.");
     }
+  } else {
+    info("Browser auto-open disabled (--no-open). Copy the URL above into your browser.");
   }
-  return void 0;
-}
-function countOverviewDataRows(overviewContent) {
-  let n = 0;
-  for (const line2 of overviewContent.split("\n")) {
-    if (!line2.startsWith("|")) continue;
-    if (/^\|\s*-+/.test(line2)) continue;
-    if (line2.includes("NN") && line2.includes("File") && line2.includes("Title")) continue;
-    n++;
-  }
-  return n;
-}
-function featureStoriesDirEmpty(paths, feature) {
-  const d = path22.join(paths.storiesDir, feature);
-  if (!fs28.existsSync(d)) return true;
-  return fs28.readdirSync(d).length === 0;
+  await server.done;
+  info("console stopped");
 }
 
 // src/commands/rm/story.ts
-import fs30 from "fs";
-import path24 from "path";
+import fs38 from "fs";
+import path32 from "path";
 import { confirm as confirm10 } from "@inquirer/prompts";
 
 // src/commands/rm/feature.ts
-import fs29 from "fs";
-import path23 from "path";
+import fs37 from "fs";
+import path31 from "path";
 import { confirm as confirm9 } from "@inquirer/prompts";
 function countStoryDirs(storiesDir, feature) {
-  const d = path23.join(storiesDir, feature);
-  if (!fs29.existsSync(d)) return 0;
-  return fs29.readdirSync(d, { withFileTypes: true }).filter((x) => x.isDirectory()).length;
+  const d = path31.join(storiesDir, feature);
+  if (!fs37.existsSync(d)) return 0;
+  return fs37.readdirSync(d, { withFileTypes: true }).filter((x) => x.isDirectory()).length;
 }
 async function runRmFeature(featureSlug, opts = {}) {
   const root = requireSquadRoot();
@@ -5121,17 +6996,17 @@ async function runRmFeature(featureSlug, opts = {}) {
       feature = await pickFeatureInteractive(paths);
     }
   }
-  const storyDir = path23.join(paths.storiesDir, feature);
-  const planDir = path23.join(paths.plansDir, feature);
+  const storyDir = path31.join(paths.storiesDir, feature);
+  const planDir = path31.join(paths.plansDir, feature);
   const nStories = countStoryDirs(paths.storiesDir, feature);
   const nPlans = listAllPlanListEntries(paths, feature).length;
-  const hasOverview = fs29.existsSync(path23.join(planDir, "00-overview.md")) ? 1 : 0;
+  const hasOverview = fs37.existsSync(path31.join(planDir, "00-overview.md")) ? 1 : 0;
   const targets = [];
-  if (fs29.existsSync(storyDir)) {
-    targets.push({ label: path23.relative(root, storyDir), absPath: storyDir, kind: "dir" });
+  if (fs37.existsSync(storyDir)) {
+    targets.push({ label: path31.relative(root, storyDir), absPath: storyDir, kind: "dir" });
   }
-  if (fs29.existsSync(planDir)) {
-    targets.push({ label: path23.relative(root, planDir), absPath: planDir, kind: "dir" });
+  if (fs37.existsSync(planDir)) {
+    targets.push({ label: path31.relative(root, planDir), absPath: planDir, kind: "dir" });
   }
   divider("squad rm feature");
   info(`Feature:  ${feature}`);
@@ -5146,7 +7021,7 @@ async function runRmFeature(featureSlug, opts = {}) {
     kv(t.kind, t.label, 6);
   }
   if (useTrash) {
-    info(`Items will move to ${path23.relative(process.cwd(), paths.trashDir)}/<timestamp>/`);
+    info(`Items will move to ${path31.relative(process.cwd(), paths.trashDir)}/<timestamp>/`);
   } else if (!dryRun) {
     warning("This is a permanent delete. Pass --trash to move to .squad/.trash/ instead.");
   }
@@ -5179,7 +7054,7 @@ async function runRmFeature(featureSlug, opts = {}) {
     useTrash
   );
   if (result.trashed) {
-    success(`Feature removed. Items moved to ${path23.relative(root, result.trashed)}.`);
+    success(`Feature removed. Items moved to ${path31.relative(root, result.trashed)}.`);
   } else {
     success("Feature removed (stories and plans directories).");
   }
@@ -5220,11 +7095,11 @@ async function runRmStory(storyPathOrId, opts = {}) {
     }
   }
   const targets = [
-    { label: path24.relative(root, story.storyDir), absPath: story.storyDir, kind: "dir" }
+    { label: path32.relative(root, story.storyDir), absPath: story.storyDir, kind: "dir" }
   ];
   if (story.planFile) {
-    const planAbs = path24.join(paths.plansDir, story.feature, story.planFile);
-    targets.push({ label: path24.relative(root, planAbs), absPath: planAbs, kind: "file" });
+    const planAbs = path32.join(paths.plansDir, story.feature, story.planFile);
+    targets.push({ label: path32.relative(root, planAbs), absPath: planAbs, kind: "file" });
   }
   renderPreview("story", targets, {
     dryRun,
@@ -5247,18 +7122,16 @@ async function runRmStory(storyPathOrId, opts = {}) {
       return;
     }
   }
-  const absPaths = targets.map((t) => t.absPath);
-  const result = trashOrDelete(absPaths, paths.trashDir, useTrash);
-  removeOverviewRow(path24.join(paths.plansDir, story.feature), story.id);
+  const result = deleteStoryRecord({ paths, story, trash: useTrash });
   if (result.trashed) {
-    success(`Removed (moved to ${path24.relative(root, result.trashed)}).`);
+    success(`Removed (moved to ${path32.relative(root, result.trashed)}).`);
   } else {
     success("Removed story folder, plan file (if any), and overview row.");
   }
-  const featurePlanDir = path24.join(paths.plansDir, story.feature);
-  const overviewPath = path24.join(featurePlanDir, "00-overview.md");
-  if (fs30.existsSync(overviewPath)) {
-    const body = fs30.readFileSync(overviewPath, "utf8");
+  const featurePlanDir = path32.join(paths.plansDir, story.feature);
+  const overviewPath = path32.join(featurePlanDir, "00-overview.md");
+  if (fs38.existsSync(overviewPath)) {
+    const body = fs38.readFileSync(overviewPath, "utf8");
     const onlyShell = countOverviewDataRows(body) === 0;
     if (onlyShell && featureStoriesDirEmpty(paths, story.feature)) {
       if (canPrompt) {
@@ -5278,7 +7151,7 @@ async function runRmStory(storyPathOrId, opts = {}) {
 }
 
 // src/commands/rm/plan.ts
-import path25 from "path";
+import path33 from "path";
 import { confirm as confirm11 } from "@inquirer/prompts";
 async function runRmPlan(planPathOrSequence, opts = {}) {
   const root = requireSquadRoot();
@@ -5314,7 +7187,7 @@ async function runRmPlan(planPathOrSequence, opts = {}) {
   }
   const storyRows = listStories(paths, { feature: plan.feature });
   const linked = storyRows.find((s) => s.planFile === plan.file);
-  const targets = [{ label: path25.relative(root, plan.abs), absPath: plan.abs, kind: "file" }];
+  const targets = [{ label: path33.relative(root, plan.abs), absPath: plan.abs, kind: "file" }];
   renderPreview("plan", targets, {
     dryRun,
     trash: useTrash,
@@ -5337,14 +7210,14 @@ async function runRmPlan(planPathOrSequence, opts = {}) {
     }
   }
   trashOrDelete([plan.abs], paths.trashDir, useTrash);
-  removeOverviewRowForPlanFile(path25.join(paths.plansDir, plan.feature), plan.file);
-  const intakeHint = linked ? path25.relative(root, linked.intakePath) : `under .squad/stories/${plan.feature}/`;
+  removeOverviewRowForPlanFile(path33.join(paths.plansDir, plan.feature), plan.file);
+  const intakeHint = linked ? path33.relative(root, linked.intakePath) : `under .squad/stories/${plan.feature}/`;
   success(`Plan removed. Run \`squad new-plan ${intakeHint}\` to regenerate.`);
 }
 
 // src/cli.ts
 var program = new Command();
-program.name("squad").description("Plan once, execute cheap. A 3-step SDD workflow CLI.").version("0.3.0");
+program.name("squad").description("Plan once, execute cheap. A 3-step SDD workflow CLI.").version("0.6.0");
 program.command("init").description("Bootstrap .squad/ in the current directory").option("--agents <list>", "Comma-separated agent list: claude-code,cursor,copilot,gemini").option("--tracker <type>", "Tracker type: none|github|linear|jira|azure").option(
   "--tracker-workspace <hostOrOrg>",
   "Jira host or Azure org (non-interactive default; also written to config for jira/azure)"
@@ -5377,6 +7250,11 @@ program.command("status").description("Show squad-kit workspace status").action(
 program.command("doctor").description("Run a health check on the local .squad/ workspace and its external integrations").option("--fix", "Apply non-destructive repairs (gitignore, permissions, missing dirs)", false).option("--json", "Emit results as JSON to stdout (for scripting)", false).action(wrap(runDoctor));
 program.command("migrate").description("Apply one-shot structural migrations to bring .squad/ to the latest version").option("--dry-run", "Show what would change without touching the filesystem", false).option("-y, --yes", "Skip the confirmation prompt", false).action(wrap(runMigrate));
 program.command("upgrade").description("Check for and install the latest squad-kit release").option("--check", "Only check for updates; do not install", false).option("-y, --yes", "Skip the confirmation prompt", false).action(wrap(runUpgrade));
+program.command("console").description("Open the squad-kit web console (local, dark-modern UI for stories, plans, runs, config)").option(
+  "--port <number>",
+  "Port to bind on 127.0.0.1 (default 4571; falls back to next free port)",
+  (v) => parseInt(v, 10)
+).option("--no-open", "Do not auto-open the browser; print the URL instead").option("--token <hex>", "Reuse a specific session token (advanced; default: random per session)").action(wrap(runConsole));
 program.command("list").description("List stories and their plan state").option("--feature <slug>", "Filter by feature slug").action(wrap(runList));
 var rm = program.command("rm").description("Delete stories, plans, or entire features safely");
 rm.command("story [story-path-or-id]").description("Delete a story: intake folder + matching plan file + overview row").option("--feature <slug>", "Scope the picker or lookup to one feature").option("--dry-run", "Show what would be deleted without touching the filesystem", false).option("--trash", "Move into .squad/.trash/<ts>/ instead of permanent delete", false).option("-y, --yes", "Skip the confirmation prompt", false).action(wrapArgs(runRmStory));
@@ -5398,6 +7276,10 @@ config.command("remove-credential <section>").description('Delete credentials fo
   )
 );
 program.parseAsync(process.argv).catch((err) => {
+  if (isSquadExit(err)) {
+    if (err.message.trim()) info(err.message);
+    process.exit(err.exitCode);
+  }
   renderError(err);
   process.exit(1);
 });
@@ -5406,6 +7288,10 @@ function wrap(fn) {
     try {
       await fn(opts);
     } catch (err) {
+      if (isSquadExit(err)) {
+        if (err.message.trim()) info(err.message);
+        process.exit(err.exitCode);
+      }
       renderError(err);
       process.exit(1);
     }
@@ -5416,6 +7302,10 @@ function wrapArgs(fn) {
     try {
       await fn(...args);
     } catch (err) {
+      if (isSquadExit(err)) {
+        if (err.message.trim()) info(err.message);
+        process.exit(err.exitCode);
+      }
       renderError(err);
       process.exit(1);
     }