@coopcli/specplan 5.3.1 → 5.5.0

package/dist/cli/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // server/cli.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync4 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync3 } 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 { dirname as dirname5, extname, join as join7, 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";
@@ -189,7 +189,6 @@ var PromptInfo = z.object({
 });
 
 // server/app.ts
-import { basename as basename3 } from "node:path";
 import { Hono } from "hono";
 
 // src/lib/dag.ts
@@ -329,10 +328,9 @@ function planErrors(plan) {
 
 // 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 { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
 import { promisify } from "node:util";
 import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";
 
@@ -605,6 +603,78 @@ ${note}${r.content}
   return parts.join("\n\n");
 }
 
+// server/spec-state.ts
+import { createHash } from "node:crypto";
+import { dirname as dirname2, join as join2 } from "node:path";
+
+// server/fs-node.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "node:fs";
+var nodeSyncFs = {
+  readIfExists(path) {
+    return readIfExists(path);
+  },
+  writeAtomicFile(path, content) {
+    writeAtomicFile(path, content);
+  },
+  exists(path) {
+    return existsSync2(path);
+  },
+  mkdirp(path) {
+    mkdirSync2(path, { recursive: true });
+  },
+  readdir(path) {
+    if (!existsSync2(path)) return [];
+    return readdirSync2(path, { withFileTypes: true }).map((entry) => ({
+      name: entry.name,
+      directory: entry.isDirectory()
+    }));
+  }
+};
+
+// server/spec-state.ts
+var sha256 = (s) => createHash("sha256").update(s).digest("hex");
+function listBodyFiles(changeDir, fsx = nodeSyncFs) {
+  const files = [];
+  for (const name of ["proposal.md", "design.md", "tasks.md"]) {
+    if (fsx.exists(join2(changeDir, name))) files.push(name);
+  }
+  const specsDir = join2(changeDir, "specs");
+  for (const entry of fsx.readdir(specsDir).sort((a, b) => a.name.localeCompare(b.name))) {
+    const rel = join2("specs", entry.name, "spec.md");
+    if (entry.directory && fsx.exists(join2(changeDir, rel))) files.push(rel);
+  }
+  return files;
+}
+function bodyHash(changeDir, fsx = nodeSyncFs) {
+  const files = listBodyFiles(changeDir, fsx);
+  if (files.length === 0) return null;
+  const parts = files.map(
+    (rel) => `${rel}
+${sha256(fsx.readIfExists(join2(changeDir, rel)) ?? "")}`
+  );
+  return `sha256:${sha256(parts.join("\n"))}`;
+}
+function specState(store, specId) {
+  const changeDir = dirname2(store.specMetaPath(specId));
+  const currentHash = bodyHash(changeDir, store.fsx);
+  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, store.fsx).map((rel) => ({ path: rel, content: store.fsx.readIfExists(join2(changeDir, rel)) })).filter((f) => f.content !== void 0);
+}
+
 // 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
@@ -641,62 +711,18 @@ var GenerationFailed = class extends Error {
   }
   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"));
+  let dir = dirname3(require2.resolve("@fission-ai/openspec"));
   for (; ; ) {
-    const pkgPath = join2(dir, "package.json");
-    if (existsSync2(pkgPath)) {
+    const pkgPath = join3(dir, "package.json");
+    if (existsSync3(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 ?? "");
+        return join3(dir, typeof pkg.bin === "string" ? pkg.bin : pkg.bin.openspec ?? "");
       }
     }
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) throw new Error("could not locate the @fission-ai/openspec bin");
     dir = parent;
   }
@@ -707,7 +733,7 @@ async function runOpenspecValidate(specId, rootDir) {
     const { stdout, stderr } = await promisify(execFile)(
       process.execPath,
       [bin, "validate", specId, "--strict"],
-      { cwd: dirname2(resolve2(rootDir)) }
+      { cwd: dirname3(resolve2(rootDir)) }
     );
     return { ok: true, output: `${stdout}${stderr}`.trim() };
   } catch (err) {
@@ -736,7 +762,7 @@ 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} ---
+  const sections = listBodyFiles(changeDir).map((rel) => ({ rel, content: readIfExists(join3(changeDir, rel)) })).filter((f) => f.content !== void 0).map((f) => `--- ${f.rel} ---
 ${f.content}`);
   if (sections.length === 0) return "";
   return `
@@ -751,11 +777,11 @@ function writeBundle(changeDir, bundle) {
     "design.md": bundle.design,
     "tasks.md": bundle.tasks
   };
-  for (const s of bundle.specs) files[join2("specs", s.capability, "spec.md")] = s.spec;
+  for (const s of bundle.specs) files[join3("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);
+    if (readIfExists(join3(changeDir, rel)) === content) continue;
+    writeAtomicFile(join3(changeDir, rel), content);
     written.push(rel);
   }
   return written;
@@ -769,7 +795,7 @@ async function generateForSpec(deps, specId, model = DEFAULT_MODEL) {
   }
   const stories = storyNodes(plan, specId);
   const depSpecs = depNodes(plan, specId);
-  const changeDir = dirname2(store.specMetaPath(specId));
+  const changeDir = dirname3(store.specMetaPath(specId));
   store.writeSpecMeta(
     specId,
     stories.map((s) => s.id),
@@ -836,9 +862,11 @@ function depNodes(plan, specId) {
   return specDependencies(plan, specId).map((id) => byId.get(id)).filter((n) => n?.type === "spec");
 }
 
+// server/plan-routes.ts
+import { basename as basename3 } from "node:path";
+
 // 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 { basename as basename2, join as join4, resolve as resolve3 } from "node:path";
 import { Document, parseDocument } from "yaml";
 
 // server/ulid.ts
@@ -904,16 +932,19 @@ var META_FILE = "specplan.yaml";
 var PlanStore = class {
   /** Resolved openspec root directory. */
   dir;
-  constructor(dir) {
+  /** IO substrate — real disk by default, in-memory for the cloud target. */
+  fsx;
+  constructor(dir, fsx = nodeSyncFs) {
     this.dir = resolve3(dir);
-    mkdirSync2(this.dir, { recursive: true });
+    this.fsx = fsx;
+    this.fsx.mkdirp(this.dir);
   }
   // ── Root file ────────────────────────────────────────────────────────────
   rootPath() {
-    return join3(this.dir, ROOT_FILE);
+    return join4(this.dir, ROOT_FILE);
   }
   loadDoc() {
-    const raw = readIfExists(this.rootPath());
+    const raw = this.fsx.readIfExists(this.rootPath());
     if (raw === void 0) return new Document({ version: 1, nodes: [], edges: [] });
     const doc = parseDocument(raw);
     const fault = doc.errors[0];
@@ -936,7 +967,7 @@ var PlanStore = class {
     return this.planOf(this.loadDoc());
   }
   save(doc) {
-    writeAtomicFile(this.rootPath(), doc.toString());
+    this.fsx.writeAtomicFile(this.rootPath(), doc.toString());
   }
   // ── Ids ──────────────────────────────────────────────────────────────────
   mintId(prefix, existing) {
@@ -971,7 +1002,7 @@ var PlanStore = class {
   }
   /** A fresh per-spec metadata file: empty relations, explicit draft status. */
   initSpecMeta(specId) {
-    writeAtomicFile(
+    this.fsx.writeAtomicFile(
       this.specMetaPath(specId),
       new Document({
         specId,
@@ -1047,17 +1078,15 @@ var PlanStore = class {
    * next refresh. Never touches a change's body files.
    */
   adoptExistingChanges() {
-    const changesDir = join3(this.dir, "changes");
-    if (!existsSync3(changesDir)) return [];
+    const changesDir = join4(this.dir, "changes");
+    if (!this.fsx.exists(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(".")) {
+    for (const entry of this.fsx.readdir(changesDir).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (!entry.directory || entry.name === "archive" || entry.name.startsWith(".")) {
         continue;
       }
       if (known.has(entry.name)) continue;
@@ -1083,10 +1112,10 @@ var PlanStore = class {
   }
   // ── Per-spec metadata files ──────────────────────────────────────────────
   specMetaPath(specId) {
-    return join3(this.dir, "changes", specId, META_FILE);
+    return join4(this.dir, "changes", specId, META_FILE);
   }
   readSpecMeta(specId) {
-    const raw = readIfExists(this.specMetaPath(specId));
+    const raw = this.fsx.readIfExists(this.specMetaPath(specId));
     if (raw === void 0) return null;
     const doc = parseDocument(raw);
     const fault = doc.errors[0];
@@ -1104,12 +1133,12 @@ var PlanStore = class {
    */
   writeSpecMeta(specId, userStories, dependencies) {
     const path = this.specMetaPath(specId);
-    const raw = readIfExists(path);
+    const raw = this.fsx.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());
+    this.fsx.writeAtomicFile(path, doc.toString());
   }
   /**
    * Set a spec's lifecycle status (draft | active | done | deferred) in its
@@ -1120,22 +1149,144 @@ var PlanStore = class {
     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 raw = this.fsx.readIfExists(path);
     const doc = raw === void 0 ? new Document({ specId, userStories: [], dependencies: [] }) : parseDocument(raw);
     doc.setIn(["status"], status);
-    writeAtomicFile(path, doc.toString());
+    this.fsx.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 raw = this.fsx.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());
+    this.fsx.writeAtomicFile(path, doc.toString());
   }
 };
 
+// server/plan-routes.ts
+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 registerPlanRoutes(app, store, workspace) {
+  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/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);
+    }
+  });
+}
+
 // server/tools.ts
 import { z as z2 } from "zod";
 var CreateSpecInput = z2.object({ title: z2.string().min(1) });
@@ -1319,11 +1470,6 @@ function anthropicErrorResponse(c, err, kind) {
   }
   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();
@@ -1337,85 +1483,7 @@ function createApp(anthropic, workspace, store, options) {
     })
   );
   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);
-      }
-    });
+    registerPlanRoutes(app, store, workspace);
     app.post("/api/generate", async (c) => {
       const parsed = GenerateRequest.safeParse(await c.req.json().catch(() => null));
       if (!parsed.success) {
@@ -1531,40 +1599,6 @@ ${renderPlanContext(chatPlan, statuses)}`;
       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",
@@ -1591,7 +1625,7 @@ 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";
+import { join as join5, dirname as dirname4 } from "node:path";
 
 // ../shared/src/schemas.ts
 import { z as z3 } from "zod";
@@ -1771,8 +1805,8 @@ var wsClientMessageSchema = z3.discriminatedUnion("type", [
 ]);
 
 // ../shared/src/cli-config.ts
-var DEFAULT_CONFIG_DIR = join4(homedir(), ".coopcli");
-var DEFAULT_CONFIG_PATH = join4(DEFAULT_CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG_DIR = join5(homedir(), ".coopcli");
+var DEFAULT_CONFIG_PATH = join5(DEFAULT_CONFIG_DIR, "config.json");
 var PROD_API_URL = "https://api.coopcli.com";
 function emptyProfile(apiUrl) {
   return {
@@ -1818,7 +1852,7 @@ var ConfigStore = class {
   configDir;
   constructor(configPath) {
     this.configPath = configPath ?? DEFAULT_CONFIG_PATH;
-    this.configDir = dirname3(this.configPath);
+    this.configDir = dirname4(this.configPath);
   }
   /**
    * Select the profile this store operates on for the rest of the process
@@ -2337,19 +2371,21 @@ function validateCommand(rootDir, log = console.log, logError = console.error) {
 }
 
 // server/workspace.ts
-import { join as join5, resolve as resolve4 } from "node:path";
-import { mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join6, resolve as resolve4 } from "node:path";
 var SIDECAR_FILE = "specplan-ui.json";
 var PlanWorkspace = class {
   /** Resolved openspec root directory. */
   dir;
-  constructor(dir) {
+  /** IO substrate — real disk by default, in-memory for the cloud target. */
+  fsx;
+  constructor(dir, fsx = nodeSyncFs) {
     this.dir = resolve4(dir);
-    mkdirSync3(this.dir, { recursive: true });
+    this.fsx = fsx;
+    this.fsx.mkdirp(this.dir);
   }
   // ── Sidecar ──────────────────────────────────────────────────────────────
   readSidecar() {
-    const raw = readIfExists(join5(this.dir, SIDECAR_FILE));
+    const raw = this.fsx.readIfExists(join6(this.dir, SIDECAR_FILE));
     if (!raw) return {};
     try {
       return JSON.parse(raw);
@@ -2363,7 +2399,7 @@ var PlanWorkspace = class {
     const next = update(current);
     next.createdAt ??= now;
     next.updatedAt = now;
-    writeAtomicFile(join5(this.dir, SIDECAR_FILE), JSON.stringify(next, null, 2));
+    this.fsx.writeAtomicFile(join6(this.dir, SIDECAR_FILE), JSON.stringify(next, null, 2));
   }
   readModel() {
     return this.readSidecar().model;
@@ -2471,15 +2507,15 @@ var MIME = {
   ".woff": "font/woff"
 };
 function resolveClientDir(moduleUrl) {
-  const here = dirname4(fileURLToPath(moduleUrl));
+  const here = dirname5(fileURLToPath(moduleUrl));
   const candidates = [
-    join6(here, "..", "client"),
+    join7(here, "..", "client"),
     // packed: dist/cli -> dist/client
-    join6(here, "..", "dist", "client")
+    join7(here, "..", "dist", "client")
     // repo: server/ -> dist/client
   ];
   for (const dir of candidates) {
-    if (existsSync4(join6(dir, "index.html"))) return dir;
+    if (existsSync4(join7(dir, "index.html"))) return dir;
   }
   return null;
 }
@@ -2487,7 +2523,7 @@ 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");
+  const file = existsSync4(target) && extname(target) ? target : join7(clientDir, "index.html");
   if (!existsSync4(file)) return null;
   return new Response(readFileSync4(file), {
     headers: { "Content-Type": MIME[extname(file)] ?? "application/octet-stream" }
@@ -2505,8 +2541,8 @@ 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";
+    const dir = join7(home, ".config", "anthropic", "credentials");
+    if (readdirSync3(dir).some((f) => f.endsWith(".json"))) return "anthropic profile";
   } catch {
   }
   return null;