@coopcli/specsketch 5.5.4 → 5.5.7

package/dist/cli/index.js

@@ -1,18 +1,343 @@
 #!/usr/bin/env node
 
 // server/cli.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname3, extname, join as join5, normalize as normalize2, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync4, readdirSync as readdirSync5 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, extname, join as join7, normalize as normalize2, resolve as resolve3 } 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";
+
+// ../agent-harness/src/model-auth.ts
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var ModelAuthError = class extends Error {
+};
+var API_ENV_KEYS = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"];
+function hasAntAuthProfile(home) {
+  try {
+    return readdirSync(join(home, ".config", "anthropic", "credentials")).some(
+      (f) => f.endsWith(".json")
+    );
+  } catch {
+    return false;
+  }
+}
+function resolveModelCredential(opts = {}) {
+  const env = opts.env ?? process.env;
+  const home = opts.home ?? homedir();
+  const useApi = Boolean(opts.useApi) || Boolean(env.COOP_USE_API);
+  const hasApiKey = Boolean(env.ANTHROPIC_API_KEY);
+  const hasAntAuth = Boolean(env.ANTHROPIC_AUTH_TOKEN) || hasAntAuthProfile(home);
+  const hasSubscription = existsSync(join(home, ".claude", ".credentials.json"));
+  if (useApi) {
+    if (hasApiKey || hasAntAuth) return apiResult(env, hasApiKey ? "api-key" : "ant-auth");
+    throw new ModelAuthError(
+      "--api / COOP_USE_API is set but no API credential was found. Set ANTHROPIC_API_KEY=sk-ant-\u2026 or run `ant auth login`."
+    );
+  }
+  if (hasSubscription) {
+    const subprocessEnv = { ...env };
+    for (const k of API_ENV_KEYS) delete subprocessEnv[k];
+    return {
+      path: "subscription",
+      billsApiCredits: false,
+      notice: "Model auth: Max/Pro subscription login \u2014 billing your subscription.",
+      subprocessEnv
+    };
+  }
+  if (hasApiKey) return apiResult(env, "api-key");
+  if (hasAntAuth) return apiResult(env, "ant-auth");
+  throw new ModelAuthError(
+    "No Anthropic model credential found. Either:\n  \u2022 log in your own Claude Code for subscription billing:  claude login\n  \u2022 or use API credits:  export ANTHROPIC_API_KEY=sk-ant-\u2026   (or: ant auth login)"
+  );
+}
+function apiResult(env, path) {
+  return {
+    path,
+    billsApiCredits: true,
+    notice: `Model auth: ${path === "api-key" ? "ANTHROPIC_API_KEY" : "ant auth OAuth token"} \u2014 billing API credits, NOT your Max subscription.`,
+    subprocessEnv: { ...env }
+  };
+}
+
+// ../agent-harness/src/claude.ts
+function makeGate(profile) {
+  return async (toolName, input) => {
+    if (!profile.allowedTools.includes(toolName)) {
+      return {
+        behavior: "deny",
+        message: `Tool "${toolName}" is not in the headless allowlist for agent "${profile.identity}".`
+      };
+    }
+    if (toolName === "Bash") {
+      const command = typeof input["command"] === "string" ? input["command"] : "";
+      for (const pattern of profile.blockedBashPatterns) {
+        if (pattern.test(command)) {
+          return {
+            behavior: "deny",
+            message: `Bash command blocked by headless profile pattern ${String(pattern)} for agent "${profile.identity}".`
+          };
+        }
+      }
+    }
+    if (profile.gatedTools.includes(toolName) && !profile.allowGated) {
+      return {
+        behavior: "deny",
+        message: `Tool "${toolName}" is a gated side-effect tool and this profile does not allow gated tools (allowGated: false).`
+      };
+    }
+    return { behavior: "allow", updatedInput: input };
+  };
+}
+function destructiveBashHook(profile) {
+  return {
+    matcher: "Bash",
+    hooks: [
+      async (input) => {
+        if (input.hook_event_name !== "PreToolUse") return { continue: true };
+        const ti = input.tool_input;
+        const command = typeof ti === "object" && ti !== null ? String(ti.command ?? "") : "";
+        for (const pattern of profile.blockedBashPatterns) {
+          if (pattern.test(command)) {
+            return {
+              continue: true,
+              hookSpecificOutput: {
+                hookEventName: "PreToolUse",
+                permissionDecision: "deny",
+                permissionDecisionReason: `Destructive command blocked by headless profile (${String(pattern)}) for agent "${profile.identity}".`
+              }
+            };
+          }
+        }
+        return { continue: true };
+      }
+    ]
+  };
+}
+function* mapMessage(message, expectStructuredOutput) {
+  switch (message.type) {
+    case "system": {
+      if (message.subtype === "init") {
+        yield { type: "start", sessionId: message.session_id };
+      }
+      return;
+    }
+    case "assistant": {
+      const assistant = message;
+      for (const block of assistant.message.content) {
+        if (block.type === "text") {
+          yield { type: "text", text: block.text };
+        } else if (block.type === "thinking") {
+          yield { type: "thinking", text: block.thinking };
+        } else if (block.type === "tool_use") {
+          yield { type: "tool_use", id: block.id, name: block.name, input: block.input };
+        }
+      }
+      return;
+    }
+    case "user": {
+      const user = message;
+      const content = user.message.content;
+      if (typeof content === "string") return;
+      for (const block of content) {
+        if (block.type === "tool_result") {
+          yield {
+            type: "tool_result",
+            id: block.tool_use_id,
+            isError: block.is_error ?? false,
+            content: block.content
+          };
+        }
+      }
+      return;
+    }
+    case "result": {
+      if (message.subtype === "success") {
+        const missingStructured = expectStructuredOutput && message.structured_output === void 0;
+        yield {
+          type: "result",
+          text: message.result,
+          costUsd: message.total_cost_usd,
+          isError: message.is_error || missingStructured,
+          ...message.structured_output !== void 0 ? { structuredOutput: message.structured_output } : {}
+        };
+      } else {
+        yield {
+          type: "result",
+          text: message.errors.join("\n"),
+          costUsd: message.total_cost_usd,
+          isError: true
+        };
+      }
+      return;
+    }
+    default:
+      return;
+  }
+}
+function buildOptions(input, resolved) {
+  const profile = input.profile;
+  const options = {
+    cwd: input.cwd,
+    // CRITICAL: an EXPLICIT settingSources: [] loads NOTHING. (The SDK's own
+    // default — when the option is omitted — loads ALL sources; we always
+    // pass the profile's list so inheritance is an explicit choice, and the
+    // profile's sources are what yield LifeOS inheritance.)
+    settingSources: profile.settingSources,
+    // Never 'bypassPermissions' / 'acceptEdits' — PermissionProfile's type
+    // only admits 'default' | 'plan' | 'dontAsk'.
+    permissionMode: profile.permissionMode,
+    allowedTools: profile.allowedTools,
+    canUseTool: makeGate(profile),
+    // Containment: destructive-Bash denial must survive a bare allowlisted
+    // `Bash` (allow rules short-circuit canUseTool), so it is enforced by a
+    // PreToolUse hook, which the SDK evaluates before allow rules.
+    hooks: { PreToolUse: [destructiveBashHook(profile)] },
+    // Options.env REPLACES the subprocess environment (no merge). The
+    // resolver hands back the FULL inherited env (HOME/PATH preserved) with
+    // ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN stripped on the subscription
+    // path, so the subprocess cannot prefer an API key over the login.
+    env: resolved.subprocessEnv
+  };
+  if (profile.disallowedTools) {
+    options.disallowedTools = profile.disallowedTools;
+  }
+  if (profile.mcpServers) {
+    options.mcpServers = profile.mcpServers;
+  }
+  if (profile.strictMcp !== void 0) {
+    options.strictMcpConfig = profile.strictMcp;
+  }
+  if (input.outputSchema) {
+    options.outputFormat = { type: "json_schema", schema: input.outputSchema };
+  }
+  return options;
+}
+function verifyBilling(resolved, apiKeySource, notify) {
+  if (apiKeySource === void 0) return;
+  const billedViaApiKey = apiKeySource !== "none";
+  if (resolved.path === "subscription" && billedViaApiKey) {
+    notify(
+      `Warning: the subscription path was selected but the run authenticated from an API-key source ('${apiKeySource}') \u2014 this run bills API credits, not your subscription.`
+    );
+  } else if (resolved.path !== "subscription" && !billedViaApiKey) {
+    notify(
+      `Warning: the ${resolved.path} (API credits) path was selected but the run authenticated as first-party (no API key) \u2014 this run bills the subscription.`
+    );
+  }
+}
+var SDK_UNAVAILABLE_MESSAGE = "Claude Agent SDK not available \u2014 reinstall the CLI (do not use --omit=optional). Global install is required for the agent path; pnpm dlx/npx re-download the ~268 MB native binary.";
+function isSdkAbsence(error) {
+  const code = error?.code;
+  if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") return true;
+  const message = error instanceof Error ? error.message : String(error);
+  return /Native CLI binary.*not found/i.test(message);
+}
+async function loadSdkQuery(loader) {
+  try {
+    const mod = await (loader ?? (() => import("@anthropic-ai/claude-agent-sdk")))();
+    return mod.query;
+  } catch (error) {
+    if (isSdkAbsence(error)) throw new Error(SDK_UNAVAILABLE_MESSAGE, { cause: error });
+    throw error;
+  }
+}
+function createClaudeHarness(deps) {
+  return {
+    id: "claude",
+    async *run(input) {
+      const resolved = resolveModelCredential({
+        env: deps?.env,
+        home: deps?.home,
+        useApi: input.useApi
+      });
+      const notify = input.onNotice ?? ((message) => console.error(message));
+      notify(resolved.notice);
+      const queryFn = deps?.queryFn ?? await loadSdkQuery(deps?.sdkLoader);
+      const expectStructuredOutput = input.outputSchema !== void 0;
+      try {
+        const stream = queryFn({ prompt: input.prompt, options: buildOptions(input, resolved) });
+        for await (const message of stream) {
+          if (message.type === "system" && message.subtype === "init") {
+            verifyBilling(resolved, message.apiKeySource, notify);
+          }
+          yield* mapMessage(message, expectStructuredOutput);
+        }
+      } catch (error) {
+        if (isSdkAbsence(error)) throw new Error(SDK_UNAVAILABLE_MESSAGE, { cause: error });
+        throw error;
+      }
+    }
+  };
+}
+
+// ../agent-harness/src/profiles.ts
+var SIDE_EFFECT_GATED_TOOLS = ["SendMessage", "Send", "Deploy", "Publish"];
+var BLOCKED_BASH_PATTERNS = [
+  /\bgit\s+push\b/,
+  /\bwrangler\s+deploy\b/,
+  /\brm\s+-rf\b/,
+  /\bnpm\s+publish\b/
+];
+function blockedBashPatterns() {
+  return [...BLOCKED_BASH_PATTERNS];
+}
+function defaultHeadlessProfile(identity) {
+  return {
+    allowedTools: ["Read", "Grep", "Glob", "WebFetch"],
+    gatedTools: [...SIDE_EFFECT_GATED_TOOLS],
+    allowGated: false,
+    blockedBashPatterns: blockedBashPatterns(),
+    permissionMode: "default",
+    settingSources: [],
+    identity
+  };
+}
+function lifeOSProfile(identity, mcpServers) {
+  const profile = {
+    allowedTools: [
+      "Read",
+      "Grep",
+      "Glob",
+      "WebFetch",
+      "WebSearch",
+      "Write",
+      "Edit",
+      "NotebookEdit",
+      // NOTE: a bare 'Bash' allow rule auto-approves the tool and
+      // short-circuits canUseTool — blockedBashPatterns stay enforced only
+      // because the harness installs them as a PreToolUse hook (claude.ts
+      // destructiveBashHook), which the SDK evaluates before allow rules.
+      "Bash",
+      "Agent",
+      "Task",
+      "Skill",
+      "TodoWrite"
+    ],
+    gatedTools: [...SIDE_EFFECT_GATED_TOOLS],
+    allowGated: false,
+    blockedBashPatterns: blockedBashPatterns(),
+    permissionMode: "default",
+    settingSources: ["user", "project", "local"],
+    identity
+  };
+  if (mcpServers) {
+    profile.mcpServers = mcpServers;
+    profile.strictMcp = true;
+  }
+  return profile;
+}
+
+// server/cli.ts
 import { WebSocketServer } from "ws";
 
 // server/app.ts
 import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";
 import { Hono } from "hono";
+import { z as z2 } from "zod";
 
 // src/lib/schema.ts
 import { z } from "zod";
@@ -137,8 +462,8 @@ var SessionSnapshot = z.object({
 });
 
 // server/references.ts
-import { readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
-import { basename, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
+import { readFileSync, readdirSync as readdirSync2, realpathSync, statSync } from "node:fs";
+import { basename, isAbsolute, join as join2, 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;
@@ -164,14 +489,14 @@ function collectEntries(root) {
     if (files.length + dirs.length >= WALK_ENTRY_LIMIT) return;
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries = readdirSync2(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);
+      const full = join2(dir, entry.name);
       if (entry.isDirectory()) {
         dirs.push(relative(root, full));
         walk(full);
@@ -258,7 +583,7 @@ function expandReferences(text, root) {
         if (included >= REF_DIR_FILE_LIMIT || totalBytes >= REF_TOTAL_BYTE_LIMIT) break;
         let body;
         try {
-          body = readClamped(join(rootReal, relPath));
+          body = readClamped(join2(rootReal, relPath));
         } catch {
           continue;
         }
@@ -305,7 +630,7 @@ function resolveOne(rootReal, ref) {
     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 dirFiles = collectFiles(direct).map((p) => relative(rootReal, join2(direct, p))).sort((a, b) => {
       const depth = a.split(sep).length - b.split(sep).length;
       return depth !== 0 ? depth : a.localeCompare(b);
     });
@@ -331,7 +656,7 @@ function resolveOne(rootReal, ref) {
   if (matches.length === 0) return { reason: "not found" };
   const best = matches[0];
   try {
-    const body = readClamped(join(rootReal, best));
+    const body = readClamped(join2(rootReal, best));
     return {
       path: best,
       ...body,
@@ -513,6 +838,7 @@ function bundleFilePaths(b) {
     ...b.specs.map((s) => `specs/${s.capability}/spec.md`)
   ];
 }
+var SPEC_BUNDLE_JSON_SCHEMA = z2.toJSONSchema(SpecBundle, { target: "draft-7" });
 var FABLE_BETAS = ["server-side-fallback-2026-06-01"];
 var FABLE_FALLBACKS = [{ model: "claude-opus-4-8" }];
 function parseWithModelGate(anthropic, request) {
@@ -546,6 +872,9 @@ function anthropicErrorResponse(c, err, kind) {
 }
 function createApp(anthropic, workspace, getShare, options) {
   const refRoot = options === void 0 ? process.cwd() : options.refRoot;
+  const harness = options?.harness;
+  const reviewProfile = lifeOSProfile("specsketch-review");
+  const generateProfile = defaultHeadlessProfile("specsketch-generate");
   const app = new Hono();
   app.get("/api/health", (c) => c.json({ ok: true }));
   app.get(
@@ -624,25 +953,65 @@ Produce the OpenSpec change proposal for this architecture as structured output.
 Referenced files (resolved from @-references in the input):
 
 ${refContext}` : "");
-    let msg;
-    try {
-      msg = await parseWithModelGate(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.
-      });
-    } catch (err) {
-      return anthropicErrorResponse(c, err, "generation-failed");
-    }
-    if (msg.stop_reason === "refusal") {
-      return c.json({ error: "refusal", detail: msg.stop_details }, 422);
+    let output;
+    if (harness) {
+      let structured;
+      let resultText = "";
+      let resultError = false;
+      try {
+        for await (const ev of harness.run({
+          prompt: `${system}
+
+${prompt}`,
+          cwd: refRoot ?? process.cwd(),
+          session: workspace?.changeName ?? "specsketch-generate",
+          profile: generateProfile,
+          outputSchema: SPEC_BUNDLE_JSON_SCHEMA
+        })) {
+          if (ev.type === "result") {
+            structured = ev.structuredOutput;
+            resultText = ev.text;
+            resultError = ev.isError;
+          }
+        }
+      } catch (err) {
+        return anthropicErrorResponse(c, err, "generation-failed");
+      }
+      if (structured === void 0) {
+        return resultError ? c.json(
+          { error: "generation-failed", detail: resultText || "the agent run failed" },
+          502
+        ) : c.json({ error: "model returned no structured output" }, 502);
+      }
+      const checked = SpecBundle.safeParse(structured);
+      if (!checked.success) {
+        return c.json(
+          { error: "model returned invalid structured output", detail: checked.error.issues },
+          502
+        );
+      }
+      output = checked.data;
+    } else {
+      let msg;
+      try {
+        msg = await parseWithModelGate(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.
+        });
+      } catch (err) {
+        return anthropicErrorResponse(c, err, "generation-failed");
+      }
+      if (msg.stop_reason === "refusal") {
+        return c.json({ error: "refusal", detail: msg.stop_details }, 422);
+      }
+      if (!msg.parsed_output) return c.json({ error: "model returned no structured output" }, 502);
+      output = SpecBundle.parse(msg.parsed_output);
     }
-    if (!msg.parsed_output) return c.json({ error: "model returned no structured output" }, 502);
-    const output = SpecBundle.parse(msg.parsed_output);
     const bundle = workspace ? { ...output, changeName: workspace.changeName } : output;
     const changedFiles = workspace ? workspace.writeBundle(bundle) : bundleFilePaths(bundle);
     const seed = await makeSeed(anthropic, model, conversation, changedFiles, bundle);
@@ -654,43 +1023,56 @@ ${refContext}` : "");
     if (!parsed.success) {
       return c.json({ error: "invalid request", detail: parsed.error.issues }, 400);
     }
-    const { message, conversation, model = DEFAULT_MODEL } = parsed.data;
+    const { message, conversation } = parsed.data;
     const bundle = parsed.data.bundle ?? workspace?.toBundle() ?? null;
     if (!bundle) return c.json({ error: "no spec to chat about \u2014 generate one first" }, 400);
+    if (!harness) {
+      return c.json(
+        { error: "chat-unavailable", detail: "no agent harness configured for this server" },
+        500
+      );
+    }
     const refs = expandReferences(message, refRoot);
     const refContext = renderReferenceContext(refs);
-    const history = conversation.map((m) => ({
-      role: m.role === "user" ? "user" : "assistant",
-      content: m.text
-    }));
-    let msg;
-    try {
-      msg = await createWithModelGate(anthropic, {
-        model,
-        max_tokens: 2e3,
-        system: `${CHAT_SYSTEM}
-
-${renderBundleContext(bundle)}`,
-        messages: [
-          ...history,
-          {
-            role: "user",
-            content: message + (refContext ? `
+    const history = conversation.map((m) => `[${m.role === "user" ? "user" : "assistant"}]
+${m.text}`).join("\n\n");
+    const prompt = `${CHAT_SYSTEM}
+
+${renderBundleContext(bundle)}` + (history ? `
+
+Conversation so far:
+
+${history}` : "") + `
+
+[user]
+${message}` + (refContext ? `
 
 Referenced files (resolved from @-references in the message):
 
-${refContext}` : "")
-          }
-        ]
-      });
+${refContext}` : "");
+    let answer = "";
+    let resultText = "";
+    let resultError = false;
+    try {
+      for await (const ev of harness.run({
+        prompt,
+        cwd: refRoot ?? process.cwd(),
+        session: workspace?.changeName ?? bundle.changeName ?? "specsketch-review",
+        profile: reviewProfile
+      })) {
+        if (ev.type === "text") answer += ev.text;
+        else if (ev.type === "result") {
+          resultText = ev.text;
+          resultError = ev.isError;
+        }
+      }
     } catch (err) {
       return anthropicErrorResponse(c, err, "chat-failed");
     }
-    if (msg.stop_reason === "refusal") {
-      return c.json({ error: "refusal", detail: msg.stop_details }, 422);
+    const text = answer.trim() || resultText.trim();
+    if (!text) {
+      return resultError ? c.json({ error: "chat-failed", detail: resultText || "the agent run failed" }, 502) : c.json({ error: "model returned no text" }, 502);
     }
-    const text = textOf(msg);
-    if (!text) return c.json({ error: "model returned no text" }, 502);
     const reply = { role: "assistant", text, at: (/* @__PURE__ */ new Date()).toISOString() };
     workspace?.writeChat([
       ...conversation,
@@ -711,27 +1093,27 @@ ${refContext}` : "")
 }
 
 // server/coop-auth.ts
-import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
 
 // ../shared/src/cli-auth.ts
 import { exec } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { createServer } from "node:http";
 import { hostname as hostname2 } from "node:os";
 import { URL as URL2 } from "node:url";
 
 // ../shared/src/cli-config.ts
 import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
-import { homedir, hostname } from "node:os";
-import { join as join2, dirname } from "node:path";
+import { homedir as homedir2, hostname } from "node:os";
+import { join as join3, dirname } from "node:path";
 
 // ../shared/src/schemas.ts
-import { z as z2 } from "zod";
-var planTierSchema = z2.enum(["hobby", "squad", "org"]);
-var jurisdictionSchema = z2.enum(["eu", "fedramp"]);
-var locationHintSchema = z2.enum([
+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",
@@ -742,135 +1124,135 @@ var locationHintSchema = z2.enum([
   "me",
   "sam"
 ]);
-var sessionNameSchema = z2.string().min(1).max(63).regex(
+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 = z2.string().min(1).max(63).regex(
+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 = z2.enum(["text", "context", "request", "system"]);
-var messageContentSchema = z2.object({
+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: z2.string().min(1),
+  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: z2.record(z2.string(), z2.unknown()).optional()
+  metadata: z3.record(z3.string(), z3.unknown()).optional()
 });
-var createTeamInputSchema = z2.object({
+var createTeamInputSchema = z3.object({
   name: teamNameSchema
 });
-var createSessionInputSchema = z2.object({
+var createSessionInputSchema = z3.object({
   name: sessionNameSchema,
-  teamId: z2.string().optional(),
+  teamId: z3.string().optional(),
   jurisdiction: jurisdictionSchema.optional(),
   locationHint: locationHintSchema.optional()
 });
-var sendMessageInputSchema = z2.object({
+var sendMessageInputSchema = z3.object({
   content: messageContentSchema
 });
-var inviteInputSchema = z2.object({
-  email: z2.string().email(),
-  role: z2.enum(["admin", "member"]).default("member")
+var inviteInputSchema = z3.object({
+  email: z3.string().email(),
+  role: z3.enum(["admin", "member"]).default("member")
 });
-var joinTeamInputSchema = z2.object({
-  inviteCode: z2.string().min(1)
+var joinTeamInputSchema = z3.object({
+  inviteCode: z3.string().min(1)
 });
-var markReadInputSchema = z2.object({
-  notificationIds: z2.array(z2.string().min(1))
+var markReadInputSchema = z3.object({
+  notificationIds: z3.array(z3.string().min(1))
 });
-var pollQuerySchema = z2.object({
-  since: z2.string().optional(),
-  limit: z2.coerce.number().int().min(1).max(100).default(50),
-  session: z2.string().optional()
+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 = z2.object({
-  cursor: z2.string().optional(),
-  limit: z2.coerce.number().int().min(1).max(100).default(50)
+var messagesQuerySchema = z3.object({
+  cursor: z3.string().optional(),
+  limit: z3.coerce.number().int().min(1).max(100).default(50)
 });
-var teamTypeSchema = z2.enum(["personal", "shared"]);
-var teamRoleSchema = z2.enum(["owner", "admin", "member"]);
-var accessPermissionSchema = z2.enum(["read", "write", "admin"]);
-var accessGrantInputSchema = z2.object({
-  userId: z2.string().min(1),
+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 = z2.string().min(1).max(63).regex(
+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 = z2.object({
-  email: z2.string().email().nullable(),
-  displayName: z2.string().min(1).max(100),
-  avatarUrl: z2.string().url().nullable(),
-  provider: z2.string().min(1).max(50),
-  providerUserId: z2.string().min(1).max(100)
+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 = z2.object({
-  sessionId: z2.string(),
-  team: z2.string(),
-  teamName: z2.string().optional(),
-  key: z2.string().startsWith("api_"),
-  enrolledAt: z2.string().datetime(),
-  apiUrl: z2.string().url().optional(),
-  machineId: z2.string().optional()
+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 = z2.object({
-  key: z2.string().startsWith("api_"),
-  userId: z2.string().min(1),
-  displayName: z2.string().nullable().optional().default(null),
-  email: z2.string().email().nullable(),
-  machineId: z2.string().nullable(),
-  authenticatedAt: z2.string().datetime()
+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: z2.string().url(),
-  machineId: z2.string().nullable(),
-  sessions: z2.record(z2.string(), sessionEnrollmentSchema),
-  defaults: z2.object({
-    team: z2.string().nullable(),
-    session: z2.string().nullable()
+  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: z2.object({
-    lastPollAt: z2.string().datetime().nullable()
+  poll: z3.object({
+    lastPollAt: z3.string().datetime().nullable()
   })
 };
-var coopConfigV1Schema = z2.object({
-  version: z2.literal(1),
+var coopConfigV1Schema = z3.object({
+  version: z3.literal(1),
   ...configBaseFields
 });
-var coopConfigV2Schema = z2.object({
-  version: z2.literal(2),
+var coopConfigV2Schema = z3.object({
+  version: z3.literal(2),
   ...configBaseFields,
   auth: authConfigSchema.optional()
 });
-var profileNameSchema = z2.string().regex(
+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 = z2.object({
-  apiUrl: z2.string().url(),
+var coopProfileSchema = z3.object({
+  apiUrl: z3.string().url(),
   auth: authConfigSchema.optional(),
-  sessions: z2.record(z2.string(), sessionEnrollmentSchema),
-  defaults: z2.object({
-    team: z2.string().nullable(),
-    session: z2.string().nullable()
+  sessions: z3.record(z3.string(), sessionEnrollmentSchema),
+  defaults: z3.object({
+    team: z3.string().nullable(),
+    session: z3.string().nullable()
   }),
-  poll: z2.object({
-    lastPollAt: z2.string().datetime().nullable()
+  poll: z3.object({
+    lastPollAt: z3.string().datetime().nullable()
   })
 });
-var coopConfigV3ObjectSchema = z2.object({
-  version: z2.literal(3),
-  machineId: z2.string().nullable(),
-  defaultProfile: z2.string(),
-  profiles: z2.record(profileNameSchema, coopProfileSchema)
+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)) {
@@ -884,7 +1266,7 @@ function requireDefaultProfilePointer(config, ctx) {
 var coopConfigV3Schema = coopConfigV3ObjectSchema.superRefine(
   requireDefaultProfilePointer
 );
-var coopConfigSchema = z2.discriminatedUnion("version", [
+var coopConfigSchema = z3.discriminatedUnion("version", [
   coopConfigV1Schema,
   coopConfigV2Schema,
   coopConfigV3ObjectSchema
@@ -893,20 +1275,39 @@ var coopConfigSchema = z2.discriminatedUnion("version", [
     requireDefaultProfilePointer(config, ctx);
   }
 });
-var hookStdinSchema = z2.object({
-  session_id: z2.string().optional(),
-  cwd: z2.string().optional(),
-  hook_event_name: z2.string().optional()
+var hookStdinSchema = z3.object({
+  session_id: z3.string().optional(),
+  cwd: z3.string().optional(),
+  hook_event_name: z3.string().optional()
 }).passthrough();
-var wsClientMessageSchema = z2.discriminatedUnion("type", [
-  z2.object({ type: z2.literal("message"), content: messageContentSchema }),
-  z2.object({ type: z2.literal("presence_request") }),
-  z2.object({ type: z2.literal("ping") })
+var wsClientMessageSchema = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("message"), content: messageContentSchema }),
+  z3.object({ type: z3.literal("ack"), data: z3.object({ messageId: z3.string() }) }),
+  z3.object({ type: z3.literal("presence_request") }),
+  z3.object({ type: z3.literal("ping") })
 ]);
+var workKindSchema = z3.enum(["implement", "generate"]);
+var workCompletionStatusSchema = z3.enum(["succeeded", "failed"]);
+var poolJoinInputSchema = z3.object({}).passthrough();
+var poolCheckInInputSchema = z3.object({}).passthrough();
+var poolCompleteInputSchema = z3.object({
+  workId: z3.string().min(1),
+  status: workCompletionStatusSchema,
+  resultRef: z3.string().max(512),
+  assignmentSeq: z3.number().int().nonnegative()
+});
+var poolEnqueueInputSchema = z3.object({
+  kind: workKindSchema,
+  source: z3.string().min(1),
+  dedupKey: z3.string().min(1).max(512).optional()
+});
+var poolCancelInputSchema = z3.object({
+  workId: z3.string().min(1)
+});
 
 // ../shared/src/cli-config.ts
-var DEFAULT_CONFIG_DIR = join2(homedir(), ".coopcli");
-var DEFAULT_CONFIG_PATH = join2(DEFAULT_CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG_DIR = join3(homedir2(), ".coopcli");
+var DEFAULT_CONFIG_PATH = join3(DEFAULT_CONFIG_DIR, "config.json");
 var PROD_API_URL = "https://api.coopcli.com";
 function emptyProfile(apiUrl) {
   return {
@@ -1383,7 +1784,7 @@ var CliAuthError = class extends Error {
 async function resolveCoopCredentials(opts) {
   const env = opts.env ?? process.env;
   const { configPath, loginHint } = opts;
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     throw new CliAuthError(`No CoopCLI config found at ${configPath}.
 ${loginHint}`, "missing-config");
   }
@@ -1425,7 +1826,7 @@ ${loginHint}`, "no-login");
 var CoopAuthError = class extends Error {
 };
 var LOGIN_HINT = "--share needs a CoopCLI account. Run `specsketch login` (it opens your browser and saves credentials to ~/.coopcli/config.json), then rerun with --share.";
-async function readCoopAuth(configPath = join3(homedir2(), ".coopcli", "config.json"), env = process.env) {
+async function readCoopAuth(configPath = join4(homedir3(), ".coopcli", "config.json"), env = process.env) {
   try {
     return await resolveCoopCredentials({
       configPath,
@@ -1688,14 +2089,6 @@ var ApiClient = class _ApiClient {
       latest: count
     });
   }
-  async queryAIContext(teamId, sessionName, input) {
-    return this.request(
-      "POST",
-      this.userPath(`/sessions/${encodeURIComponent(sessionName)}/ai-context`),
-      input,
-      { team: teamId }
-    );
-  }
   async listSessionFiles(teamId, sessionName) {
     const result = await this.request(
       "GET",
@@ -1783,6 +2176,72 @@ var ApiClient = class _ApiClient {
     const size = parseInt(res.headers.get("Content-Length") ?? "0", 10);
     return { filename, body: res.body, size };
   }
+  // ── Agent pool (specsesh-agent-pool) — user-scoped routes ──────────────
+  /** Enroll this machine in its org's execute pool. Identity comes from the key. */
+  async poolJoin() {
+    return this.request("POST", this.userPath("/pool/join"), {});
+  }
+  /** Check in; may return one assigned work item in the same round-trip (FIFO). */
+  async poolCheckIn() {
+    return this.request("POST", this.userPath("/pool/check-in"), {});
+  }
+  /**
+   * The org pool's roster. `specsesh dispatch` reads it to surface a live-agent
+   * count so a dispatch into a pool with zero live agents is a visible no-signal
+   * enqueue, not a silent success (specsesh-work-dispatch §4.4).
+   */
+  async poolRoster() {
+    const body = await this.request("GET", this.userPath("/pool/roster"));
+    return body.agents;
+  }
+  /**
+   * Report completion of an assigned work item. `assignmentSeq` is REQUIRED
+   * (specsesh-task-lifecycle §5) — echo back the epoch from the `WorkItem`
+   * this caller was handed at check-in, so the DO's ABA fence can reject a
+   * stale completion from a since-superseded assignment.
+   */
+  async poolComplete(workId, status, resultRef, assignmentSeq) {
+    await this.request("POST", this.userPath("/pool/complete"), { workId, status, resultRef, assignmentSeq });
+  }
+  /**
+   * Dispatch a task record into the org pool as one work item (idempotent on
+   * the qualified `dedupKey`). CLI producer of specsesh-work-dispatch; returns
+   * the (possibly already-existing) work id.
+   */
+  async poolEnqueue(kind, source, dedupKey) {
+    return this.request("POST", this.userPath("/pool/enqueue"), { kind, source, dedupKey });
+  }
+  /**
+   * Org-scoped cancel (specsesh-task-lifecycle §2) — any authenticated member
+   * of the org may cancel any work item in its pool, regardless of which
+   * agent (if any) holds it. `queued` cancels directly; `assigned`/`running`
+   * cancels and frees the holding agent (no redelivery); an already-terminal
+   * item rejects.
+   */
+  async poolCancel(workId) {
+    await this.request("POST", this.userPath("/pool/cancel"), { workId });
+  }
+  /**
+   * Query a single work item's current status (specsesh-task-lifecycle §4) —
+   * tenant-scoped, independent of whether the caller is the agent (if any)
+   * holding it. Throws `CoopApiError` (`POOL_WORK_NOT_FOUND`, 404) if the
+   * item does not exist in this organization's pool.
+   */
+  async poolWork(workId) {
+    const body = await this.request(
+      "GET",
+      this.userPath(`/pool/work/${encodeURIComponent(workId)}`)
+    );
+    return body.work;
+  }
+  /**
+   * List every work item currently in the organization's pool, regardless of
+   * status (specsesh-task-lifecycle §4).
+   */
+  async poolWorkList() {
+    const body = await this.request("GET", this.userPath("/pool/work"));
+    return body.items;
+  }
   getWebSocketUrl(session) {
     const wsBase = this.apiUrl.replace(
       /^https?:\/\//,
@@ -1796,98 +2255,98 @@ var ApiClient = class _ApiClient {
 };
 
 // ../shared/src/canvas-protocol.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var CANVAS_PROTOCOL_VERSION = 1;
-var canvasElementSchema = z3.object({
-  id: z3.string().min(1),
-  version: z3.number().int().nonnegative(),
-  versionNonce: z3.number().int(),
-  isDeleted: z3.boolean().optional()
+var canvasElementSchema = z4.object({
+  id: z4.string().min(1),
+  version: z4.number().int().nonnegative(),
+  versionNonce: z4.number().int(),
+  isDeleted: z4.boolean().optional()
 }).passthrough();
-var canvasFilesSchema = z3.record(z3.string(), z3.unknown());
-var canvasSceneSchema = z3.object({
-  elements: z3.array(canvasElementSchema),
+var canvasFilesSchema = z4.record(z4.string(), z4.unknown());
+var canvasSceneSchema = z4.object({
+  elements: z4.array(canvasElementSchema),
   files: canvasFilesSchema.optional()
 });
-var canvasParticipantSchema = z3.object({
-  id: z3.string().min(1),
-  role: z3.enum(["host", "guest"]),
-  name: z3.string().optional(),
-  color: z3.string().optional()
+var canvasParticipantSchema = z4.object({
+  id: z4.string().min(1),
+  role: z4.enum(["host", "guest"]),
+  name: z4.string().optional(),
+  color: z4.string().optional()
 });
-var canvasHelloSchema = z3.object({
-  type: z3.literal("hello"),
-  protocolVersion: z3.number().int().positive(),
-  role: z3.enum(["host", "guest"]),
+var canvasHelloSchema = z4.object({
+  type: z4.literal("hello"),
+  protocolVersion: z4.number().int().positive(),
+  role: z4.enum(["host", "guest"]),
   /** Stable id across reconnects, if the client has one. */
-  participantId: z3.string().min(1).max(64).optional(),
-  name: z3.string().max(120).optional()
+  participantId: z4.string().min(1).max(64).optional(),
+  name: z4.string().max(120).optional()
 });
-var canvasClientOpSchema = z3.object({
-  type: z3.literal("op"),
+var canvasClientOpSchema = z4.object({
+  type: z4.literal("op"),
   /** Changed or soft-deleted elements only — never the full scene. */
-  elements: z3.array(canvasElementSchema).min(1),
+  elements: z4.array(canvasElementSchema).min(1),
   /** New binary files referenced by the changed elements, if any. */
   files: canvasFilesSchema.optional(),
   /** Client-local monotonic sequence, used by the sender for echo dedupe. */
-  clientSeq: z3.number().int().nonnegative()
+  clientSeq: z4.number().int().nonnegative()
 });
-var canvasClientMessageSchema = z3.discriminatedUnion("type", [
+var canvasClientMessageSchema = z4.discriminatedUnion("type", [
   canvasHelloSchema,
   canvasClientOpSchema
 ]);
-var canvasSnapshotSchema = z3.object({
-  type: z3.literal("snapshot"),
+var canvasSnapshotSchema = z4.object({
+  type: z4.literal("snapshot"),
   scene: canvasSceneSchema,
-  revision: z3.number().int().nonnegative(),
-  participants: z3.array(canvasParticipantSchema),
+  revision: z4.number().int().nonnegative(),
+  participants: z4.array(canvasParticipantSchema),
   /** Echoes the server's protocol version so clients can detect skew. */
-  protocolVersion: z3.number().int().positive(),
+  protocolVersion: z4.number().int().positive(),
   /** The participant id the server assigned to (or kept for) this client. */
-  participantId: z3.string()
+  participantId: z4.string()
 });
-var canvasServerOpSchema = z3.object({
-  type: z3.literal("op"),
+var canvasServerOpSchema = z4.object({
+  type: z4.literal("op"),
   /** The elements that won reconciliation (never echoed to the sender). */
-  elements: z3.array(canvasElementSchema),
+  elements: z4.array(canvasElementSchema),
   files: canvasFilesSchema.optional(),
-  revision: z3.number().int().positive(),
+  revision: z4.number().int().positive(),
   /** Participant id of the sender. */
-  from: z3.string()
+  from: z4.string()
 });
-var canvasPresenceSchema = z3.object({
-  type: z3.literal("presence"),
-  participants: z3.array(canvasParticipantSchema)
+var canvasPresenceSchema = z4.object({
+  type: z4.literal("presence"),
+  participants: z4.array(canvasParticipantSchema)
 });
-var canvasEndSchema = z3.object({
-  type: z3.literal("end"),
-  reason: z3.string()
+var canvasEndSchema = z4.object({
+  type: z4.literal("end"),
+  reason: z4.string()
 });
-var canvasErrorSchema = z3.object({
-  type: z3.literal("error"),
-  code: z3.string(),
-  message: z3.string()
+var canvasErrorSchema = z4.object({
+  type: z4.literal("error"),
+  code: z4.string(),
+  message: z4.string()
 });
-var canvasServerMessageSchema = z3.discriminatedUnion("type", [
+var canvasServerMessageSchema = z4.discriminatedUnion("type", [
   canvasSnapshotSchema,
   canvasServerOpSchema,
   canvasPresenceSchema,
   canvasEndSchema,
   canvasErrorSchema
 ]);
-var canvasSessionCreatedSchema = z3.object({
-  sessionId: z3.string().min(1),
+var canvasSessionCreatedSchema = z4.object({
+  sessionId: z4.string().min(1),
   /** Capability token — shown once; the server stores only its hash. */
-  token: z3.string().min(1),
-  shareUrl: z3.string().min(1),
-  wsUrl: z3.string().min(1)
+  token: z4.string().min(1),
+  shareUrl: z4.string().min(1),
+  wsUrl: z4.string().min(1)
 });
-var canvasSessionSummarySchema = z3.object({
-  sessionId: z3.string(),
-  title: z3.string().nullable(),
-  status: z3.enum(["active", "ended"]),
-  createdAt: z3.number(),
-  endedAt: z3.number().nullable()
+var canvasSessionSummarySchema = z4.object({
+  sessionId: z4.string(),
+  title: z4.string().nullable(),
+  status: z4.enum(["active", "ended"]),
+  createdAt: z4.number(),
+  endedAt: z4.number().nullable()
 });
 function elementWins(local, incoming) {
   if (incoming.version !== local.version) return incoming.version > local.version;
@@ -2171,37 +2630,178 @@ var RemoteSession = class _RemoteSession {
 };
 
 // server/workspace.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import {
-  existsSync as existsSync2,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  readdirSync as readdirSync2,
-  renameSync,
-  writeFileSync
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync4,
+  renameSync as renameSync2,
+  writeFileSync as writeFileSync2
 } from "node:fs";
-import { basename as basename2, dirname as dirname2, join as join4, resolve as resolve2 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join6, resolve as resolve2 } from "node:path";
+
+// ../shared/src/openspec-change-meta.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync4, readdirSync as readdirSync3, realpathSync as realpathSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+import { Document, parseDocument } from "yaml";
+import { z as z5 } from "zod";
+
+// ../shared/src/fs-atomic.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+function writeAtomicFile(target, content) {
+  mkdirSync(dirname2(target), { recursive: true });
+  const tmp = `${target}.tmp`;
+  writeFileSync(tmp, content, "utf8");
+  renameSync(tmp, target);
+}
+function readIfExists(target) {
+  return existsSync3(target) ? readFileSync2(target, "utf8") : void 0;
+}
+
+// ../shared/src/openspec-change-meta.ts
+var CHANGE_META_FILE = "specplan.yaml";
+var nodeChangeMetaFs = {
+  readIfExists(path) {
+    return readIfExists(path);
+  },
+  writeAtomicFile(path, content) {
+    writeAtomicFile(path, content);
+  },
+  exists(path) {
+    return existsSync4(path);
+  },
+  readdir(path) {
+    if (!existsSync4(path)) return [];
+    return readdirSync3(path, { withFileTypes: true }).map((entry) => ({
+      name: entry.name,
+      directory: entry.isDirectory()
+    }));
+  },
+  realpath(path) {
+    return realpathSync2(path);
+  }
+};
+var sha256 = (s) => createHash("sha256").update(s).digest("hex");
+function listBodyFiles(changeDir, fsx = nodeChangeMetaFs) {
+  const files = [];
+  for (const name of ["proposal.md", "design.md", "tasks.md"]) {
+    if (fsx.exists(join5(changeDir, name))) files.push(name);
+  }
+  const specsDir = join5(changeDir, "specs");
+  for (const entry of fsx.readdir(specsDir).sort((a, b) => a.name.localeCompare(b.name))) {
+    const rel = join5("specs", entry.name, "spec.md");
+    if (entry.directory && fsx.exists(join5(changeDir, rel))) files.push(rel);
+  }
+  return files;
+}
+function bodyHash(changeDir, fsx = nodeChangeMetaFs) {
+  const files = listBodyFiles(changeDir, fsx);
+  if (files.length === 0) return null;
+  const parts = files.map(
+    (rel) => `${rel}
+${sha256(fsx.readIfExists(join5(changeDir, rel)) ?? "")}`
+  );
+  return `sha256:${sha256(parts.join("\n"))}`;
+}
+var SPEC_STATUSES = ["draft", "in-progress"];
+var SpecStatus = z5.enum(SPEC_STATUSES);
+var LEGACY_STATUS_COERCION = {
+  active: "in-progress",
+  done: "in-progress",
+  deferred: "draft"
+};
+var StoredSpecStatus = z5.enum([...SPEC_STATUSES, "active", "done", "deferred"]).transform(
+  (s) => s in LEGACY_STATUS_COERCION ? LEGACY_STATUS_COERCION[s] : s
+);
+var SpecMetaSchema = z5.object({
+  specId: z5.string(),
+  userStories: z5.array(z5.string()),
+  dependencies: z5.array(z5.string()),
+  /** Working state (retired values coerce on read); absent = draft. */
+  status: StoredSpecStatus.optional(),
+  /**
+   * Approved axis (formerly `applied`) — fold-driven, SEPARATE from the
+   * working status above. True when the proposal's delta has been folded
+   * into specs/ and archived (apply-first: the fold happens at approval).
+   * Absent = not-approved.
+   */
+  approved: z5.boolean().optional(),
+  /**
+   * Legacy spelling of the fold axis (pre-rename metadata files). Read-only
+   * compatibility: readers treat `applied: true` as `approved: true`; no
+   * writer ever sets this field again.
+   */
+  applied: z5.boolean().optional(),
+  /**
+   * Build flag — user-set, independent of the fold: true once the code has
+   * been built to match the approved diff. Absent = not-implemented.
+   */
+  implemented: z5.boolean().optional(),
+  /**
+   * Minimal implementation-task record written on fold (specplan-timeline-apply
+   * "Implementation task record on fold"): the creation time and a reference to
+   * the archived change's own id/path (from which the delta artifact is
+   * materialized on demand). Deliberately carries NO status and NO dispatch
+   * state — task execution/dispatch is a separate, not-yet-defined concern. A
+   * field addition to this sidecar, not a redefinition of its format.
+   */
+  task: z5.object({
+    createdAt: z5.string(),
+    source: z5.string()
+  }).optional(),
+  generation: z5.object({
+    /** sha256 of the last generated body files — detects hand edits. */
+    lastGeneratedBodyHash: z5.string(),
+    lastGeneratedAt: z5.string()
+  }).optional()
+});
+function writeChangeMeta(fsx, changeDir, meta) {
+  const path = join5(changeDir, CHANGE_META_FILE);
+  const raw = fsx.readIfExists(path);
+  const doc = raw === void 0 ? new Document({
+    specId: meta.specId,
+    userStories: meta.userStories ?? [],
+    dependencies: meta.dependencies ?? [],
+    status: meta.status ?? "draft"
+  }) : parseDocument(raw);
+  if (meta.approved !== void 0) doc.setIn(["approved"], meta.approved);
+  if (meta.implemented !== void 0) doc.setIn(["implemented"], meta.implemented);
+  if (meta.task !== void 0) {
+    doc.setIn(["task", "createdAt"], meta.task.createdAt);
+    doc.setIn(["task", "source"], meta.task.source);
+  }
+  if (meta.generation !== void 0) {
+    doc.setIn(["generation", "lastGeneratedBodyHash"], meta.generation.lastGeneratedBodyHash);
+    doc.setIn(["generation", "lastGeneratedAt"], meta.generation.lastGeneratedAt);
+  }
+  fsx.writeAtomicFile(path, doc.toString());
+}
+
+// server/workspace.ts
 var DIAGRAM_FILE = "diagram.excalidraw";
 var SIDECAR_FILE = "specsketch.json";
-var sha256 = (s) => createHash("sha256").update(s).digest("hex");
+var sha2562 = (s) => createHash2("sha256").update(s).digest("hex");
 var ChangeWorkspace = class {
   dir;
   changeName;
   constructor(dir) {
     this.dir = resolve2(dir);
     this.changeName = basename2(this.dir);
-    mkdirSync(this.dir, { recursive: true });
+    mkdirSync2(this.dir, { recursive: true });
   }
   writeAtomic(relPath, content) {
-    const target = join4(this.dir, relPath);
-    mkdirSync(dirname2(target), { recursive: true });
+    const target = join6(this.dir, relPath);
+    mkdirSync2(dirname3(target), { recursive: true });
     const tmp = `${target}.tmp`;
-    writeFileSync(tmp, content, "utf8");
-    renameSync(tmp, target);
+    writeFileSync2(tmp, content, "utf8");
+    renameSync2(tmp, target);
   }
   readIfExists(relPath) {
-    const target = join4(this.dir, relPath);
-    return existsSync2(target) ? readFileSync2(target, "utf8") : void 0;
+    const target = join6(this.dir, relPath);
+    return existsSync5(target) ? readFileSync3(target, "utf8") : void 0;
   }
   // ── Scene ────────────────────────────────────────────────────────────────
   loadScene() {
@@ -2262,11 +2862,11 @@ var ChangeWorkspace = class {
   /** Current artifact files, however they were authored. */
   readArtifacts() {
     const specs = [];
-    const specsDir = join4(this.dir, "specs");
-    if (existsSync2(specsDir)) {
-      for (const entry of readdirSync2(specsDir, { withFileTypes: true })) {
+    const specsDir = join6(this.dir, "specs");
+    if (existsSync5(specsDir)) {
+      for (const entry of readdirSync4(specsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const spec = this.readIfExists(join4("specs", entry.name, "spec.md"));
+        const spec = this.readIfExists(join6("specs", entry.name, "spec.md"));
         if (spec !== void 0) specs.push({ capability: entry.name, spec });
       }
     }
@@ -2300,11 +2900,11 @@ var ChangeWorkspace = class {
       "design.md": bundle.design,
       "tasks.md": bundle.tasks
     };
-    for (const s of bundle.specs) files[join4("specs", s.capability, "spec.md")] = s.spec;
+    for (const s of bundle.specs) files[join6("specs", s.capability, "spec.md")] = s.spec;
     const written = [];
     const manifest = {};
     for (const [relPath, content] of Object.entries(files)) {
-      manifest[relPath] = sha256(content);
+      manifest[relPath] = sha2562(content);
       if (this.readIfExists(relPath) === content) continue;
       this.writeAtomic(relPath, content);
       written.push(relPath);
@@ -2317,6 +2917,16 @@ var ChangeWorkspace = class {
       // post-generation chat seed (generation-chat-reset-summary).
       lastGeneration: { at: (/* @__PURE__ */ new Date()).toISOString(), changedFiles: written }
     }));
+    const lastGeneratedBodyHash = bodyHash(this.dir, nodeChangeMetaFs);
+    if (lastGeneratedBodyHash) {
+      writeChangeMeta(nodeChangeMetaFs, this.dir, {
+        specId: this.changeName,
+        userStories: [],
+        dependencies: [],
+        status: "draft",
+        generation: { lastGeneratedBodyHash, lastGeneratedAt: (/* @__PURE__ */ new Date()).toISOString() }
+      });
+    }
     return written;
   }
   // ── Spec review chat ─────────────────────────────────────────────────────
@@ -2405,15 +3015,15 @@ var MIME = {
   ".woff": "font/woff"
 };
 function resolveClientDir(moduleUrl) {
-  const here = dirname3(fileURLToPath(moduleUrl));
+  const here = dirname4(fileURLToPath(moduleUrl));
   const candidates = [
-    join5(here, "..", "client"),
+    join7(here, "..", "client"),
     // packed: dist/cli -> dist/client
-    join5(here, "..", "dist", "client")
+    join7(here, "..", "dist", "client")
     // repo: server/ -> dist/client
   ];
   for (const dir of candidates) {
-    if (existsSync3(join5(dir, "index.html"))) return dir;
+    if (existsSync6(join7(dir, "index.html"))) return dir;
   }
   return null;
 }
@@ -2421,9 +3031,9 @@ function staticResponse(clientDir, pathname) {
   const rel = normalize2(decodeURIComponent(pathname)).replace(/^\/+/, "");
   const target = resolve3(clientDir, rel === "" ? "index.html" : rel);
   if (!target.startsWith(resolve3(clientDir))) return null;
-  const file = existsSync3(target) && extname(target) ? target : join5(clientDir, "index.html");
-  if (!existsSync3(file)) return null;
-  return new Response(readFileSync3(file), {
+  const file = existsSync6(target) && extname(target) ? target : join7(clientDir, "index.html");
+  if (!existsSync6(file)) return null;
+  return new Response(readFileSync4(file), {
     headers: { "Content-Type": MIME[extname(file)] ?? "application/octet-stream" }
   });
 }
@@ -2435,12 +3045,12 @@ but "Generate Spec" needs one of:
   \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 = homedir3()) {
+function detectCredentialSource(env = process.env, home = homedir4()) {
   if (env.ANTHROPIC_API_KEY) return "ANTHROPIC_API_KEY";
   if (env.ANTHROPIC_AUTH_TOKEN) return "ANTHROPIC_AUTH_TOKEN";
   try {
-    const dir = join5(home, ".config", "anthropic", "credentials");
-    if (readdirSync3(dir).some((f) => f.endsWith(".json"))) return "anthropic profile";
+    const dir = join7(home, ".config", "anthropic", "credentials");
+    if (readdirSync5(dir).some((f) => f.endsWith(".json"))) return "anthropic profile";
   } catch {
   }
   return null;
@@ -2507,7 +3117,8 @@ ${USAGE}` : err);
       shareUrl: remote.shareUrl,
       status: remote.status,
       participants: remote.participants.length
-    } : { active: false }
+    } : { active: false },
+    { refRoot: process.cwd(), harness: createClaudeHarness() }
   );
   app.get("*", (c) => {
     const res = staticResponse(clientDir, new URL(c.req.url).pathname);