@coopcli/specplan 5.2.0

package/dist/cli/index.js

@@ -0,0 +1,2650 @@
+#!/usr/bin/env node
+
+// server/cli.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync4 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname4, extname, join as join6, normalize as normalize2, resolve as resolve5 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs as parseArgs2 } from "node:util";
+import { serve } from "@hono/node-server";
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/lib/schema.ts
+import { z } from "zod";
+var GENERATION_MODELS = [
+  "claude-opus-4-8",
+  "claude-sonnet-5",
+  "claude-fable-5"
+];
+var DEFAULT_MODEL = "claude-opus-4-8";
+var GenerationModel = z.enum(GENERATION_MODELS);
+var NodeType = z.enum(["spec", "user_story"]);
+var SpecNode = z.object({
+  /** Server-minted `spec-<ulid>` (lowercase). */
+  id: z.string(),
+  type: z.literal("spec"),
+  title: z.string(),
+  /**
+   * Author's description/prompt for the spec — steering context for
+   * generation. May contain `@` file references, which expand at
+   * generation time like any other input.
+   */
+  description: z.string().optional(),
+  specFile: z.string(),
+  /** Sibling ordering hint — display/tie-break only, never affects edges. */
+  order: z.number()
+});
+var StoryNode = z.object({
+  /** Server-minted `us-<ulid>` (lowercase). */
+  id: z.string(),
+  type: z.literal("user_story"),
+  text: z.string(),
+  order: z.number()
+});
+var PlanNode = z.discriminatedUnion("type", [SpecNode, StoryNode]);
+var EdgeType = z.enum(["dependency", "containment"]);
+var PlanEdge = z.object({
+  from: z.string(),
+  to: z.string(),
+  type: EdgeType
+});
+var Plan = z.object({
+  version: z.number(),
+  nodes: z.array(PlanNode),
+  edges: z.array(PlanEdge)
+});
+var SPEC_STATUSES = ["draft", "active", "done", "deferred"];
+var SpecStatus = z.enum(SPEC_STATUSES);
+var SpecMeta = z.object({
+  specId: z.string(),
+  userStories: z.array(z.string()),
+  dependencies: z.array(z.string()),
+  /** Lifecycle status; absent = draft. */
+  status: SpecStatus.optional(),
+  generation: z.object({
+    /** sha256 of the last generated body files — detects hand edits. */
+    lastGeneratedBodyHash: z.string(),
+    lastGeneratedAt: z.string()
+  }).optional()
+});
+var ChatRole = z.enum(["user", "assistant", "summary"]);
+var ChatMessage = z.object({
+  role: ChatRole,
+  text: z.string(),
+  /** ISO-8601 creation time. */
+  at: z.string()
+});
+var ExecutedToolCall = z.object({
+  tool: z.string(),
+  /** Human-readable outcome, e.g. `created spec-… "Auth floor"`. */
+  summary: z.string()
+});
+var ChatRequest = z.object({
+  /** The user's new message (may contain `@` references). */
+  message: z.string().min(1),
+  /** Conversation history preceding `message`, oldest first. */
+  conversation: z.array(ChatMessage).default([]),
+  model: GenerationModel.optional()
+});
+var UnresolvedRefInfo = z.object({ ref: z.string(), reason: z.string() });
+var ChatReply = z.object({
+  reply: ChatMessage,
+  /** Tool calls the dispatch loop executed against the plan, in order. */
+  toolCalls: z.array(ExecutedToolCall),
+  /** The plan after any mutations (so the canvas refreshes in one hop). */
+  plan: Plan,
+  /** Workspace-relative paths whose contents joined the answer's context. */
+  resolvedRefs: z.array(z.string()),
+  /** References that soft-failed, with the reason shown to the user. */
+  unresolvedRefs: z.array(UnresolvedRefInfo)
+});
+var CapabilitySpec = z.object({
+  capability: z.string(),
+  spec: z.string()
+});
+var SpecBundle = z.object({
+  /** kebab-case change id — always overwritten with the card's specId. */
+  changeName: z.string(),
+  /** One-paragraph plain-language summary. */
+  summary: z.string(),
+  /** proposal.md — why + what is changing. */
+  proposal: z.string(),
+  /** design.md — technical approach, components, data flow, decisions. */
+  design: z.string(),
+  /** tasks.md — implementation checklist. */
+  tasks: z.string(),
+  /** One entry per capability the change introduces. */
+  specs: z.array(CapabilitySpec)
+});
+var GenerateRequest = z.object({
+  specId: z.string().min(1),
+  model: GenerationModel.optional()
+});
+var GenerateResponse = z.object({
+  specId: z.string(),
+  /**
+   * `generated` — bodies (re)written and validated; `metadata-only` — the
+   * body was hand-edited, so only the per-spec metadata file was updated.
+   */
+  mode: z.enum(["generated", "metadata-only"]),
+  /** Change-dir-relative paths written by this generation. */
+  changedFiles: z.array(z.string())
+});
+var NodePosition = z.object({ x: z.number(), y: z.number() });
+var SpecState = z.object({
+  /** Body files (proposal/design/tasks/specs) exist in the change dir. */
+  hasSpec: z.boolean(),
+  /**
+   * The body diverges from the recorded lastGeneratedBodyHash (or was never
+   * generated by specplan) — regeneration will be metadata-only.
+   */
+  handEdited: z.boolean(),
+  /** Lifecycle status from the per-spec metadata file (absent = draft). */
+  status: SpecStatus
+});
+var SetStatusRequest = z.object({
+  specId: z.string(),
+  status: SpecStatus
+});
+var SessionSnapshot = z.object({
+  /** Display name of the plan root (the openspec directory). */
+  rootName: z.string(),
+  model: GenerationModel.optional(),
+  plan: Plan,
+  /** Canvas layout per node id (UI sidecar state, not plan data). */
+  positions: z.record(z.string(), NodePosition),
+  /** Per-spec-node on-disk change state, keyed by spec id. */
+  specStates: z.record(z.string(), SpecState),
+  /** Persisted assistant chat, oldest first. */
+  chat: z.array(ChatMessage).optional()
+});
+var SpecArtifacts = z.object({
+  specId: z.string(),
+  handEdited: z.boolean(),
+  /** Change-dir-relative body files in canonical order. */
+  files: z.array(z.object({ path: z.string(), content: z.string() }))
+});
+var SessionSave = z.object({
+  model: GenerationModel.optional(),
+  positions: z.record(z.string(), NodePosition).optional()
+});
+var CreateSpecRequest = z.object({
+  title: z.string().min(1),
+  /** Optional description/prompt used as generation steering context. */
+  description: z.string().optional()
+});
+var CreateStoryRequest = z.object({ text: z.string().min(1) });
+var LinkRequest = z.object({ from: z.string(), to: z.string() });
+var ReorderRequest = z.object({ nodeId: z.string(), order: z.number() });
+var PromptSave = z.object({
+  system: z.string().min(1).nullable()
+});
+var PromptInfo = z.object({
+  /** The prompt the next generation will use (custom override or default). */
+  system: z.string(),
+  /** The built-in default, for the editor's Reset action. */
+  default: z.string(),
+  /** True when a custom override is active. */
+  custom: z.boolean()
+});
+
+// server/app.ts
+import { basename as basename3 } from "node:path";
+import { Hono } from "hono";
+
+// src/lib/dag.ts
+function storyError(text) {
+  const lower = text.toLowerCase();
+  const find = (marker, from) => lower.indexOf(marker.toLowerCase(), from);
+  const asA = find("As a", 0);
+  if (asA === -1) return 'user story is missing the "As a" marker';
+  const iWantTo = find("I want to", asA + "As a".length);
+  if (iWantTo === -1) return 'user story is missing the "I want to" marker (after "As a")';
+  if (!text.slice(asA + "As a".length, iWantTo).trim()) {
+    return 'user story has no <user> text between "As a" and "I want to"';
+  }
+  const soThat = find("so that", iWantTo + "I want to".length);
+  if (soThat === -1) return 'user story is missing the "so that" marker (after "I want to")';
+  if (!text.slice(iWantTo + "I want to".length, soThat).trim()) {
+    return 'user story has no <feature> text between "I want to" and "so that"';
+  }
+  if (!text.slice(soThat + "so that".length).trim()) {
+    return 'user story has no <value proposition> text after "so that"';
+  }
+  return null;
+}
+var DagError = class extends Error {
+};
+function label(node) {
+  const name = node.type === "spec" ? node.title : node.text;
+  return `${node.id} ("${name.length > 40 ? `${name.slice(0, 40)}\u2026` : name}")`;
+}
+function dependencyAdjacency(edges) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (e.type !== "dependency") continue;
+    const next = adj.get(e.from) ?? [];
+    next.push(e.to);
+    adj.set(e.from, next);
+  }
+  return adj;
+}
+function dependencyPath(edges, start, goal) {
+  const adj = dependencyAdjacency(edges);
+  const seen = /* @__PURE__ */ new Set([start]);
+  const walk = (at, path) => {
+    if (at === goal) return path;
+    for (const next of adj.get(at) ?? []) {
+      if (seen.has(next)) continue;
+      seen.add(next);
+      const found = walk(next, [...path, next]);
+      if (found) return found;
+    }
+    return null;
+  };
+  return walk(start, [start]);
+}
+function deriveEdge(plan, from, to) {
+  const nodes = new Map(plan.nodes.map((n) => [n.id, n]));
+  const fromNode = nodes.get(from);
+  const toNode = nodes.get(to);
+  if (!fromNode) throw new DagError(`unknown node: ${from}`);
+  if (!toNode) throw new DagError(`unknown node: ${to}`);
+  if (fromNode.type === "user_story") {
+    throw new DagError(
+      `user stories carry no edges of their own \u2014 ${label(fromNode)} cannot be a link source; link from a spec instead`
+    );
+  }
+  if (from === to) throw new DagError(`cannot link ${label(fromNode)} to itself`);
+  if (plan.edges.some((e) => e.from === from && e.to === to)) {
+    throw new DagError(`link already exists: ${from} -> ${to}`);
+  }
+  if (toNode.type === "user_story") return { from, to, type: "containment" };
+  const path = dependencyPath(plan.edges, to, from);
+  if (path) {
+    const cycle = [from, ...path].map((id) => nodes.get(id)).filter((n) => n !== void 0);
+    throw new DagError(`dependency cycle: ${cycle.map((n) => label(n)).join(" -> ")}`);
+  }
+  return { from, to, type: "dependency" };
+}
+function containedStories(plan, specId) {
+  return plan.edges.filter((e) => e.type === "containment" && e.from === specId).map((e) => e.to);
+}
+function specDependencies(plan, specId) {
+  return plan.edges.filter((e) => e.type === "dependency" && e.from === specId).map((e) => e.to);
+}
+function backlog(plan) {
+  const linked = new Set(plan.edges.flatMap((e) => [e.from, e.to]));
+  const free = plan.nodes.filter((n) => !linked.has(n.id));
+  return {
+    specs: sortSiblings(free.filter((n) => n.type === "spec")),
+    stories: sortSiblings(free.filter((n) => n.type === "user_story"))
+  };
+}
+function sortSiblings(nodes) {
+  return [...nodes].sort((a, b) => a.order - b.order);
+}
+function planErrors(plan) {
+  const errors = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const n of plan.nodes) {
+    if (byId.has(n.id)) errors.push(`duplicate node id: ${n.id}`);
+    byId.set(n.id, n);
+    if (n.type === "user_story") {
+      const err = storyError(n.text);
+      if (err) errors.push(`${n.id}: ${err}`);
+    }
+  }
+  const seenEdges = /* @__PURE__ */ new Set();
+  for (const e of plan.edges) {
+    const fromNode = byId.get(e.from);
+    const toNode = byId.get(e.to);
+    if (!fromNode) errors.push(`edge references unknown node: ${e.from} (${e.from} -> ${e.to})`);
+    if (!toNode) errors.push(`edge references unknown node: ${e.to} (${e.from} -> ${e.to})`);
+    if (!fromNode || !toNode) continue;
+    if (fromNode.type === "user_story") {
+      errors.push(`user story ${e.from} carries an edge of its own (${e.from} -> ${e.to})`);
+      continue;
+    }
+    const expected = toNode.type === "user_story" ? "containment" : "dependency";
+    if (e.type !== expected) {
+      errors.push(`edge ${e.from} -> ${e.to} must be type "${expected}", found "${e.type}"`);
+    }
+    const key = `${e.from}->${e.to}`;
+    if (seenEdges.has(key)) errors.push(`duplicate edge: ${e.from} -> ${e.to}`);
+    seenEdges.add(key);
+  }
+  const depEdges = plan.edges.filter(
+    (e) => e.type === "dependency" && byId.has(e.from) && byId.has(e.to)
+  );
+  for (const e of depEdges) {
+    const path = dependencyPath(depEdges, e.to, e.from);
+    if (path) {
+      errors.push(`dependency cycle: ${[e.from, ...path].join(" -> ")}`);
+      break;
+    }
+  }
+  return errors;
+}
+
+// server/generate.ts
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+import { promisify } from "node:util";
+import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";
+
+// server/atomic.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+function writeAtomicFile(target, content) {
+  mkdirSync(dirname(target), { recursive: true });
+  const tmp = `${target}.tmp`;
+  writeFileSync(tmp, content, "utf8");
+  renameSync(tmp, target);
+}
+function readIfExists(target) {
+  return existsSync(target) ? readFileSync(target, "utf8") : void 0;
+}
+
+// server/model.ts
+var FABLE_BETAS = ["server-side-fallback-2026-06-01"];
+var FABLE_FALLBACKS = [{ model: "claude-opus-4-8" }];
+async function createWithModelGate(anthropic, request) {
+  const msg = request.model === "claude-fable-5" ? await anthropic.beta.messages.create({
+    ...request,
+    betas: FABLE_BETAS,
+    fallbacks: FABLE_FALLBACKS
+  }) : await anthropic.messages.create(request);
+  return msg;
+}
+function parseWithModelGate(anthropic, request) {
+  return request.model === "claude-fable-5" ? anthropic.beta.messages.parse({
+    ...request,
+    betas: FABLE_BETAS,
+    fallbacks: FABLE_FALLBACKS
+  }) : anthropic.messages.parse(request);
+}
+function textOf(msg) {
+  return msg.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+}
+function toolUsesOf(msg) {
+  return msg.content.filter((b) => b.type === "tool_use").map((b) => ({ id: b.id ?? "", name: b.name ?? "", input: b.input }));
+}
+
+// server/references.ts
+import { readFileSync as readFileSync2, readdirSync, realpathSync, statSync } from "node:fs";
+import { basename, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
+var REF_FILE_BYTE_LIMIT = 64 * 1024;
+var REF_TOTAL_BYTE_LIMIT = 256 * 1024;
+var REF_DIR_FILE_LIMIT = 50;
+var SEARCH_IGNORE = /* @__PURE__ */ new Set([".git", "node_modules", "dist", ".wrangler", ".DS_Store"]);
+function parseReferences(text) {
+  const tokens = [];
+  const pattern = /(^|[\s([{'"`])@([^\s@]+)/g;
+  for (const match of text.matchAll(pattern)) {
+    const token = (match[2] ?? "").replace(/[.,;:!?)\]}'"`>]+$/, "");
+    if (!token || token.startsWith("<")) continue;
+    if (!tokens.includes(token)) tokens.push(token);
+  }
+  return tokens;
+}
+function insideRoot(rootReal, target) {
+  return target.startsWith(rootReal + sep);
+}
+var WALK_ENTRY_LIMIT = 2e4;
+function collectEntries(root) {
+  const files = [];
+  const dirs = [];
+  const walk = (dir) => {
+    if (files.length + dirs.length >= WALK_ENTRY_LIMIT) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length + dirs.length >= WALK_ENTRY_LIMIT) return;
+      if (SEARCH_IGNORE.has(entry.name) || entry.isSymbolicLink()) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        dirs.push(relative(root, full));
+        walk(full);
+      } else if (entry.isFile()) files.push(relative(root, full));
+    }
+  };
+  walk(root);
+  return { files, dirs };
+}
+var collectFiles = (root) => collectEntries(root).files;
+function findByName(root, name) {
+  return collectFiles(root).filter((p) => basename(p) === name).sort((a, b) => {
+    const depth = a.split(sep).length - b.split(sep).length;
+    return depth !== 0 ? depth : a.localeCompare(b);
+  });
+}
+var FILE_SEARCH_LIMIT = 20;
+function searchFiles(root, query, limit = FILE_SEARCH_LIMIT) {
+  if (root === void 0) return [];
+  let rootReal;
+  try {
+    rootReal = realpathSync(resolve(root));
+  } catch {
+    return [];
+  }
+  const q = query.trim().toLowerCase();
+  const { files, dirs } = collectEntries(rootReal);
+  const all = [...dirs.map((d) => `${d}/`), ...files];
+  const matches = q ? all.filter((p) => p.toLowerCase().includes(q)) : all;
+  const rank = (p) => {
+    const lower = p.toLowerCase();
+    return [
+      q && basename(lower.replace(/\/$/, "")).includes(q) ? 0 : 1,
+      q ? lower.indexOf(q) : 0,
+      p.length
+    ];
+  };
+  return matches.map((p) => ({ p, r: rank(p) })).sort(
+    (a, b) => a.r[0] - b.r[0] || a.r[1] - b.r[1] || a.r[2] - b.r[2] || a.p.localeCompare(b.p)
+  ).slice(0, limit).map(({ p }) => p);
+}
+function readClamped(target) {
+  const raw = readFileSync2(target);
+  if (raw.byteLength <= REF_FILE_BYTE_LIMIT) {
+    return { content: raw.toString("utf8"), truncated: false };
+  }
+  return {
+    content: `${raw.subarray(0, REF_FILE_BYTE_LIMIT).toString("utf8")}
+\u2026 [truncated at ${REF_FILE_BYTE_LIMIT} bytes]`,
+    truncated: true
+  };
+}
+function expandReferences(text, root) {
+  const resolved = [];
+  const unresolved = [];
+  const refs = parseReferences(text);
+  if (refs.length === 0) return { resolved, unresolved };
+  let rootReal = null;
+  if (root !== void 0) {
+    try {
+      rootReal = realpathSync(resolve(root));
+    } catch {
+      rootReal = null;
+    }
+  }
+  let totalBytes = 0;
+  for (const ref of refs) {
+    if (rootReal === null) {
+      unresolved.push({ ref, reason: "file references are unavailable here" });
+      continue;
+    }
+    if (totalBytes >= REF_TOTAL_BYTE_LIMIT) {
+      unresolved.push({ ref, reason: "reference budget exceeded \u2014 too much file content already included" });
+      continue;
+    }
+    const outcome = resolveOne(rootReal, ref);
+    if ("reason" in outcome) {
+      unresolved.push({ ref, ...outcome });
+      continue;
+    }
+    if ("dirFiles" in outcome) {
+      let included = 0;
+      for (const relPath of outcome.dirFiles) {
+        if (included >= REF_DIR_FILE_LIMIT || totalBytes >= REF_TOTAL_BYTE_LIMIT) break;
+        let body;
+        try {
+          body = readClamped(join(rootReal, relPath));
+        } catch {
+          continue;
+        }
+        totalBytes += Buffer.byteLength(body.content, "utf8");
+        resolved.push({ ref, path: relPath, ...body });
+        included++;
+      }
+      const omitted = outcome.dirFiles.length - included;
+      if (included === 0) {
+        unresolved.push({
+          ref,
+          reason: "reference budget exceeded \u2014 too much file content already included"
+        });
+      } else if (omitted > 0) {
+        unresolved.push({
+          ref,
+          kind: "partial",
+          reason: `directory partially included \u2014 ${omitted} of ${outcome.dirFiles.length} files omitted by the size budget`
+        });
+      }
+      continue;
+    }
+    totalBytes += Buffer.byteLength(outcome.content, "utf8");
+    resolved.push({ ref, ...outcome });
+  }
+  return { resolved, unresolved };
+}
+function resolveOne(rootReal, ref) {
+  if (isAbsolute(ref)) return { reason: "absolute paths are not allowed" };
+  const rel = normalize(ref);
+  if (rel.split(sep).includes("..")) return { reason: "path escapes the working directory" };
+  const direct = resolve(rootReal, rel);
+  if (direct !== rootReal && !insideRoot(rootReal, direct)) {
+    return { reason: "path escapes the working directory" };
+  }
+  const stats = statOrNull(direct);
+  if (stats?.isDirectory()) {
+    let real;
+    try {
+      real = realpathSync(direct);
+    } catch {
+      return { reason: "not readable" };
+    }
+    if (real !== rootReal && !insideRoot(rootReal, real)) {
+      return { reason: "resolves outside the working directory" };
+    }
+    const dirFiles = collectFiles(direct).map((p) => relative(rootReal, join(direct, p))).sort((a, b) => {
+      const depth = a.split(sep).length - b.split(sep).length;
+      return depth !== 0 ? depth : a.localeCompare(b);
+    });
+    if (dirFiles.length === 0) return { reason: "directory contains no files" };
+    return { dirFiles };
+  }
+  if (stats?.isFile()) {
+    let real;
+    try {
+      real = realpathSync(direct);
+    } catch {
+      return { reason: "not readable" };
+    }
+    if (!insideRoot(rootReal, real)) return { reason: "resolves outside the working directory" };
+    try {
+      return { path: relative(rootReal, direct), ...readClamped(direct) };
+    } catch {
+      return { reason: "not readable" };
+    }
+  }
+  if (rel.includes(sep)) return { reason: "not found" };
+  const matches = findByName(rootReal, rel);
+  if (matches.length === 0) return { reason: "not found" };
+  const best = matches[0];
+  try {
+    const body = readClamped(join(rootReal, best));
+    return {
+      path: best,
+      ...body,
+      ...matches.length > 1 ? {
+        note: `ambiguous \u2014 ${matches.length} files named "${rel}"; using ${best}, others: ${matches.slice(1, 5).join(", ")}${matches.length > 5 ? ", \u2026" : ""}`
+      } : {}
+    };
+  } catch {
+    return { reason: "not readable" };
+  }
+}
+function statOrNull(path) {
+  try {
+    return statSync(path);
+  } catch {
+    return null;
+  }
+}
+function renderReferenceContext(expansion) {
+  const parts = [];
+  for (const r of expansion.resolved) {
+    const note = r.note ? `(${r.note})
+` : "";
+    parts.push(`=== @${r.path} ===
+${note}${r.content}
+=== end @${r.path} ===`);
+  }
+  for (const u of expansion.unresolved) {
+    parts.push(
+      u.kind === "partial" ? `@${u.ref}: ${u.reason}.` : `@${u.ref}: could not be resolved (${u.reason}) \u2014 do not invent its contents.`
+    );
+  }
+  return parts.join("\n\n");
+}
+
+// server/generate.ts
+var SYSTEM = `You are a principal software architect and specification writer.
+Given one planned spec card from a project roadmap \u2014 its title, the user stories it
+contains, and the other specs it depends on \u2014 produce an OpenSpec change proposal for
+exactly that spec.
+
+Follow OpenSpec conventions:
+- proposal: a "## Why" section (motivation) and a "## What Changes" section.
+- design: components & responsibilities, data flow, key decisions/trade-offs, open questions.
+- tasks: numbered "## <n>. <area>" sections of "- [ ] <n>.<m> \u2026" checklist items.
+- Each capability the change introduces gets its own spec: a "## Purpose" paragraph, then
+  "## ADDED Requirements" containing "### Requirement: <name>" sections. Every requirement
+  states "The system SHALL ..." and has at least one "#### Scenario: <name>" block whose
+  body is "- WHEN ..." / "- THEN ..." bullet lines.
+- EVERY user story contained by the spec MUST map to its own "#### Scenario:" block under
+  a requirement derived from it \u2014 no story may be dropped or merged away.
+- changeName and capability ids are kebab-case.
+- Dependencies on other specs are context: mention them in proposal/design where relevant,
+  but never restate their requirements.
+
+Referenced files: the input may contain "@<path | filename>" references that were resolved
+to real file contents, delimited as "=== @<path> === \u2026 === end @<path> ===" blocks. That
+content is authoritative ground truth about the existing system \u2014 prefer it over inference.
+A note like "@foo.ts: could not be resolved" marks a reference that failed to resolve;
+acknowledge the gap where relevant, never invent the file's contents.
+
+Ground every requirement in the stories and titles actually given; record ambiguity as an
+assumption in design rather than inventing unrelated features. Prefer 1-3 focused
+capabilities.`;
+var GenerationFailed = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var sha256 = (s) => createHash("sha256").update(s).digest("hex");
+function listBodyFiles(changeDir) {
+  const files = [];
+  for (const name of ["proposal.md", "design.md", "tasks.md"]) {
+    if (existsSync2(join2(changeDir, name))) files.push(name);
+  }
+  const specsDir = join2(changeDir, "specs");
+  if (existsSync2(specsDir)) {
+    for (const entry of readdirSync2(specsDir, { withFileTypes: true }).sort(
+      (a, b) => a.name.localeCompare(b.name)
+    )) {
+      const rel = join2("specs", entry.name, "spec.md");
+      if (entry.isDirectory() && existsSync2(join2(changeDir, rel))) files.push(rel);
+    }
+  }
+  return files;
+}
+function bodyHash(changeDir) {
+  const files = listBodyFiles(changeDir);
+  if (files.length === 0) return null;
+  const parts = files.map((rel) => `${rel}
+${sha256(readFileSync3(join2(changeDir, rel), "utf8"))}`);
+  return `sha256:${sha256(parts.join("\n"))}`;
+}
+function specState(store, specId) {
+  const changeDir = dirname2(store.specMetaPath(specId));
+  const currentHash = bodyHash(changeDir);
+  let meta = null;
+  try {
+    meta = store.readSpecMeta(specId);
+  } catch {
+  }
+  const status = meta?.status ?? "draft";
+  if (currentHash === null) return { hasSpec: false, handEdited: false, status };
+  return {
+    hasSpec: true,
+    handEdited: meta?.generation?.lastGeneratedBodyHash !== currentHash,
+    status
+  };
+}
+function readBodyFiles(store, specId) {
+  const changeDir = dirname2(store.specMetaPath(specId));
+  return listBodyFiles(changeDir).map((rel) => ({ path: rel, content: readIfExists(join2(changeDir, rel)) })).filter((f) => f.content !== void 0);
+}
+function resolveOpenspecBin() {
+  const require2 = createRequire(import.meta.url);
+  let dir = dirname2(require2.resolve("@fission-ai/openspec"));
+  for (; ; ) {
+    const pkgPath = join2(dir, "package.json");
+    if (existsSync2(pkgPath)) {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+      if (pkg.name === "@fission-ai/openspec" && pkg.bin) {
+        return join2(dir, typeof pkg.bin === "string" ? pkg.bin : pkg.bin.openspec ?? "");
+      }
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) throw new Error("could not locate the @fission-ai/openspec bin");
+    dir = parent;
+  }
+}
+async function runOpenspecValidate(specId, rootDir) {
+  const bin = resolveOpenspecBin();
+  try {
+    const { stdout, stderr } = await promisify(execFile)(
+      process.execPath,
+      [bin, "validate", specId, "--strict"],
+      { cwd: dirname2(resolve2(rootDir)) }
+    );
+    return { ok: true, output: `${stdout}${stderr}`.trim() };
+  } catch (err) {
+    const e = err;
+    return {
+      ok: false,
+      output: `${e.stdout ?? ""}${e.stderr ?? ""}`.trim() || (e.message ?? String(err))
+    };
+  }
+}
+function renderSpecPrompt(spec, stories, deps) {
+  const storyLines = stories.length ? stories.map((s) => `- ${s.id}: ${s.text}`).join("\n") : "- (none \u2014 derive a minimal requirement set from the title and description alone)";
+  const depLines = deps.length ? deps.map((d) => `- ${d.id}: "${d.title}"`).join("\n") : "- (none)";
+  return `Planned spec card: "${spec.title}" (change id: ${spec.id})
+
+` + (spec.description ? `Author's description/prompt (requirements and corrections that MUST steer this generation):
+${spec.description}
+
+` : "") + `Contained user stories (EVERY one must map to its own "#### Scenario:" block):
+${storyLines}
+
+Depends on specs (context only \u2014 do not restate their requirements):
+${depLines}
+
+Produce the OpenSpec change proposal for exactly this spec as structured output.
+Use exactly "${spec.id}" as the changeName.`;
+}
+function renderBaseline(changeDir) {
+  const sections = listBodyFiles(changeDir).map((rel) => ({ rel, content: readIfExists(join2(changeDir, rel)) })).filter((f) => f.content !== void 0).map((f) => `--- ${f.rel} ---
+${f.content}`);
+  if (sections.length === 0) return "";
+  return `
+
+The change directory already contains these artifacts (generated by a previous run). Treat them as the baseline: make the SMALLEST revision that brings them in line with the stories and dependencies above. Keep unaffected content verbatim; return the complete artifact set with those minimal edits applied.
+
+${sections.join("\n\n")}`;
+}
+function writeBundle(changeDir, bundle) {
+  const files = {
+    "proposal.md": bundle.proposal,
+    "design.md": bundle.design,
+    "tasks.md": bundle.tasks
+  };
+  for (const s of bundle.specs) files[join2("specs", s.capability, "spec.md")] = s.spec;
+  const written = [];
+  for (const [rel, content] of Object.entries(files)) {
+    if (readIfExists(join2(changeDir, rel)) === content) continue;
+    writeAtomicFile(join2(changeDir, rel), content);
+    written.push(rel);
+  }
+  return written;
+}
+async function generateForSpec(deps, specId, model = DEFAULT_MODEL) {
+  const { store } = deps;
+  const plan = store.load();
+  const node = plan.nodes.find((n) => n.id === specId);
+  if (!node || node.type !== "spec") {
+    throw new GenerationFailed(`unknown spec: ${specId}`, 400);
+  }
+  const stories = storyNodes(plan, specId);
+  const depSpecs = depNodes(plan, specId);
+  const changeDir = dirname2(store.specMetaPath(specId));
+  store.writeSpecMeta(
+    specId,
+    stories.map((s) => s.id),
+    depSpecs.map((d) => d.id)
+  );
+  const currentHash = bodyHash(changeDir);
+  if (currentHash !== null) {
+    const recorded = store.readSpecMeta(specId)?.generation?.lastGeneratedBodyHash;
+    if (recorded !== currentHash) {
+      return { specId, mode: "metadata-only", changedFiles: ["specplan.yaml"] };
+    }
+  }
+  const system = deps.systemPrompt ?? SYSTEM;
+  const refs = expandReferences(
+    [
+      ...system === SYSTEM ? [] : [system],
+      node.title,
+      node.description ?? "",
+      ...stories.map((s) => s.text)
+    ].join("\n"),
+    deps.refRoot
+  );
+  const refContext = renderReferenceContext(refs);
+  const prompt = renderSpecPrompt(node, stories, depSpecs) + renderBaseline(changeDir) + (refContext ? `
+
+Referenced files (resolved from @-references in the input):
+
+${refContext}` : "");
+  const msg = await parseWithModelGate(deps.anthropic, {
+    model,
+    max_tokens: 16e3,
+    // non-streaming stays under the SDK HTTP timeout
+    system,
+    messages: [{ role: "user", content: prompt }],
+    output_config: { format: zodOutputFormat(SpecBundle) }
+    // No temperature/top_p or thinking config — both 400 on modern models.
+  });
+  if (msg.stop_reason === "refusal") {
+    throw new GenerationFailed(`the model refused this generation`, 422);
+  }
+  if (!msg.parsed_output) {
+    throw new GenerationFailed("model returned no structured output", 502);
+  }
+  const output = SpecBundle.parse(msg.parsed_output);
+  const bundle = { ...output, changeName: specId };
+  const changedFiles = writeBundle(changeDir, bundle);
+  store.writeGeneration(specId, bodyHash(changeDir) ?? "", (/* @__PURE__ */ new Date()).toISOString());
+  const verdict = await runOpenspecValidate(specId, store.dir);
+  if (!verdict.ok) {
+    throw new GenerationFailed(
+      `generated change failed \`openspec validate ${specId} --strict\`:
+${verdict.output}`,
+      422
+    );
+  }
+  return { specId, mode: "generated", changedFiles };
+}
+function storyNodes(plan, specId) {
+  const byId = new Map(plan.nodes.map((n) => [n.id, n]));
+  return containedStories(plan, specId).map((id) => byId.get(id)).filter((n) => n?.type === "user_story");
+}
+function depNodes(plan, specId) {
+  const byId = new Map(plan.nodes.map((n) => [n.id, n]));
+  return specDependencies(plan, specId).map((id) => byId.get(id)).filter((n) => n?.type === "spec");
+}
+
+// server/store.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync3 } from "node:fs";
+import { basename as basename2, join as join3, resolve as resolve3 } from "node:path";
+import { Document, parseDocument } from "yaml";
+
+// server/ulid.ts
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var RANDOM_BYTES = 10;
+function encodeTime(ms) {
+  let str = "";
+  let t = ms;
+  for (let i = 9; i >= 0; i--) {
+    str = (ENCODING[t % 32] ?? "0") + str;
+    t = Math.floor(t / 32);
+  }
+  return str;
+}
+function encodeRandomBytes(bytes) {
+  let str = "";
+  let carry = 0;
+  let bits = 0;
+  for (const byte of bytes) {
+    carry = carry << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      str += ENCODING[carry >> bits & 31] ?? "0";
+    }
+  }
+  if (bits > 0) {
+    str += ENCODING[carry << 5 - bits & 31] ?? "0";
+  }
+  return str.slice(0, 16);
+}
+function incrementBytes(bytes) {
+  for (let i = bytes.length - 1; i >= 0; i--) {
+    if (bytes[i] < 255) {
+      bytes[i]++;
+      return true;
+    }
+    bytes[i] = 0;
+  }
+  return false;
+}
+var lastTime = 0;
+var lastRandom = new Uint8Array(RANDOM_BYTES);
+function generateUlid() {
+  const now = Date.now();
+  if (now > lastTime) {
+    lastTime = now;
+    lastRandom = crypto.getRandomValues(new Uint8Array(RANDOM_BYTES));
+  } else {
+    if (!incrementBytes(lastRandom)) {
+      lastTime += 1;
+      lastRandom = crypto.getRandomValues(new Uint8Array(RANDOM_BYTES));
+    }
+  }
+  return encodeTime(lastTime) + encodeRandomBytes(lastRandom);
+}
+
+// server/store.ts
+var PlanFileError = class extends Error {
+};
+var ROOT_FILE = "specplan.yaml";
+var META_FILE = "specplan.yaml";
+var PlanStore = class {
+  /** Resolved openspec root directory. */
+  dir;
+  constructor(dir) {
+    this.dir = resolve3(dir);
+    mkdirSync2(this.dir, { recursive: true });
+  }
+  // ── Root file ────────────────────────────────────────────────────────────
+  rootPath() {
+    return join3(this.dir, ROOT_FILE);
+  }
+  loadDoc() {
+    const raw = readIfExists(this.rootPath());
+    if (raw === void 0) return new Document({ version: 1, nodes: [], edges: [] });
+    const doc = parseDocument(raw);
+    const fault = doc.errors[0];
+    if (fault) throw new PlanFileError(`${ROOT_FILE}: ${fault.message}`);
+    if (doc.getIn(["version"]) === void 0) doc.setIn(["version"], 1);
+    if (doc.getIn(["nodes"]) === void 0) doc.setIn(["nodes"], doc.createNode([]));
+    if (doc.getIn(["edges"]) === void 0) doc.setIn(["edges"], doc.createNode([]));
+    return doc;
+  }
+  planOf(doc) {
+    const parsed = Plan.safeParse(doc.toJS());
+    if (!parsed.success) {
+      const issues = parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+      throw new PlanFileError(`${ROOT_FILE}: ${issues}`);
+    }
+    return parsed.data;
+  }
+  /** The current plan, reloaded from disk. */
+  load() {
+    return this.planOf(this.loadDoc());
+  }
+  save(doc) {
+    writeAtomicFile(this.rootPath(), doc.toString());
+  }
+  // ── Ids ──────────────────────────────────────────────────────────────────
+  mintId(prefix, existing) {
+    for (; ; ) {
+      const id = `${prefix}-${generateUlid().toLowerCase()}`;
+      if (!existing.has(id)) return id;
+    }
+  }
+  nextOrder(plan, type) {
+    const orders = plan.nodes.filter((n) => n.type === type).map((n) => n.order);
+    return orders.length === 0 ? 0 : Math.max(...orders) + 1;
+  }
+  // ── Mutations (canvas routes and chat tools share these) ─────────────────
+  createSpec(title, description) {
+    const trimmed = title.trim();
+    if (!trimmed) throw new DagError("spec title must not be empty");
+    const doc = this.loadDoc();
+    const plan = this.planOf(doc);
+    const id = this.mintId("spec", new Set(plan.nodes.map((n) => n.id)));
+    const node = {
+      id,
+      type: "spec",
+      title: trimmed,
+      ...description?.trim() ? { description: description.trim() } : {},
+      specFile: `${basename2(this.dir)}/changes/${id}/${META_FILE}`,
+      order: this.nextOrder(plan, "spec")
+    };
+    doc.addIn(["nodes"], node);
+    this.save(doc);
+    this.initSpecMeta(id);
+    return node;
+  }
+  /** A fresh per-spec metadata file: empty relations, explicit draft status. */
+  initSpecMeta(specId) {
+    writeAtomicFile(
+      this.specMetaPath(specId),
+      new Document({
+        specId,
+        userStories: [],
+        dependencies: [],
+        status: "draft"
+      }).toString()
+    );
+  }
+  createStory(text) {
+    const trimmed = text.trim();
+    const fault = storyError(trimmed);
+    if (fault) throw new DagError(fault);
+    const doc = this.loadDoc();
+    const plan = this.planOf(doc);
+    const id = this.mintId("us", new Set(plan.nodes.map((n) => n.id)));
+    const node = {
+      id,
+      type: "user_story",
+      text: trimmed,
+      order: this.nextOrder(plan, "user_story")
+    };
+    doc.addIn(["nodes"], node);
+    this.save(doc);
+    return node;
+  }
+  /** Add an edge; the type is derived (spec→spec dependency, spec→story containment). */
+  link(from, to) {
+    const doc = this.loadDoc();
+    const plan = this.planOf(doc);
+    const edge = deriveEdge(plan, from, to);
+    doc.addIn(["edges"], edge);
+    this.save(doc);
+    const next = { ...plan, edges: [...plan.edges, edge] };
+    this.writeSpecMeta(from, containedStories(next, from), specDependencies(next, from));
+    return edge;
+  }
+  /**
+   * Remove one edge (the canvas unlink gesture — a USER action; the chat
+   * tool set deliberately has no destructive tool). Re-syncs the source
+   * spec's metadata file so userStories/dependencies reflect the removal.
+   */
+  unlink(from, to) {
+    const doc = this.loadDoc();
+    const plan = this.planOf(doc);
+    const idx = plan.edges.findIndex((e) => e.from === from && e.to === to);
+    const edge = plan.edges[idx];
+    if (!edge) throw new DagError(`no link exists: ${from} -> ${to}`);
+    doc.deleteIn(["edges", idx]);
+    this.save(doc);
+    const next = { ...plan, edges: plan.edges.filter((_, i) => i !== idx) };
+    this.writeSpecMeta(from, containedStories(next, from), specDependencies(next, from));
+    return edge;
+  }
+  /** Update one node's sibling `order` hint. Never touches edges. */
+  reorder(nodeId, order) {
+    const doc = this.loadDoc();
+    const plan = this.planOf(doc);
+    const idx = plan.nodes.findIndex((n) => n.id === nodeId);
+    const node = plan.nodes[idx];
+    if (!node) throw new DagError(`unknown node: ${nodeId}`);
+    doc.setIn(["nodes", idx, "order"], order);
+    this.save(doc);
+    return { ...node, order };
+  }
+  /**
+   * Adopt pre-existing OpenSpec change directories (layered-storage:
+   * "Landing existing changes on the canvas"): every directory under
+   * <root>/changes/ — except `archive` — that is not yet a node becomes a
+   * spec node whose id IS the change-dir basename (the D5 rule), with its
+   * per-spec metadata file initialized when missing. Idempotent; runs on
+   * every session load so a change dir created mid-session lands on the
+   * next refresh. Never touches a change's body files.
+   */
+  adoptExistingChanges() {
+    const changesDir = join3(this.dir, "changes");
+    if (!existsSync3(changesDir)) return [];
+    const doc = this.loadDoc();
+    const plan = this.planOf(doc);
+    const known = new Set(plan.nodes.map((n) => n.id));
+    let order = this.nextOrder(plan, "spec");
+    const adopted = [];
+    for (const entry of readdirSync3(changesDir, { withFileTypes: true }).sort(
+      (a, b) => a.name.localeCompare(b.name)
+    )) {
+      if (!entry.isDirectory() || entry.name === "archive" || entry.name.startsWith(".")) {
+        continue;
+      }
+      if (known.has(entry.name)) continue;
+      const node = {
+        id: entry.name,
+        type: "spec",
+        title: entry.name,
+        specFile: `${basename2(this.dir)}/changes/${entry.name}/${META_FILE}`,
+        order: order++
+      };
+      doc.addIn(["nodes"], node);
+      adopted.push(node);
+    }
+    if (adopted.length === 0) return [];
+    this.save(doc);
+    for (const node of adopted) {
+      try {
+        if (this.readSpecMeta(node.id) === null) this.initSpecMeta(node.id);
+      } catch {
+      }
+    }
+    return adopted;
+  }
+  // ── Per-spec metadata files ──────────────────────────────────────────────
+  specMetaPath(specId) {
+    return join3(this.dir, "changes", specId, META_FILE);
+  }
+  readSpecMeta(specId) {
+    const raw = readIfExists(this.specMetaPath(specId));
+    if (raw === void 0) return null;
+    const doc = parseDocument(raw);
+    const fault = doc.errors[0];
+    if (fault) throw new PlanFileError(`changes/${specId}/${META_FILE}: ${fault.message}`);
+    const parsed = SpecMeta.safeParse(doc.toJS());
+    if (!parsed.success) {
+      const issues = parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+      throw new PlanFileError(`changes/${specId}/${META_FILE}: ${issues}`);
+    }
+    return parsed.data;
+  }
+  /**
+   * Write a spec's metadata file, preserving everything this write does not
+   * own (comments, the generation block) by editing the existing document.
+   */
+  writeSpecMeta(specId, userStories, dependencies) {
+    const path = this.specMetaPath(specId);
+    const raw = readIfExists(path);
+    const doc = raw === void 0 ? new Document({}) : parseDocument(raw);
+    doc.setIn(["specId"], specId);
+    doc.setIn(["userStories"], userStories);
+    doc.setIn(["dependencies"], dependencies);
+    writeAtomicFile(path, doc.toString());
+  }
+  /**
+   * Set a spec's lifecycle status (draft | active | done | deferred) in its
+   * per-spec metadata file. User-owned, free transitions; everything else
+   * in the file (stories, dependencies, generation, comments) is preserved.
+   */
+  setStatus(specId, status) {
+    const node = this.load().nodes.find((n) => n.id === specId);
+    if (!node || node.type !== "spec") throw new DagError(`unknown spec: ${specId}`);
+    const path = this.specMetaPath(specId);
+    const raw = readIfExists(path);
+    const doc = raw === void 0 ? new Document({ specId, userStories: [], dependencies: [] }) : parseDocument(raw);
+    doc.setIn(["status"], status);
+    writeAtomicFile(path, doc.toString());
+  }
+  /** Record a generation result in the spec's metadata file. */
+  writeGeneration(specId, lastGeneratedBodyHash, lastGeneratedAt) {
+    const path = this.specMetaPath(specId);
+    const raw = readIfExists(path);
+    const doc = raw === void 0 ? new Document({ specId }) : parseDocument(raw);
+    doc.setIn(["generation", "lastGeneratedBodyHash"], lastGeneratedBodyHash);
+    doc.setIn(["generation", "lastGeneratedAt"], lastGeneratedAt);
+    writeAtomicFile(path, doc.toString());
+  }
+};
+
+// server/tools.ts
+import { z as z2 } from "zod";
+var CreateSpecInput = z2.object({ title: z2.string().min(1) });
+var CreateStoryInput = z2.object({ text: z2.string().min(1) });
+var LinkDependencyInput = z2.object({ fromSpecId: z2.string(), toSpecId: z2.string() });
+var ContainStoryInput = z2.object({ specId: z2.string(), storyId: z2.string() });
+var ReorderInput = z2.object({ nodeId: z2.string(), order: z2.number() });
+var CHAT_TOOLS = [
+  {
+    name: "create_spec",
+    description: "Create a new spec card on the planning canvas. Returns the minted spec id.",
+    input_schema: {
+      type: "object",
+      properties: { title: { type: "string", description: "Short spec title" } },
+      required: ["title"]
+    }
+  },
+  {
+    name: "create_user_story",
+    description: 'Create a new user story card. The text MUST follow "As a <user>, I want to <feature> so that <value proposition>". Returns the minted story id.',
+    input_schema: {
+      type: "object",
+      properties: { text: { type: "string", description: "The full user-story sentence" } },
+      required: ["text"]
+    }
+  },
+  {
+    name: "link_dependency",
+    description: "Add a directed dependency edge between two existing SPECS (fromSpecId depends on toSpecId). Rejected if it would create a cycle.",
+    input_schema: {
+      type: "object",
+      properties: {
+        fromSpecId: { type: "string", description: "The dependent spec id (spec-\u2026)" },
+        toSpecId: { type: "string", description: "The spec it depends on (spec-\u2026)" }
+      },
+      required: ["fromSpecId", "toSpecId"]
+    }
+  },
+  {
+    name: "contain_story",
+    description: "Contain an existing user story in an existing spec (the coverage relation). Removes the story from the backlog.",
+    input_schema: {
+      type: "object",
+      properties: {
+        specId: { type: "string", description: "The containing spec id (spec-\u2026)" },
+        storyId: { type: "string", description: "The user story id (us-\u2026)" }
+      },
+      required: ["specId", "storyId"]
+    }
+  },
+  {
+    name: "reorder",
+    description: "Set a node's sibling `order` value (display ordering among siblings). Never changes any edges.",
+    input_schema: {
+      type: "object",
+      properties: {
+        nodeId: { type: "string", description: "The node to reorder" },
+        order: { type: "number", description: "The new order value" }
+      },
+      required: ["nodeId", "order"]
+    }
+  }
+];
+function parseInput(schema, input, tool) {
+  const parsed = schema.safeParse(input);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    throw new DagError(`${tool}: invalid input \u2014 ${issues}`);
+  }
+  return parsed.data;
+}
+function nodeType(store, id) {
+  const node = store.load().nodes.find((n) => n.id === id);
+  if (!node) throw new DagError(`unknown node: ${id}`);
+  return node.type;
+}
+function executeToolCall(store, name, input) {
+  switch (name) {
+    case "create_spec": {
+      const { title } = parseInput(CreateSpecInput, input, name);
+      const node = store.createSpec(title);
+      return { tool: name, summary: `created spec ${node.id} "${node.title}"` };
+    }
+    case "create_user_story": {
+      const { text } = parseInput(CreateStoryInput, input, name);
+      const node = store.createStory(text);
+      return { tool: name, summary: `created user story ${node.id}` };
+    }
+    case "link_dependency": {
+      const { fromSpecId, toSpecId } = parseInput(LinkDependencyInput, input, name);
+      for (const id of [fromSpecId, toSpecId]) {
+        if (nodeType(store, id) !== "spec") {
+          throw new DagError(
+            `link_dependency links specs only \u2014 ${id} is a user story (use contain_story)`
+          );
+        }
+      }
+      const edge = store.link(fromSpecId, toSpecId);
+      return { tool: name, summary: `linked dependency ${edge.from} -> ${edge.to}` };
+    }
+    case "contain_story": {
+      const { specId, storyId } = parseInput(ContainStoryInput, input, name);
+      if (nodeType(store, specId) !== "spec") {
+        throw new DagError(`contain_story: ${specId} is not a spec`);
+      }
+      if (nodeType(store, storyId) !== "user_story") {
+        throw new DagError(`contain_story: ${storyId} is not a user story`);
+      }
+      const edge = store.link(specId, storyId);
+      return { tool: name, summary: `contained ${edge.to} in ${edge.from}` };
+    }
+    case "reorder": {
+      const { nodeId, order } = parseInput(ReorderInput, input, name);
+      const node = store.reorder(nodeId, order);
+      return { tool: name, summary: `set order of ${node.id} to ${order}` };
+    }
+    default:
+      throw new DagError(`unknown tool: ${name}`);
+  }
+}
+
+// server/app.ts
+var CHAT_SYSTEM = `You are SpecPlan's planning assistant. The user is planning a project as a
+DAG of two node types \u2014 specs and user stories \u2014 with directed dependency edges between
+specs (kept acyclic) and containment edges from specs to the user stories they cover.
+
+You have tools to CREATE specs and user stories, LINK spec dependencies, CONTAIN stories
+in specs, and REORDER siblings. Use them whenever the user asks to add, connect, cover, or
+reorder plan items, then confirm what you did. User stories MUST follow the formula
+"As a <user>, I want to <feature> so that <value proposition>" \u2014 compose conforming text
+when the user is informal. A failed tool call returns a named error; adjust or explain,
+never retry the identical call.
+
+You CANNOT delete, remove, or rename anything \u2014 no such tool exists, by design. If asked
+to delete or remove an item, explain that SpecPlan's assistant is non-destructive (the
+user can edit specplan.yaml by hand) and make NO tool calls.
+
+Ground answers in the current plan below. "=== @<path> ===" blocks are real file contents
+resolved from @-references; they are authoritative over your assumptions. Answers render
+as plain text in a narrow side pane: be concise, short paragraphs or simple "- " lists,
+no headings or heavy markdown.`;
+function renderPlanContext(plan, statuses) {
+  if (plan.nodes.length === 0) return "Current plan: (empty \u2014 no nodes yet)";
+  const stories = new Map(
+    plan.nodes.filter((n) => n.type === "user_story").map((n) => [n.id, n])
+  );
+  const lines = ["Current plan:"];
+  for (const node of plan.nodes) {
+    if (node.type !== "spec") continue;
+    lines.push(
+      `- spec ${node.id} "${node.title}" (order ${node.order}, status ${statuses?.[node.id] ?? "draft"})`
+    );
+    for (const dep of specDependencies(plan, node.id)) lines.push(`    depends on ${dep}`);
+    for (const sid of containedStories(plan, node.id)) {
+      const story = stories.get(sid);
+      lines.push(`    contains ${sid}: ${story?.type === "user_story" ? story.text : ""}`);
+    }
+  }
+  const free = backlog(plan);
+  const backlogLines = [
+    ...free.specs.map((n) => `- ${n.id} (spec): ${n.type === "spec" ? n.title : ""}`),
+    ...free.stories.map((n) => `- ${n.id} (story): ${n.type === "user_story" ? n.text : ""}`)
+  ];
+  lines.push("", "Backlog (not yet linked into the plan):");
+  lines.push(...backlogLines.length > 0 ? backlogLines : ["- (empty)"]);
+  return lines.join("\n");
+}
+var CHAT_TOOL_ROUNDS_LIMIT = 8;
+function anthropicErrorResponse(c, err, kind) {
+  const message = err instanceof Error ? err.message : String(err);
+  const status = err.status;
+  if (status === 401 || /authentication|auth token|x-api-key/i.test(message)) {
+    return c.json(
+      {
+        error: "anthropic-auth",
+        hint: "No Anthropic credentials available to the server. Set ANTHROPIC_API_KEY in your environment, or install the Anthropic CLI and run `ant auth login` (macOS: brew install anthropics/tap/ant), then restart specplan.",
+        detail: message
+      },
+      401
+    );
+  }
+  return c.json({ error: kind, detail: message }, 502);
+}
+function planErrorResponse(c, err) {
+  if (err instanceof DagError) return c.json({ error: err.message }, 400);
+  if (err instanceof PlanFileError) return c.json({ error: err.message }, 500);
+  throw err;
+}
+function createApp(anthropic, workspace, store, options) {
+  const refRoot = options === void 0 ? process.cwd() : options.refRoot;
+  const app = new Hono();
+  app.get("/api/health", (c) => c.json({ ok: true }));
+  app.get(
+    "/api/config",
+    (c) => c.json({
+      workspace: Boolean(workspace),
+      models: GENERATION_MODELS,
+      defaultModel: DEFAULT_MODEL
+    })
+  );
+  if (workspace && store) {
+    app.get("/api/session", (c) => {
+      try {
+        store.adoptExistingChanges();
+        const plan = store.load();
+        const specStates = Object.fromEntries(
+          plan.nodes.filter((n) => n.type === "spec").map((n) => [n.id, specState(store, n.id)])
+        );
+        return c.json({
+          rootName: basename3(workspace.dir),
+          model: GENERATION_MODELS.find((m) => m === workspace.readModel()),
+          plan,
+          positions: workspace.readPositions(),
+          specStates,
+          chat: workspace.readChat()
+        });
+      } catch (err) {
+        return planErrorResponse(c, err);
+      }
+    });
+    app.put("/api/session", async (c) => {
+      const parsed = SessionSave.safeParse(await c.req.json().catch(() => null));
+      if (!parsed.success) {
+        return c.json({ error: "invalid session", detail: parsed.error.issues }, 400);
+      }
+      workspace.writeUiState(parsed.data);
+      return c.json({ ok: true });
+    });
+    app.post("/api/plan/spec", async (c) => {
+      const parsed = CreateSpecRequest.safeParse(await c.req.json().catch(() => null));
+      if (!parsed.success) {
+        return c.json({ error: "invalid request", detail: parsed.error.issues }, 400);
+      }
+      try {
+        return c.json(
+          { node: store.createSpec(parsed.data.title, parsed.data.description) },
+          201
+        );
+      } catch (err) {
+        return planErrorResponse(c, err);
+      }
+    });
+    app.post("/api/plan/story", async (c) => {
+      const parsed = CreateStoryRequest.safeParse(await c.req.json().catch(() => null));
+      if (!parsed.success) {
+        return c.json({ error: "invalid request", detail: parsed.error.issues }, 400);
+      }
+      try {
+        return c.json({ node: store.createStory(parsed.data.text) }, 201);
+      } catch (err) {
+        return planErrorResponse(c, err);
+      }
+    });
+    app.post("/api/plan/link", async (c) => {
+      const parsed = LinkRequest.safeParse(await c.req.json().catch(() => null));
+      if (!parsed.success) {
+        return c.json({ error: "invalid request", detail: parsed.error.issues }, 400);
+      }
+      try {
+        return c.json({ edge: store.link(parsed.data.from, parsed.data.to) }, 201);
+      } catch (err) {
+        return planErrorResponse(c, err);
+      }
+    });
+    app.get("/api/spec/:specId", (c) => {
+      const specId = c.req.param("specId");
+      try {
+        const node = store.load().nodes.find((n) => n.id === specId);
+        if (!node || node.type !== "spec") {
+          return c.json({ error: `unknown spec: ${specId}` }, 404);
+        }
+        return c.json({
+          specId,
+          handEdited: specState(store, specId).handEdited,
+          files: readBodyFiles(store, specId)
+        });
+      } catch (err) {
+        return planErrorResponse(c, err);
+      }
+    });
+    app.post("/api/generate", async (c) => {
+      const parsed = GenerateRequest.safeParse(await c.req.json().catch(() => null));
+      if (!parsed.success) {
+        return c.json({ error: "invalid request", detail: parsed.error.issues }, 400);
+      }
+      const model = parsed.data.model ?? GENERATION_MODELS.find((m) => m === workspace.readModel()) ?? DEFAULT_MODEL;
+      try {
+        const result = await generateForSpec(
+          {
+            anthropic,
+            store,
+            systemPrompt: workspace.readSystemPrompt(),
+            refRoot
+          },
+          parsed.data.specId,
+          model
+        );
+        return c.json(result);
+      } catch (err) {
+        if (err instanceof GenerationFailed) {
+          return c.json({ error: "generation-failed", detail: err.message }, err.status);
+        }
+        return anthropicErrorResponse(c, err, "generation-failed");
+      }
+    });
+    app.post("/api/chat", async (c) => {
+      const parsed = ChatRequest.safeParse(await c.req.json().catch(() => null));
+      if (!parsed.success) {
+        return c.json({ error: "invalid request", detail: parsed.error.issues }, 400);
+      }
+      const { message, conversation, model = DEFAULT_MODEL } = parsed.data;
+      const refs = expandReferences(message, refRoot);
+      const refContext = renderReferenceContext(refs);
+      const messages = [
+        ...conversation.map((m) => ({
+          role: m.role === "user" ? "user" : "assistant",
+          content: m.text
+        })),
+        {
+          role: "user",
+          content: message + (refContext ? `
+
+Referenced files (resolved from @-references in the message):
+
+${refContext}` : "")
+        }
+      ];
+      const chatPlan = store.load();
+      const statuses = Object.fromEntries(
+        chatPlan.nodes.filter((n) => n.type === "spec").map((n) => [n.id, specState(store, n.id).status])
+      );
+      const system = `${CHAT_SYSTEM}
+
+${renderPlanContext(chatPlan, statuses)}`;
+      const executed = [];
+      let text = "";
+      try {
+        for (let round = 0; round < CHAT_TOOL_ROUNDS_LIMIT; round++) {
+          const msg = await createWithModelGate(anthropic, {
+            model,
+            max_tokens: 2e3,
+            system,
+            messages,
+            tools: CHAT_TOOLS
+          });
+          if (msg.stop_reason === "refusal") {
+            return c.json({ error: "refusal", detail: msg.stop_details }, 422);
+          }
+          const toolUses = toolUsesOf(msg);
+          if (toolUses.length === 0 || msg.stop_reason !== "tool_use") {
+            text = textOf(msg);
+            break;
+          }
+          messages.push({ role: "assistant", content: msg.content });
+          const results = toolUses.map((tu) => {
+            try {
+              const outcome = executeToolCall(store, tu.name, tu.input);
+              executed.push(outcome);
+              return { type: "tool_result", tool_use_id: tu.id, content: outcome.summary };
+            } catch (err) {
+              if (!(err instanceof DagError)) throw err;
+              return {
+                type: "tool_result",
+                tool_use_id: tu.id,
+                content: err.message,
+                is_error: true
+              };
+            }
+          });
+          messages.push({ role: "user", content: results });
+        }
+      } catch (err) {
+        return anthropicErrorResponse(c, err, "chat-failed");
+      }
+      if (!text) {
+        text = executed.length > 0 ? `Applied ${executed.length} change${executed.length === 1 ? "" : "s"}: ${executed.map((e) => e.summary).join("; ")}.` : "The model returned no text.";
+      }
+      const reply = { role: "assistant", text, at: (/* @__PURE__ */ new Date()).toISOString() };
+      workspace.writeChat([
+        ...conversation,
+        { role: "user", text: message, at: reply.at },
+        reply
+      ]);
+      return c.json({
+        reply,
+        toolCalls: executed,
+        plan: store.load(),
+        resolvedRefs: refs.resolved.map((r) => r.path),
+        unresolvedRefs: refs.unresolved
+      });
+    });
+    app.delete("/api/chat", (c) => {
+      workspace.writeChat([]);
+      return c.json({ ok: true });
+    });
+    app.post("/api/plan/status", async (c) => {
+      const parsed = SetStatusRequest.safeParse(await c.req.json().catch(() => null));
+      if (!parsed.success) {
+        return c.json({ error: "invalid request", detail: parsed.error.issues }, 400);
+      }
+      try {
+        store.setStatus(parsed.data.specId, parsed.data.status);
+        return c.json({ specId: parsed.data.specId, status: parsed.data.status });
+      } catch (err) {
+        return planErrorResponse(c, err);
+      }
+    });
+    app.post("/api/plan/unlink", async (c) => {
+      const parsed = LinkRequest.safeParse(await c.req.json().catch(() => null));
+      if (!parsed.success) {
+        return c.json({ error: "invalid request", detail: parsed.error.issues }, 400);
+      }
+      try {
+        return c.json({ edge: store.unlink(parsed.data.from, parsed.data.to) });
+      } catch (err) {
+        return planErrorResponse(c, err);
+      }
+    });
+    app.post("/api/plan/reorder", async (c) => {
+      const parsed = ReorderRequest.safeParse(await c.req.json().catch(() => null));
+      if (!parsed.success) {
+        return c.json({ error: "invalid request", detail: parsed.error.issues }, 400);
+      }
+      try {
+        return c.json({ node: store.reorder(parsed.data.nodeId, parsed.data.order) });
+      } catch (err) {
+        return planErrorResponse(c, err);
+      }
+    });
+  }
+  app.get(
+    "/api/files",
+    (c) => c.json({ files: searchFiles(refRoot, c.req.query("q") ?? "") })
+  );
+  app.get("/api/prompt", (c) => {
+    const custom = workspace?.readSystemPrompt();
+    return c.json({ system: custom ?? SYSTEM, default: SYSTEM, custom: custom !== void 0 });
+  });
+  app.put("/api/prompt", async (c) => {
+    const parsed = PromptSave.safeParse(await c.req.json().catch(() => null));
+    if (!parsed.success) {
+      return c.json({ error: "invalid prompt", detail: parsed.error.issues }, 400);
+    }
+    workspace?.writeSystemPrompt(parsed.data.system ?? void 0);
+    return c.json({ ok: true, persisted: Boolean(workspace) });
+  });
+  return app;
+}
+
+// server/login.ts
+import { parseArgs } from "node:util";
+
+// ../shared/src/cli-config.ts
+import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
+import { homedir, hostname } from "node:os";
+import { join as join4, dirname as dirname3 } from "node:path";
+
+// ../shared/src/schemas.ts
+import { z as z3 } from "zod";
+var planTierSchema = z3.enum(["hobby", "squad", "org"]);
+var jurisdictionSchema = z3.enum(["eu", "fedramp"]);
+var locationHintSchema = z3.enum([
+  "wnam",
+  "enam",
+  "weur",
+  "eeur",
+  "apac",
+  "oc",
+  "afr",
+  "me",
+  "sam"
+]);
+var sessionNameSchema = z3.string().min(1).max(63).regex(
+  /^[a-z0-9][a-z0-9-]*$/,
+  "Session name must be lowercase alphanumeric with hyphens, starting with a letter or digit"
+);
+var teamNameSchema = z3.string().min(1).max(63).regex(
+  /^[a-z0-9][a-z0-9-]*$/,
+  "Team name must be lowercase alphanumeric with hyphens"
+);
+var messageKindSchema = z3.enum(["text", "context", "request", "system"]);
+var messageContentSchema = z3.object({
+  kind: messageKindSchema,
+  // No .max() here: the 10 000-char body limit is business logic owned by the
+  // SessionActor (MAX_BODY_BYTES), which rejects with 413 MESSAGE_TOO_LARGE on
+  // both REST and WS. A schema cap would pre-empt it as a generic 400.
+  body: z3.string().min(1),
+  // Two-arg z.record: identical semantics in zod 3, required form in zod 4
+  // (specsketch bundles this file against zod 4 — keep every construct dual-safe).
+  metadata: z3.record(z3.string(), z3.unknown()).optional()
+});
+var createTeamInputSchema = z3.object({
+  name: teamNameSchema
+});
+var createSessionInputSchema = z3.object({
+  name: sessionNameSchema,
+  teamId: z3.string().optional(),
+  jurisdiction: jurisdictionSchema.optional(),
+  locationHint: locationHintSchema.optional()
+});
+var sendMessageInputSchema = z3.object({
+  content: messageContentSchema
+});
+var inviteInputSchema = z3.object({
+  email: z3.string().email(),
+  role: z3.enum(["admin", "member"]).default("member")
+});
+var joinTeamInputSchema = z3.object({
+  inviteCode: z3.string().min(1)
+});
+var markReadInputSchema = z3.object({
+  notificationIds: z3.array(z3.string().min(1))
+});
+var pollQuerySchema = z3.object({
+  since: z3.string().optional(),
+  limit: z3.coerce.number().int().min(1).max(100).default(50),
+  session: z3.string().optional()
+});
+var messagesQuerySchema = z3.object({
+  cursor: z3.string().optional(),
+  limit: z3.coerce.number().int().min(1).max(100).default(50)
+});
+var teamTypeSchema = z3.enum(["personal", "shared"]);
+var teamRoleSchema = z3.enum(["owner", "admin", "member"]);
+var accessPermissionSchema = z3.enum(["read", "write", "admin"]);
+var accessGrantInputSchema = z3.object({
+  userId: z3.string().min(1),
+  sessionName: sessionNameSchema.nullable().default(null),
+  // null = general
+  permission: accessPermissionSchema
+});
+var machineIdSchema = z3.string().min(1).max(63).regex(
+  /^[a-z0-9][a-z0-9-]*$/,
+  "Machine ID must be lowercase alphanumeric with hyphens, starting with a letter or digit"
+);
+var clerkProfileInputSchema = z3.object({
+  email: z3.string().email().nullable(),
+  displayName: z3.string().min(1).max(100),
+  avatarUrl: z3.string().url().nullable(),
+  provider: z3.string().min(1).max(50),
+  providerUserId: z3.string().min(1).max(100)
+});
+var sessionEnrollmentSchema = z3.object({
+  sessionId: z3.string(),
+  team: z3.string(),
+  teamName: z3.string().optional(),
+  key: z3.string().startsWith("api_"),
+  enrolledAt: z3.string().datetime(),
+  apiUrl: z3.string().url().optional(),
+  machineId: z3.string().optional()
+});
+var authConfigSchema = z3.object({
+  key: z3.string().startsWith("api_"),
+  userId: z3.string().min(1),
+  displayName: z3.string().nullable().optional().default(null),
+  email: z3.string().email().nullable(),
+  machineId: z3.string().nullable(),
+  authenticatedAt: z3.string().datetime()
+});
+var configBaseFields = {
+  apiUrl: z3.string().url(),
+  machineId: z3.string().nullable(),
+  sessions: z3.record(z3.string(), sessionEnrollmentSchema),
+  defaults: z3.object({
+    team: z3.string().nullable(),
+    session: z3.string().nullable()
+  }),
+  poll: z3.object({
+    lastPollAt: z3.string().datetime().nullable()
+  })
+};
+var coopConfigV1Schema = z3.object({
+  version: z3.literal(1),
+  ...configBaseFields
+});
+var coopConfigV2Schema = z3.object({
+  version: z3.literal(2),
+  ...configBaseFields,
+  auth: authConfigSchema.optional()
+});
+var profileNameSchema = z3.string().regex(
+  /^[a-z0-9][a-z0-9_-]{0,63}$/,
+  "Profile name must be lowercase alphanumeric with dashes/underscores, max 64 chars"
+);
+var coopProfileSchema = z3.object({
+  apiUrl: z3.string().url(),
+  auth: authConfigSchema.optional(),
+  sessions: z3.record(z3.string(), sessionEnrollmentSchema),
+  defaults: z3.object({
+    team: z3.string().nullable(),
+    session: z3.string().nullable()
+  }),
+  poll: z3.object({
+    lastPollAt: z3.string().datetime().nullable()
+  })
+});
+var coopConfigV3ObjectSchema = z3.object({
+  version: z3.literal(3),
+  machineId: z3.string().nullable(),
+  defaultProfile: z3.string(),
+  profiles: z3.record(profileNameSchema, coopProfileSchema)
+});
+function requireDefaultProfilePointer(config, ctx) {
+  if (!(config.defaultProfile in config.profiles)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultProfile"],
+      message: `defaultProfile "${config.defaultProfile}" does not name an existing profile`
+    });
+  }
+}
+var coopConfigV3Schema = coopConfigV3ObjectSchema.superRefine(
+  requireDefaultProfilePointer
+);
+var coopConfigSchema = z3.discriminatedUnion("version", [
+  coopConfigV1Schema,
+  coopConfigV2Schema,
+  coopConfigV3ObjectSchema
+]).superRefine((config, ctx) => {
+  if (config.version === 3) {
+    requireDefaultProfilePointer(config, ctx);
+  }
+});
+var hookStdinSchema = z3.object({
+  session_id: z3.string().optional(),
+  cwd: z3.string().optional(),
+  hook_event_name: z3.string().optional()
+}).passthrough();
+var wsClientMessageSchema = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("message"), content: messageContentSchema }),
+  z3.object({ type: z3.literal("presence_request") }),
+  z3.object({ type: z3.literal("ping") })
+]);
+
+// ../shared/src/cli-config.ts
+var DEFAULT_CONFIG_DIR = join4(homedir(), ".coopcli");
+var DEFAULT_CONFIG_PATH = join4(DEFAULT_CONFIG_DIR, "config.json");
+var PROD_API_URL = "https://api.coopcli.com";
+function emptyProfile(apiUrl) {
+  return {
+    apiUrl,
+    sessions: {},
+    defaults: { team: null, session: null },
+    poll: { lastPollAt: null }
+  };
+}
+var DEFAULT_CONFIG = {
+  version: 3,
+  machineId: hostname(),
+  defaultProfile: "default",
+  profiles: { default: emptyProfile(PROD_API_URL) }
+};
+function upgradeToV3(parsed) {
+  if (parsed.version === 3) return parsed;
+  const profile = {
+    apiUrl: parsed.apiUrl,
+    ...parsed.version === 2 && parsed.auth ? { auth: parsed.auth } : {},
+    sessions: parsed.sessions,
+    defaults: parsed.defaults,
+    poll: parsed.poll
+  };
+  return {
+    version: 3,
+    machineId: parsed.machineId,
+    defaultProfile: "default",
+    profiles: { default: profile }
+  };
+}
+function profileFromEnv(env, envVars) {
+  for (const name of envVars) {
+    const value = env[name];
+    if (value) return value;
+  }
+  return null;
+}
+var ConfigStore = class {
+  config = null;
+  selectedProfile = null;
+  configPath;
+  configDir;
+  constructor(configPath) {
+    this.configPath = configPath ?? DEFAULT_CONFIG_PATH;
+    this.configDir = dirname3(this.configPath);
+  }
+  /**
+   * Select the profile this store operates on for the rest of the process
+   * (--profile flag / COOP_PROFILE env). Without a selection, the
+   * defaultProfile pointer applies.
+   */
+  selectProfile(name) {
+    this.selectedProfile = name;
+  }
+  activeProfileName(config) {
+    return this.selectedProfile ?? config.defaultProfile;
+  }
+  view(config) {
+    const profileName = this.activeProfileName(config);
+    const profile = config.profiles[profileName];
+    if (!profile) {
+      const available = Object.keys(config.profiles).join(", ");
+      throw new Error(`Unknown profile "${profileName}". Available profiles: ${available}`);
+    }
+    return { profileName, machineId: config.machineId, ...profile };
+  }
+  /** Returns the active-profile view of the previously loaded config. Throws if load() hasn't been called. */
+  cached() {
+    return this.view(this.cachedRaw());
+  }
+  /** Returns the full previously loaded config. Throws if load() hasn't been called. */
+  cachedRaw() {
+    if (this.config === null) {
+      throw new Error("Config not loaded yet. Call load() first.");
+    }
+    return this.config;
+  }
+  /** Load the config file and return the active profile's view. */
+  async load() {
+    return this.view(await this.loadRaw());
+  }
+  /** Load the config file, normalized to v3. Legacy v1/v2 files upgrade in memory (persisted on next save). */
+  async loadRaw() {
+    if (this.config !== null) {
+      return this.config;
+    }
+    try {
+      const raw = await readFile(this.configPath, "utf8");
+      const parsed = upgradeToV3(coopConfigSchema.parse(JSON.parse(raw)));
+      if (!parsed.machineId) {
+        parsed.machineId = hostname();
+      }
+      this.config = parsed;
+      return parsed;
+    } catch (err) {
+      if (isNodeError(err) && err.code === "ENOENT") {
+        this.config = structuredClone(DEFAULT_CONFIG);
+        return this.config;
+      }
+      if (err instanceof SyntaxError || err?.name === "ZodError") {
+        throw new Error(`Config file (${this.configPath}) is corrupt. Reset with: rm ${this.configPath}`);
+      }
+      throw err;
+    }
+  }
+  async save(config) {
+    await mkdir(this.configDir, { recursive: true, mode: 448 });
+    const content = JSON.stringify(config, null, 2);
+    const tmpPath = this.configPath + ".tmp";
+    await writeFile(tmpPath, content, { mode: 384 });
+    const { rename } = await import("node:fs/promises");
+    await rename(tmpPath, this.configPath);
+    try {
+      await chmod(this.configPath, 384);
+    } catch {
+    }
+    this.config = config;
+  }
+  /** Load, transform the active profile, and save — the single write path for profile-scoped state. */
+  async saveProfile(mutate) {
+    const config = await this.loadRaw();
+    const name = this.activeProfileName(config);
+    const profile = config.profiles[name];
+    if (!profile) {
+      throw new Error(`Profile "${name}" not found in config (${this.configPath})`);
+    }
+    await this.save({
+      ...config,
+      profiles: { ...config.profiles, [name]: mutate(profile) }
+    });
+  }
+  /** Validate config for common misconfigurations. Returns warning strings. */
+  validate() {
+    if (!this.config) return [];
+    let view;
+    try {
+      view = this.view(this.config);
+    } catch {
+      return [];
+    }
+    const warnings = [];
+    try {
+      const url = new URL(view.apiUrl);
+      if (!["http:", "https:"].includes(url.protocol)) {
+        warnings.push(`apiUrl protocol "${url.protocol}" is not http/https`);
+      }
+    } catch {
+      warnings.push(`apiUrl "${view.apiUrl}" is not a valid URL`);
+    }
+    if (this.selectedProfile === null && (view.apiUrl.includes("localhost") || view.apiUrl.includes("127.0.0.1"))) {
+      warnings.push(
+        `profile "${view.profileName}" points to localhost \u2014 select it explicitly with --profile, or run coop login`
+      );
+    }
+    return warnings;
+  }
+  async enrollSession(name, enrollment) {
+    await this.saveProfile((profile) => ({
+      ...profile,
+      sessions: { ...profile.sessions, [name]: enrollment }
+    }));
+  }
+  async unenrollSession(name) {
+    await this.saveProfile((profile) => {
+      const sessions = { ...profile.sessions };
+      delete sessions[name];
+      const defaults = { ...profile.defaults };
+      if (defaults.session === name) {
+        defaults.session = null;
+      }
+      return { ...profile, sessions, defaults };
+    });
+  }
+  async setDefault(key, value) {
+    await this.saveProfile((profile) => ({
+      ...profile,
+      defaults: { ...profile.defaults, [key]: value }
+    }));
+  }
+  async getDefaultSession() {
+    const view = await this.load();
+    return view.defaults.session;
+  }
+  async getSessionKey(sessionName) {
+    const view = await this.load();
+    const enrollment = view.sessions[sessionName];
+    if (!enrollment) {
+      throw new Error(`Not enrolled in session "${sessionName}". Join it first.`);
+    }
+    return enrollment.key;
+  }
+  /** Resolve the API URL for a session, falling back to the active profile's apiUrl. */
+  async getApiUrl(sessionName) {
+    const view = await this.load();
+    if (sessionName) {
+      const enrollment = view.sessions[sessionName];
+      if (enrollment?.apiUrl) return enrollment.apiUrl;
+    }
+    return view.apiUrl;
+  }
+  /** Resolve the machine ID for a session, falling back to the global machineId or the profile's auth. */
+  async getMachineId(sessionName) {
+    const view = await this.load();
+    if (sessionName) {
+      const enrollment = view.sessions[sessionName];
+      if (enrollment?.machineId) return enrollment.machineId;
+    }
+    if (view.machineId) return view.machineId;
+    if (view.auth?.machineId) return view.auth.machineId;
+    return null;
+  }
+  async setMachineId(machineId) {
+    const config = await this.loadRaw();
+    await this.save({ ...config, machineId });
+  }
+  /** Set the active profile's API base URL. */
+  async setApiUrl(apiUrl) {
+    await this.saveProfile((profile) => ({ ...profile, apiUrl }));
+  }
+  /** Create the active profile (empty, at the given endpoint) if it does not exist yet. */
+  async ensureActiveProfile(apiUrl) {
+    const config = await this.loadRaw();
+    const name = this.activeProfileName(config);
+    if (config.profiles[name]) return;
+    await this.save({
+      ...config,
+      profiles: { ...config.profiles, [name]: emptyProfile(apiUrl) }
+    });
+  }
+  /** Re-point the defaultProfile fallback. The target must exist. */
+  async setDefaultProfile(name) {
+    const config = await this.loadRaw();
+    if (!config.profiles[name]) {
+      const available = Object.keys(config.profiles).join(", ");
+      throw new Error(`Unknown profile "${name}". Available profiles: ${available}`);
+    }
+    await this.save({ ...config, defaultProfile: name });
+  }
+  /** True if any profile holds an auth block (used to detect the first login). */
+  async hasAnyAuth() {
+    const config = await this.loadRaw();
+    return Object.values(config.profiles).some((profile) => profile.auth !== void 0);
+  }
+  /**
+   * Remove a profile including its credentials and enrollments. The
+   * defaultProfile pointer target cannot be deleted — re-point first.
+   */
+  async deleteProfile(name) {
+    const config = await this.loadRaw();
+    if (!config.profiles[name]) {
+      const available = Object.keys(config.profiles).join(", ");
+      throw new Error(`Unknown profile "${name}". Available profiles: ${available}`);
+    }
+    if (config.defaultProfile === name) {
+      throw new Error(
+        `Profile "${name}" is the default profile. Re-point it first: coop profile set-default <other>`
+      );
+    }
+    const profiles = { ...config.profiles };
+    delete profiles[name];
+    await this.save({ ...config, profiles });
+  }
+  async updateLastPoll() {
+    await this.saveProfile((profile) => ({
+      ...profile,
+      poll: { lastPollAt: (/* @__PURE__ */ new Date()).toISOString() }
+    }));
+  }
+  /** Returns true if the active profile has an auth block. */
+  isAuthenticated() {
+    if (this.config === null) return false;
+    return this.view(this.config).auth !== void 0;
+  }
+  /** Returns the user-scoped API key, or throws if not authenticated. */
+  getAuthKey() {
+    const auth = this.config === null ? void 0 : this.view(this.config).auth;
+    if (!auth) {
+      throw new Error("Not authenticated. Run `coop login` first.");
+    }
+    return auth.key;
+  }
+  /** Returns the user ID, or throws if not authenticated. */
+  getUserId() {
+    const auth = this.config === null ? void 0 : this.view(this.config).auth;
+    if (!auth) {
+      throw new Error("Not authenticated. Run `coop login` first.");
+    }
+    return auth.userId;
+  }
+  /**
+   * Saves the auth block into the active profile. Legacy v1/v2 files are
+   * normalized to v3 by load(), so the write always persists v3.
+   */
+  async setAuth(auth) {
+    await this.saveProfile((profile) => ({ ...profile, auth }));
+  }
+  /**
+   * Returns true if the user should be nudged to run `coop login`:
+   * the active profile has no auth block.
+   */
+  needsLoginNudge() {
+    if (this.config === null) return true;
+    return this.view(this.config).auth === void 0;
+  }
+  /**
+   * Removes the auth block from the active profile (for `coop logout`).
+   * Sessions are preserved.
+   */
+  async clearAuth() {
+    await this.saveProfile((profile) => {
+      const { auth: _removed, ...rest } = profile;
+      return rest;
+    });
+  }
+};
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+
+// ../shared/src/cli-auth.ts
+import { exec } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { hostname as hostname2 } from "node:os";
+import { URL as URL2 } from "node:url";
+function resolveDisplayName(name, email, userId) {
+  if (name && !name.startsWith("user_")) return name;
+  if (email) return email.split("@")[0];
+  if (userId) return userId.slice(0, 12);
+  if (name) return name.slice(0, 12);
+  return "unknown";
+}
+async function openBrowser(url) {
+  const escaped = url.replace(/"/g, '\\"');
+  const cmd = process.platform === "darwin" ? `open "${escaped}"` : process.platform === "win32" ? `start "" "${escaped}"` : `xdg-open "${escaped}"`;
+  return new Promise((resolve6) => {
+    exec(cmd, () => resolve6());
+  });
+}
+var PAGE_STYLE = "body{background:#0f0f0f;color:#e8e8e8;font-family:system-ui;display:flex;justify-content:center;padding-top:4rem}";
+function htmlPage(title, body) {
+  return `<!DOCTYPE html><html><head><title>${title}</title><style>${PAGE_STYLE}</style></head><body><div><h2>${title}</h2><p>${body}</p></div></body></html>`;
+}
+function startLocalhostServer(options) {
+  const timeout = options.timeout ?? 12e4;
+  const loginCommand = options.loginCommand ?? "coop login";
+  return new Promise((resolveServer, rejectServer) => {
+    let resolveCallback;
+    let rejectCallback;
+    const callbackPromise = new Promise((res, rej) => {
+      resolveCallback = res;
+      rejectCallback = rej;
+    });
+    const timer = setTimeout(() => {
+      rejectCallback(new Error(`Login timed out. No browser callback received. Check your browser and try \`${loginCommand}\` again.`));
+      server.close();
+    }, timeout);
+    const server = createServer((req, res) => {
+      const url = new URL2(req.url ?? "/", `http://127.0.0.1`);
+      if (url.pathname === "/") {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(htmlPage("Waiting for Authentication", `This page was opened by <code>${loginCommand}</code>. Complete sign-in in the browser window.`));
+        return;
+      }
+      if (url.pathname === "/callback") {
+        const state = url.searchParams.get("state") ?? "";
+        if (state !== options.expectedState) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(htmlPage("State Mismatch", `Possible CSRF attack. Try <code>${loginCommand}</code> again.`));
+          return;
+        }
+        const key = url.searchParams.get("key") ?? "";
+        if (!key) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(htmlPage("Missing Key", `No API key received. Try <code>${loginCommand}</code> again.`));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(htmlPage("Authentication Complete", "You can close this tab."));
+        clearTimeout(timer);
+        resolveCallback({
+          key,
+          userId: url.searchParams.get("userId") ?? "",
+          email: url.searchParams.get("email") ?? "",
+          displayName: url.searchParams.get("displayName") ?? "",
+          state,
+          apiUrl: url.searchParams.get("apiUrl") ?? ""
+        });
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      resolveServer({
+        port,
+        close: () => {
+          clearTimeout(timer);
+          server.close();
+        },
+        waitForCallback: () => callbackPromise
+      });
+    });
+    server.on("error", (err) => {
+      clearTimeout(timer);
+      rejectServer(err);
+    });
+  });
+}
+function deriveApiUrl(webUrl) {
+  const url = new URL2(webUrl);
+  if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
+    return "http://localhost:8788";
+  }
+  return `https://api.${url.hostname}`;
+}
+async function login(input, deps) {
+  const state = randomBytes(16).toString("hex");
+  const machineId = input.machine ?? hostname2();
+  const server = await startLocalhostServer({ expectedState: state, loginCommand: input.loginCommand });
+  try {
+    const webUrl = input.webUrl ?? "https://coopcli.com";
+    const authUrl = `${webUrl}/cli-auth?port=${server.port}&state=${state}&machine=${encodeURIComponent(machineId)}`;
+    process.stderr.write(`Opening browser for authentication...
+`);
+    await deps.openBrowser(authUrl);
+    process.stderr.write(`Waiting for callback on port ${server.port}...
+`);
+    const params = await server.waitForCallback();
+    const displayName = resolveDisplayName(params.displayName, params.email, params.userId);
+    const resolvedApiUrl = input.apiUrl ?? (params.apiUrl || deriveApiUrl(webUrl));
+    const isFirstLogin = !await deps.config.hasAnyAuth();
+    await deps.config.ensureActiveProfile(resolvedApiUrl);
+    await deps.config.setAuth({
+      key: params.key,
+      userId: params.userId,
+      displayName,
+      email: params.email || null,
+      machineId,
+      authenticatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const config = await deps.config.load();
+    if (params.apiUrl && config.apiUrl && params.apiUrl !== config.apiUrl) {
+      process.stderr.write(
+        `
+Backend mismatch: you authenticated against ${params.apiUrl}
+  but your config points to ${config.apiUrl}
+  Updating config to ${resolvedApiUrl}
+
+`
+      );
+    }
+    if (resolvedApiUrl !== config.apiUrl) {
+      await deps.config.setApiUrl(resolvedApiUrl);
+    }
+    if (isFirstLogin) {
+      await deps.config.setDefaultProfile(config.profileName);
+    }
+    return {
+      userId: params.userId,
+      email: params.email || null,
+      displayName
+    };
+  } finally {
+    server.close();
+  }
+}
+
+// server/login.ts
+var LOGIN_USAGE = `Usage: specplan login [--profile <name>] [--web-url <url>]
+
+Opens your browser to sign in to CoopCLI and saves credentials to
+~/.coopcli/config.json \u2014 the same file and format \`coop login\` uses.
+
+--profile   config profile to log into (default: SPECPLAN_COOP_PROFILE,
+            then COOP_PROFILE, then the config's default profile). A profile
+            that doesn't exist yet is created.
+--web-url   web app URL for browser auth (default: https://coopcli.com)`;
+var LoginUsageError = class extends Error {
+};
+function parseLoginArgs(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      options: { profile: { type: "string" }, "web-url": { type: "string" } },
+      allowPositionals: true
+    });
+  } catch (err) {
+    throw new LoginUsageError(err instanceof Error ? err.message : String(err));
+  }
+  if (parsed.positionals.length > 0) {
+    throw new LoginUsageError(`unexpected argument: ${parsed.positionals[0]}`);
+  }
+  return {
+    profile: parsed.values.profile ?? null,
+    ...parsed.values["web-url"] !== void 0 ? { webUrl: parsed.values["web-url"] } : {}
+  };
+}
+async function runLogin(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const config = deps.config ?? new ConfigStore();
+  const profile = args.profile ?? profileFromEnv(env, ["SPECPLAN_COOP_PROFILE", "COOP_PROFILE"]);
+  if (profile) config.selectProfile(profile);
+  const result = await login(
+    { webUrl: args.webUrl, loginCommand: "specplan login" },
+    { config, openBrowser: deps.openBrowser ?? openBrowser }
+  );
+  (deps.log ?? console.log)(`Authenticated as ${result.email ?? result.userId}. Credentials saved.`);
+}
+
+// server/validate.ts
+function collectTreeErrors(rootDir) {
+  const store = new PlanStore(rootDir);
+  let plan;
+  try {
+    plan = store.load();
+  } catch (err) {
+    return [err instanceof Error ? err.message : String(err)];
+  }
+  const errors = planErrors(plan);
+  const nodeIds = new Set(plan.nodes.map((n) => n.id));
+  for (const node of plan.nodes) {
+    if (node.type !== "spec") continue;
+    let meta;
+    try {
+      meta = store.readSpecMeta(node.id);
+    } catch (err) {
+      errors.push(err instanceof PlanFileError ? err.message : String(err));
+      continue;
+    }
+    if (meta === null) {
+      errors.push(`${node.id}: per-spec file missing (${node.specFile})`);
+      continue;
+    }
+    if (meta.specId !== node.id) {
+      errors.push(
+        `changes/${node.id}/specplan.yaml: specId "${meta.specId}" does not match its change directory "${node.id}"`
+      );
+    }
+    for (const ref of [...meta.userStories, ...meta.dependencies]) {
+      if (!nodeIds.has(ref)) {
+        errors.push(`changes/${node.id}/specplan.yaml: references unknown node ${ref}`);
+      }
+    }
+  }
+  return errors;
+}
+function validateCommand(rootDir, log = console.log, logError = console.error) {
+  const errors = collectTreeErrors(rootDir);
+  if (errors.length > 0) {
+    for (const e of errors) logError(`\u2717 ${e}`);
+    logError(`specplan: plan is invalid \u2014 ${errors.length} error${errors.length === 1 ? "" : "s"}`);
+    return 1;
+  }
+  const plan = new PlanStore(rootDir).load();
+  log(`plan is valid \u2014 ${plan.nodes.length} nodes, ${plan.edges.length} edges`);
+  return 0;
+}
+
+// server/workspace.ts
+import { join as join5, resolve as resolve4 } from "node:path";
+import { mkdirSync as mkdirSync3 } from "node:fs";
+var SIDECAR_FILE = "specplan-ui.json";
+var PlanWorkspace = class {
+  /** Resolved openspec root directory. */
+  dir;
+  constructor(dir) {
+    this.dir = resolve4(dir);
+    mkdirSync3(this.dir, { recursive: true });
+  }
+  // ── Sidecar ──────────────────────────────────────────────────────────────
+  readSidecar() {
+    const raw = readIfExists(join5(this.dir, SIDECAR_FILE));
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  updateSidecar(update) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const current = this.readSidecar();
+    const next = update(current);
+    next.createdAt ??= now;
+    next.updatedAt = now;
+    writeAtomicFile(join5(this.dir, SIDECAR_FILE), JSON.stringify(next, null, 2));
+  }
+  readModel() {
+    return this.readSidecar().model;
+  }
+  readPositions() {
+    return this.readSidecar().positions ?? {};
+  }
+  /** One sidecar write for the debounced UI autosave (model + positions). */
+  writeUiState(state) {
+    this.updateSidecar((s) => ({
+      ...s,
+      ...state.model !== void 0 ? { model: state.model } : {},
+      ...state.positions !== void 0 ? { positions: state.positions } : {}
+    }));
+  }
+  // ── Assistant chat ───────────────────────────────────────────────────────
+  readChat() {
+    return this.readSidecar().chat ?? [];
+  }
+  writeChat(chat) {
+    this.updateSidecar((s) => ({ ...s, chat }));
+  }
+  // ── Generation system prompt override ────────────────────────────────────
+  readSystemPrompt() {
+    return this.readSidecar().systemPrompt;
+  }
+  /** `undefined` clears the override (reset to the built-in default). */
+  writeSystemPrompt(systemPrompt) {
+    this.updateSidecar(({ systemPrompt: _prev, ...s }) => ({
+      ...s,
+      ...systemPrompt !== void 0 ? { systemPrompt } : {}
+    }));
+  }
+};
+
+// server/cli.ts
+var USAGE = `Usage: specplan [rootDir] [--port <n>]
+       specplan generate <specId> [rootDir]
+       specplan validate [rootDir]
+       specplan login [--profile <name>] [--web-url <url>]
+
+  specplan                       # plan ./openspec in the browser
+  specplan ../other-repo/openspec --port 9000
+
+rootDir is the OpenSpec root to plan (default ./openspec, created if
+missing). The plan autosaves to specplan.yaml inside it, plus one
+specplan.yaml per openspec/changes/<specId>/ directory.
+
+--port sets the preferred port (default 8789); if it's already in use the
+server moves to the next available port and prints the actual URL.
+
+generate <specId> runs OpenSpec generation for one spec card headlessly;
+exits non-zero when the output fails \`openspec validate --strict\`.
+
+validate checks the plan files (schema, acyclicity, containment, story
+formula, id references) and exits non-zero with named errors.
+
+login authenticates this machine against your CoopCLI account (opens a
+browser, saves credentials to ~/.coopcli/config.json).`;
+var UsageError = class extends Error {
+};
+var DEFAULT_ROOT_DIR = "./openspec";
+var DEFAULT_PORT = 8789;
+function parseCliArgs(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs2({
+      args: argv,
+      options: { port: { type: "string" } },
+      allowPositionals: true
+    });
+  } catch (err) {
+    throw new UsageError(err instanceof Error ? err.message : String(err));
+  }
+  const [rootDir = DEFAULT_ROOT_DIR, ...rest] = parsed.positionals;
+  if (rest.length > 0) throw new UsageError("expected at most one root directory");
+  const port = parsed.values.port === void 0 ? DEFAULT_PORT : Number(parsed.values.port);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new UsageError(`invalid --port: ${String(parsed.values.port)}`);
+  }
+  return { rootDir, port };
+}
+var PORT_SCAN_LIMIT = 100;
+async function bindAvailablePort(start, tryBind) {
+  const end = Math.min(start + PORT_SCAN_LIMIT - 1, 65535);
+  for (let port = start; port <= end; port++) {
+    try {
+      return { port: await tryBind(port), moved: port !== start };
+    } catch (err) {
+      if (err.code !== "EADDRINUSE") throw err;
+    }
+  }
+  throw new Error(`no free port between ${start} and ${end} \u2014 free one up or pass --port`);
+}
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".json": "application/json",
+  ".map": "application/json",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff"
+};
+function resolveClientDir(moduleUrl) {
+  const here = dirname4(fileURLToPath(moduleUrl));
+  const candidates = [
+    join6(here, "..", "client"),
+    // packed: dist/cli -> dist/client
+    join6(here, "..", "dist", "client")
+    // repo: server/ -> dist/client
+  ];
+  for (const dir of candidates) {
+    if (existsSync4(join6(dir, "index.html"))) return dir;
+  }
+  return null;
+}
+function staticResponse(clientDir, pathname) {
+  const rel = normalize2(decodeURIComponent(pathname)).replace(/^\/+/, "");
+  const target = resolve5(clientDir, rel === "" ? "index.html" : rel);
+  if (!target.startsWith(resolve5(clientDir))) return null;
+  const file = existsSync4(target) && extname(target) ? target : join6(clientDir, "index.html");
+  if (!existsSync4(file)) return null;
+  return new Response(readFileSync4(file), {
+    headers: { "Content-Type": MIME[extname(file)] ?? "application/octet-stream" }
+  });
+}
+var CREDENTIALS_HINT = `No Anthropic credentials detected. The canvas works without them,
+but chat and "Generate OpenSpec" need one of:
+
+  \u2022 ANTHROPIC_API_KEY set in your environment
+      export ANTHROPIC_API_KEY=sk-ant-...
+  \u2022 or the Anthropic CLI's login profile (no key handling needed):
+      brew install anthropics/tap/ant   # macOS
+      ant auth login`;
+function detectCredentialSource(env = process.env, home = homedir2()) {
+  if (env.ANTHROPIC_API_KEY) return "ANTHROPIC_API_KEY";
+  if (env.ANTHROPIC_AUTH_TOKEN) return "ANTHROPIC_AUTH_TOKEN";
+  try {
+    const dir = join6(home, ".config", "anthropic", "credentials");
+    if (readdirSync4(dir).some((f) => f.endsWith(".json"))) return "anthropic profile";
+  } catch {
+  }
+  return null;
+}
+function preflight(log = console.log) {
+  const major = Number(process.versions.node.split(".")[0]);
+  if (major < 22) {
+    log(`\u26A0 Node ${process.versions.node} detected \u2014 specplan needs Node >= 22.`);
+    log("  Install a current Node (https://nodejs.org) and rerun.");
+    process.exit(1);
+  }
+}
+async function main(argv) {
+  preflight();
+  if (argv[0] === "login") {
+    let loginArgs;
+    try {
+      loginArgs = parseLoginArgs(argv.slice(1));
+    } catch (err) {
+      console.error(
+        err instanceof LoginUsageError ? `specplan: ${err.message}
+
+${LOGIN_USAGE}` : err
+      );
+      process.exit(1);
+    }
+    try {
+      await runLogin(loginArgs);
+    } catch (err) {
+      console.error(`specplan: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+    return;
+  }
+  if (argv[0] === "validate") {
+    const [rootDir = DEFAULT_ROOT_DIR, ...rest] = argv.slice(1);
+    if (rest.length > 0 || rootDir.startsWith("-")) {
+      console.error(`specplan: validate takes at most one root directory
+
+${USAGE}`);
+      process.exit(1);
+    }
+    process.exit(validateCommand(rootDir));
+  }
+  if (argv[0] === "generate") {
+    const [specId, rootDir = DEFAULT_ROOT_DIR, ...rest] = argv.slice(1);
+    if (!specId || specId.startsWith("-") || rest.length > 0) {
+      console.error(`specplan: generate takes a spec id and at most one root directory
+
+${USAGE}`);
+      process.exit(1);
+    }
+    const workspace2 = new PlanWorkspace(rootDir);
+    const store2 = new PlanStore(rootDir);
+    const model = GENERATION_MODELS.find((m) => m === workspace2.readModel()) ?? DEFAULT_MODEL;
+    try {
+      const result = await generateForSpec(
+        {
+          anthropic: new Anthropic(),
+          store: store2,
+          systemPrompt: workspace2.readSystemPrompt(),
+          refRoot: process.cwd()
+        },
+        specId,
+        model
+      );
+      if (result.mode === "metadata-only") {
+        console.log(
+          `specplan: ${specId} body is hand-edited \u2014 updated metadata only (changes/${specId}/specplan.yaml)`
+        );
+      } else {
+        console.log(
+          `specplan: generated ${specId} (${result.changedFiles.length} file${result.changedFiles.length === 1 ? "" : "s"} changed) \u2014 openspec validate --strict passed`
+        );
+        for (const f of result.changedFiles) console.log(`  ${f}`);
+      }
+    } catch (err) {
+      console.error(`specplan: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+    return;
+  }
+  let args;
+  try {
+    args = parseCliArgs(argv);
+  } catch (err) {
+    console.error(err instanceof UsageError ? `specplan: ${err.message}
+
+${USAGE}` : err);
+    process.exit(1);
+  }
+  const clientDir = resolveClientDir(import.meta.url);
+  if (!clientDir) {
+    console.error("specplan: built UI assets not found (dist/client missing).");
+    process.exit(1);
+  }
+  const workspace = new PlanWorkspace(args.rootDir);
+  const store = new PlanStore(args.rootDir);
+  const app = createApp(new Anthropic(), workspace, store);
+  app.get("*", (c) => {
+    const res = staticResponse(clientDir, new URL(c.req.url).pathname);
+    return res ?? c.notFound();
+  });
+  const tryBind = (port2) => new Promise((bound, failed) => {
+    const server = serve({ fetch: app.fetch, port: port2, hostname: "127.0.0.1" }, (info) => {
+      bound(info.port);
+    });
+    server.once("error", (err) => {
+      try {
+        server.close();
+      } catch {
+      }
+      failed(err);
+    });
+  });
+  let port;
+  let moved;
+  try {
+    ({ port, moved } = await bindAvailablePort(args.port, tryBind));
+  } catch (err) {
+    console.error(`specplan: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const source = detectCredentialSource();
+  console.log(`coopcli specplan`);
+  console.log(`  plan root: ${workspace.dir}`);
+  console.log(`  open:      http://127.0.0.1:${port}`);
+  if (moved) {
+    console.log(`  port:      ${args.port} was in use \u2014 moved to ${port}`);
+  }
+  if (source) {
+    console.log(`  auth:      ${source}`);
+  } else {
+    console.log(`
+\u26A0 ${CREDENTIALS_HINT}
+`);
+  }
+}
+
+// server/cli-entry.ts
+void main(process.argv.slice(2));