@4pm/cli 1.24.0 → 1.27.0

package/dist/index.js

@@ -28557,11 +28557,12 @@ function fetchWhoami(serverUrl, hashcode3) {
 function selfUnlink(serverUrl, hashcode3) {
   return post(serverUrl, "/machine-links/self-unlink", { hashcode3 });
 }
-async function fetchCliVersion(serverUrl) {
+async function fetchCliVersion(serverUrl, version) {
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), 2e4);
   try {
-    const res = await fetch(`${serverUrl}/meta/cli-version`, { signal: ctrl.signal });
+    const query = version ? `?version=${encodeURIComponent(version)}` : "";
+    const res = await fetch(`${serverUrl}/meta/cli-version${query}`, { signal: ctrl.signal });
     return unwrap(res);
   } finally {
     clearTimeout(timer);
@@ -28798,6 +28799,8 @@ var en_default = {
   "update.updating": "Updating {from} \u2192 {to}\u2026",
   "update.checkVersionFailed": "Could not check cli version: {error}",
   "update.newVersionAutoUpdateOff": "A new version {latest} is available (running {current}) \u2014 autoUpdate is off.",
+  "update.unsupportedSoon": "cli {current} stops being supported on {date} \u2014 update before then (4pm update).",
+  "update.policyNote": "Note from 4PM: {note}",
   "update.applying": "{kind} cli update {from} \u2192 {to}\u2026",
   "update.kindMandatory": "Mandatory",
   "update.kindAutomatic": "Automatic",
@@ -28981,6 +28984,8 @@ var vi_default = {
   "update.updating": "\u0110ang c\u1EADp nh\u1EADt {from} \u2192 {to}\u2026",
   "update.checkVersionFailed": "Kh\xF4ng th\u1EC3 ki\u1EC3m tra phi\xEAn b\u1EA3n cli: {error}",
   "update.newVersionAutoUpdateOff": "C\xF3 phi\xEAn b\u1EA3n m\u1EDBi {latest} (\u0111ang ch\u1EA1y {current}) \u2014 autoUpdate \u0111ang t\u1EAFt.",
+  "update.unsupportedSoon": "cli {current} s\u1EBD ng\u1EEBng \u0111\u01B0\u1EE3c h\u1ED7 tr\u1EE3 t\u1EEB {date} \u2014 h\xE3y c\u1EADp nh\u1EADt tr\u01B0\u1EDBc ng\xE0y \u0111\xF3 (4pm update).",
+  "update.policyNote": "Ghi ch\xFA t\u1EEB 4PM: {note}",
   "update.applying": "C\u1EADp nh\u1EADt cli {kind} {from} \u2192 {to}\u2026",
   "update.kindMandatory": "b\u1EAFt bu\u1ED9c",
   "update.kindAutomatic": "t\u1EF1 \u0111\u1ED9ng",
@@ -29164,6 +29169,8 @@ var ja_default = {
   "update.updating": "\u66F4\u65B0\u4E2D {from} \u2192 {to}\u2026",
   "update.checkVersionFailed": "cli \u306E\u30D0\u30FC\u30B8\u30E7\u30F3\u3092\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F: {error}",
   "update.newVersionAutoUpdateOff": "\u65B0\u3057\u3044\u30D0\u30FC\u30B8\u30E7\u30F3 {latest} \u304C\u5229\u7528\u53EF\u80FD\u3067\u3059\uFF08\u5B9F\u884C\u4E2D {current}\uFF09\u2014 autoUpdate \u306F\u30AA\u30D5\u3067\u3059\u3002",
+  "update.unsupportedSoon": "cli {current} \u306F {date} \u306B\u30B5\u30DD\u30FC\u30C8\u304C\u7D42\u4E86\u3057\u307E\u3059 \u2014 \u305D\u308C\u307E\u3067\u306B\u66F4\u65B0\u3057\u3066\u304F\u3060\u3055\u3044\uFF084pm update\uFF09\u3002",
+  "update.policyNote": "4PM \u304B\u3089\u306E\u304A\u77E5\u3089\u305B: {note}",
   "update.applying": "{kind} \u306E cli \u66F4\u65B0 {from} \u2192 {to}\u2026",
   "update.kindMandatory": "\u5FC5\u9808",
   "update.kindAutomatic": "\u81EA\u52D5",
@@ -29347,6 +29354,8 @@ var zh_default = {
   "update.updating": "\u6B63\u5728\u66F4\u65B0 {from} \u2192 {to}\u2026",
   "update.checkVersionFailed": "\u65E0\u6CD5\u68C0\u67E5 cli \u7248\u672C\uFF1A{error}",
   "update.newVersionAutoUpdateOff": "\u6709\u65B0\u7248\u672C {latest} \u53EF\u7528\uFF08\u5F53\u524D\u8FD0\u884C {current}\uFF09\u2014 autoUpdate \u5DF2\u5173\u95ED\u3002",
+  "update.unsupportedSoon": "cli {current} \u5C06\u4E8E {date} \u505C\u6B62\u652F\u6301 \u2014 \u8BF7\u5728\u6B64\u4E4B\u524D\u66F4\u65B0\uFF084pm update\uFF09\u3002",
+  "update.policyNote": "\u6765\u81EA 4PM \u7684\u8BF4\u660E\uFF1A{note}",
   "update.applying": "{kind} cli \u66F4\u65B0 {from} \u2192 {to}\u2026",
   "update.kindMandatory": "\u5F3A\u5236",
   "update.kindAutomatic": "\u81EA\u52A8",
@@ -32701,12 +32710,18 @@ async function checkAndUpdate(serverUrl, autoUpdate) {
   if (CLI_VERSION.startsWith("0.0.0")) return { action: "none" };
   let meta;
   try {
-    meta = await fetchCliVersion(serverUrl);
+    meta = await fetchCliVersion(serverUrl, CLI_VERSION);
   } catch (err) {
     console.warn(t("update.checkVersionFailed", { error: String(err) }));
     return { action: "none" };
   }
-  const mandatory = compareSemver(CLI_VERSION, meta.minSupported) < 0;
+  const mandatory = compareSemver(CLI_VERSION, meta.minSupported) < 0 || meta.status === "unsupported";
+  if (meta.status === "warning" && meta.unsupportedFrom) {
+    console.warn(t("update.unsupportedSoon", { current: CLI_VERSION, date: meta.unsupportedFrom.slice(0, 10) }));
+    if (meta.note) console.warn(t("update.policyNote", { note: meta.note }));
+  } else if (meta.status === "unsupported" && meta.note) {
+    console.warn(t("update.policyNote", { note: meta.note }));
+  }
   const outdated = shouldUpdateTo(CLI_VERSION, meta.latest);
   if (!outdated) return { action: "none" };
   if (!mandatory && !autoUpdate) {
@@ -32753,7 +32768,7 @@ async function checkAndUpdate(serverUrl, autoUpdate) {
 
 // src/core/ws-client.ts
 init_wrapper();
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { basename as basename7, join as join32 } from "path";
 import { existsSync as existsSync18, mkdirSync as mkdirSync9 } from "fs";
 
@@ -37255,6 +37270,67 @@ var agentToolsWriteRequestSchema = external_exports.object({
   permissions: agentToolsPermissionsSchema
 });
 
+// vendor/@4pm/dto/meta.ts
+var cliVersionString = external_exports.string().trim().regex(/^\d+\.\d+\.\d+([-+][0-9A-Za-z.-]+)?$/);
+var setCliMinVersionRequestSchema = external_exports.object({
+  minSupported: cliVersionString.nullable(),
+  disconnect: external_exports.boolean().optional()
+});
+var setCliVersionOverrideRequestSchema = external_exports.object({
+  status: external_exports.enum(["supported", "warning", "unsupported"]),
+  unsupportedFrom: external_exports.string().datetime({ offset: true }).nullable().optional(),
+  note: external_exports.string().max(500).optional(),
+  disconnect: external_exports.boolean().optional()
+});
+
+// vendor/@4pm/dto/storage.ts
+var STORAGE_KINDS = [
+  "messageText",
+  "postText",
+  "commentText",
+  "memoText",
+  "messageImages",
+  "messageFiles",
+  "postImages",
+  "postFiles",
+  "commentImages",
+  "commentFiles",
+  "memoImages",
+  "memoFiles",
+  "templates",
+  "aiDocImages",
+  "artifacts",
+  "commandHistory"
+];
+var COMMUNITY_STORAGE_KINDS = [
+  "messageText",
+  "postText",
+  "commentText",
+  "messageImages",
+  "messageFiles",
+  "postImages",
+  "postFiles",
+  "commentImages",
+  "commentFiles"
+];
+var SERVER_CLEARABLE_STORAGE_KINDS = [
+  "memoText",
+  "memoImages",
+  "memoFiles",
+  "templates",
+  "commandHistory"
+];
+var CLEARABLE_STORAGE_KINDS = [
+  ...COMMUNITY_STORAGE_KINDS,
+  ...SERVER_CLEARABLE_STORAGE_KINDS
+];
+var storageClearRequestSchema = external_exports.object({
+  kinds: external_exports.array(external_exports.enum(STORAGE_KINDS)).min(1).max(STORAGE_KINDS.length),
+  before: external_exports.string().datetime({ offset: true }),
+  /** org-0009 / community-0015 only — must equal the org name. */
+  confirm: external_exports.string().max(200).optional()
+});
+
 // vendor/@4pm/dto/org.ts
 var CLI_SETTINGS_BOUNDS = {
   reconnectMaxBackoffSec: { min: 5, max: 60 },
@@ -37274,6 +37350,8 @@ var TEMPLATE_KINDS = ["report", "est", "wbs", "proposal", "feasibility"];
 // vendor/@4pm/dto/project.ts
 var listProjectsQuerySchema = baseRequestSchema.extend({
   pinned: pinnedFilterSchema,
+  /** Only projects this team is attached to (project-0001; the public v1 list — ADR-0364). */
+  teamId: external_exports.string().uuid().optional(),
   /** ADMIN-only Trash: list soft-deleted projects (ADR-0109). */
   deleted: deletedFilterSchema
 });
@@ -37564,116 +37642,12 @@ var userCardsQuerySchema = external_exports.object({
 // src/core/scaffold.ts
 import { cp, mkdir, mkdtemp, rm, writeFile } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import { execFile as execFile2 } from "child_process";
+import { execFile } from "child_process";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname3, join as join6, resolve as resolve2 } from "path";
+import { dirname as dirname3, join as join6, resolve } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { promisify as promisify2 } from "util";
-
-// src/core/ai-assist.ts
-import { execFile } from "child_process";
 import { promisify } from "util";
-
-// src/utils/agent-deny.ts
-import { isAbsolute, resolve } from "path";
-var HOME_SECRET_PATTERNS = [
-  "~/.4pm/**",
-  "~/.ssh/**",
-  "~/.config/gh/**",
-  "~/.git-credentials",
-  "~/.claude*",
-  "~/.claude*/**"
-];
-function absDirPattern(dir2) {
-  const abs = (isAbsolute(dir2) ? dir2 : resolve(dir2)).replace(/\\/g, "/").replace(/\/+$/, "");
-  return `/${abs.startsWith("/") ? abs : `/${abs}`}/**`;
-}
-function agentDenyRules(profileDirs2 = []) {
-  const patterns = new Set(HOME_SECRET_PATTERNS);
-  for (const dir2 of profileDirs2) {
-    if (dir2 && dir2.trim()) patterns.add(absDirPattern(dir2.trim()));
-  }
-  const rules = [];
-  for (const p2 of patterns) rules.push(`Read(${p2})`, `Edit(${p2})`);
-  return rules;
-}
-function denySettingsArgs(cmd, profileDirs2 = []) {
-  if (!cmd.includes("claude")) return [];
-  return ["--settings", JSON.stringify({ permissions: { deny: agentDenyRules(profileDirs2) } })];
-}
-
-// src/core/ai-assist.ts
 var run = promisify(execFile);
-function aiCli() {
-  return process.env.AI_CLI || "claude";
-}
-function aiArgs(cli, prompt) {
-  if (cli === "claude") return ["-p", prompt, "--output-format", "json", ...denySettingsArgs(cli, [process.env.CLAUDE_CONFIG_DIR])];
-  if (cli === "codex") return ["exec", "--json", prompt];
-  return ["-p", prompt];
-}
-function estimateTokens(prompt, output) {
-  return Math.max(1, Math.ceil((prompt.length + output.length) / 4));
-}
-function parseAi(cli, stdout, prompt) {
-  if (cli === "claude") {
-    try {
-      const j2 = JSON.parse(stdout);
-      const text2 = (j2.result ?? "").trim();
-      const tokens = (j2.usage?.input_tokens ?? 0) + (j2.usage?.output_tokens ?? 0);
-      if (text2 || tokens) return { text: text2, tokens: tokens || estimateTokens(prompt, text2) };
-    } catch {
-    }
-  }
-  if (cli === "codex") {
-    try {
-      let text2 = "";
-      let tokens = 0;
-      for (const line of stdout.split("\n").filter(Boolean)) {
-        const obj = JSON.parse(line);
-        if (obj.text) text2 = obj.text;
-        else if (obj.message) text2 = obj.message;
-        if (obj.usage) {
-          tokens = obj.usage.total_tokens ?? (obj.usage.input_tokens ?? 0) + (obj.usage.output_tokens ?? 0);
-        }
-      }
-      if (text2 || tokens) return { text: text2.trim(), tokens: tokens || estimateTokens(prompt, text2) };
-    } catch {
-    }
-  }
-  const text = stdout.trim();
-  return { text, tokens: estimateTokens(prompt, text) };
-}
-async function runAi(prompt) {
-  const cli = aiCli();
-  const { stdout } = await run(cli, aiArgs(cli, prompt), {
-    timeout: 12e4,
-    maxBuffer: 8 * 1024 * 1024
-  });
-  return parseAi(cli, stdout, prompt);
-}
-async function aiGenerate(prompt) {
-  const { text } = await runAi(prompt);
-  return text;
-}
-async function aiOutboundReview(input, allowedRepos, projectPath) {
-  const prompt = `You are a security reviewer for an autonomous coding agent. Decide if the following INPUT is SAFE to run. It is UNSAFE if it: (1) asks the AI using secret VALUES (api keys, env values, passwords); (2) would affect other environments (only the sandbox project is allowed, no ssh/deploy/prod); (3) edits outside the project folder "${projectPath}"; (4) commits/pushes to a repo not in this allowlist: ${allowedRepos.length ? allowedRepos.join(", ") : "(none declared)"}. Reply with ONLY JSON: {"ok": <true|false>, "reasons": ["secret"|"environment"|"path"|"repo", ...]}. INPUT:
-${input}`;
-  const { text, tokens } = await runAi(prompt);
-  const start = text.indexOf("{");
-  const end = text.lastIndexOf("}");
-  if (start < 0 || end <= start) return { ok: false, reasons: ["ai_parse"], tokens };
-  try {
-    const j2 = JSON.parse(text.slice(start, end + 1));
-    const reasons = Array.isArray(j2.reasons) ? j2.reasons.filter((r) => typeof r === "string") : [];
-    return { ok: j2.ok === true && reasons.length === 0, reasons, tokens };
-  } catch {
-    return { ok: false, reasons: ["ai_parse"], tokens };
-  }
-}
-
-// src/core/scaffold.ts
-var run2 = promisify2(execFile2);
 function reposOf(spec) {
   const repos = spec?.repos;
   return Array.isArray(repos) ? repos : [];
@@ -37695,7 +37669,7 @@ async function attachSubmodules(root, submodules, emit, createMissingBranch = fa
     if (existsSync4(join6(root, dir2, ".git")) || existsSync4(join6(root, ".git", "modules", dir2))) {
       emit("submodule", `Submodule ${dir2} already present \u2014 updating\u2026`);
       try {
-        await run2("git", ["submodule", "update", "--init", "--", dir2], { cwd: root, timeout: 12e4 });
+        await run("git", ["submodule", "update", "--init", "--", dir2], { cwd: root, timeout: 12e4 });
       } catch {
       }
       continue;
@@ -37709,11 +37683,11 @@ async function attachSubmodules(root, submodules, emit, createMissingBranch = fa
     const b2 = (sub.branch ?? "").trim();
     if (b2 && createMissingBranch && !await ensureRemoteBranch(sub.url, b2, emit)) {
       try {
-        await run2("git", ["submodule", "add", sub.url, dir2], { cwd: root, timeout: 12e4 });
-        await run2("git", ["config", "-f", ".gitmodules", `submodule.${dir2}.branch`, b2], { cwd: root, timeout: 3e4 });
+        await run("git", ["submodule", "add", sub.url, dir2], { cwd: root, timeout: 12e4 });
+        await run("git", ["config", "-f", ".gitmodules", `submodule.${dir2}.branch`, b2], { cwd: root, timeout: 3e4 });
         try {
-          await run2("git", ["checkout", "-b", b2], { cwd: join6(root, dir2), timeout: 3e4 });
-          await run2("git", ["push", "-u", "origin", b2], { cwd: join6(root, dir2), timeout: 12e4 });
+          await run("git", ["checkout", "-b", b2], { cwd: join6(root, dir2), timeout: 3e4 });
+          await run("git", ["push", "-u", "origin", b2], { cwd: join6(root, dir2), timeout: 12e4 });
         } catch (pushErr) {
           const pmsg = pushErr instanceof Error ? pushErr.message : String(pushErr);
           emit("git-branch-push-failed", `Submodule ${dir2}: branch "${b2}" created locally but the push failed: ${pmsg}`);
@@ -37728,13 +37702,13 @@ async function attachSubmodules(root, submodules, emit, createMissingBranch = fa
       }
     }
     try {
-      await run2("git", ["submodule", "add", ...b2 ? ["-b", b2] : [], sub.url, dir2], { cwd: root, timeout: 12e4 });
+      await run("git", ["submodule", "add", ...b2 ? ["-b", b2] : [], sub.url, dir2], { cwd: root, timeout: 12e4 });
       added++;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       if (/already exists|already registered|in the index/i.test(msg)) {
         try {
-          await run2("git", ["submodule", "update", "--init", "--", dir2], { cwd: root, timeout: 12e4 });
+          await run("git", ["submodule", "update", "--init", "--", dir2], { cwd: root, timeout: 12e4 });
           added++;
         } catch {
         }
@@ -37753,18 +37727,18 @@ async function commitAndPushSubmodules(root, submodules, emit) {
   ];
   if (addPaths.length === 0) return;
   emit("submodule", "Committing .gitmodules\u2026");
-  await run2("git", ["add", ...addPaths], { cwd: root, timeout: 6e4 });
-  const staged = (await run2("git", ["diff", "--cached", "--name-only"], { cwd: root, timeout: 3e4 })).stdout.trim();
+  await run("git", ["add", ...addPaths], { cwd: root, timeout: 6e4 });
+  const staged = (await run("git", ["diff", "--cached", "--name-only"], { cwd: root, timeout: 3e4 })).stdout.trim();
   if (!staged) return;
   const commitArgs = ["commit", "-m", "chore: add git submodules (4PM)"];
   try {
-    await run2("git", commitArgs, { cwd: root, timeout: 6e4 });
+    await run("git", commitArgs, { cwd: root, timeout: 6e4 });
   } catch {
-    await run2("git", ["-c", "user.name=4PM", "-c", "user.email=noreply@4pm.app", ...commitArgs], { cwd: root, timeout: 6e4 });
+    await run("git", ["-c", "user.name=4PM", "-c", "user.email=noreply@4pm.app", ...commitArgs], { cwd: root, timeout: 6e4 });
   }
   emit("submodule", "Pushing .gitmodules to the primary remote\u2026");
   try {
-    await run2("git", ["push"], { cwd: root, timeout: 12e4 });
+    await run("git", ["push"], { cwd: root, timeout: 12e4 });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     emit("submodule-push-failed", `Submodules committed locally but the push failed: ${msg}`);
@@ -37777,22 +37751,22 @@ function providerSlug(url) {
 }
 async function commitAndOpenPr(root, repo, emit) {
   emit("commit", "Committing the scaffolded project\u2026");
-  await run2("git", ["add", "-A"], { cwd: root, timeout: 6e4 });
-  const staged = (await run2("git", ["diff", "--cached", "--name-only"], { cwd: root, timeout: 3e4 })).stdout.trim();
+  await run("git", ["add", "-A"], { cwd: root, timeout: 6e4 });
+  const staged = (await run("git", ["diff", "--cached", "--name-only"], { cwd: root, timeout: 3e4 })).stdout.trim();
   if (!staged) {
     emit("commit", "Nothing to commit \u2014 skipping the pull request.");
     return;
   }
   const commitArgs = ["commit", "-m", "chore: scaffold project (4PM)"];
   try {
-    await run2("git", commitArgs, { cwd: root, timeout: 6e4 });
+    await run("git", commitArgs, { cwd: root, timeout: 6e4 });
   } catch {
-    await run2("git", ["-c", "user.name=4PM", "-c", "user.email=noreply@4pm.app", ...commitArgs], { cwd: root, timeout: 6e4 });
+    await run("git", ["-c", "user.name=4PM", "-c", "user.email=noreply@4pm.app", ...commitArgs], { cwd: root, timeout: 6e4 });
   }
   const branch = (repo.branch ?? "").trim();
   emit("push", "Pushing the scaffold branch\u2026");
   try {
-    await run2("git", ["push", "-u", "origin", ...branch ? [branch] : ["HEAD"]], { cwd: root, timeout: 12e4 });
+    await run("git", ["push", "-u", "origin", ...branch ? [branch] : ["HEAD"]], { cwd: root, timeout: 12e4 });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     emit("push-failed", `Scaffold committed locally but the push failed: ${msg} \u2014 push it from the Git tab when credentials are available.`);
@@ -37806,7 +37780,7 @@ async function commitAndOpenPr(root, repo, emit) {
   emit("pr", `Opening a pull request via ${provider}\u2026`);
   try {
     const args = provider === "glab" ? ["mr", "create", "--fill", ...slug ? ["-R", slug] : []] : ["pr", "create", "--fill", ...slug ? ["-R", slug] : []];
-    const { stdout } = await run2(provider, args, { cwd: root, timeout: 12e4 });
+    const { stdout } = await run(provider, args, { cwd: root, timeout: 12e4 });
     const link2 = stdout.trim().split(/\s+/).find((s3) => /^https?:\/\//.test(s3)) ?? stdout.trim().split("\n").pop() ?? "";
     emit("pr", `Pull request opened${link2 ? `: ${link2}` : "."}`);
   } catch (err) {
@@ -37820,7 +37794,7 @@ function cloneArgs(url, dest, branch) {
 }
 async function remoteHasBranch(url, branch) {
   try {
-    const { stdout } = await run2("git", ["ls-remote", "--heads", url, branch], { timeout: 3e4 });
+    const { stdout } = await run("git", ["ls-remote", "--heads", url, branch], { timeout: 3e4 });
     return stdout.trim().length > 0;
   } catch {
     return false;
@@ -37831,9 +37805,9 @@ async function ensureRemoteBranch(url, branch, emit) {
   const tmp = await mkdtemp(join6(tmpdir2(), "4pm-branch-"));
   try {
     emit("git", `Branch "${branch}" not found on ${url} \u2014 creating it from the default branch\u2026`);
-    await run2("git", ["clone", "--depth", "1", url, tmp], { timeout: 12e4 });
-    await run2("git", ["checkout", "-b", branch], { cwd: tmp, timeout: 3e4 });
-    await run2("git", ["push", "-u", "origin", branch], { cwd: tmp, timeout: 12e4 });
+    await run("git", ["clone", "--depth", "1", url, tmp], { timeout: 12e4 });
+    await run("git", ["checkout", "-b", branch], { cwd: tmp, timeout: 3e4 });
+    await run("git", ["push", "-u", "origin", branch], { cwd: tmp, timeout: 12e4 });
     return true;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -37846,9 +37820,9 @@ async function ensureRemoteBranch(url, branch, emit) {
 async function updateRepo(dir2, branch, emit) {
   const b2 = (branch ?? "").trim();
   emit("git", `Updating repository (fetch + ${b2 ? `checkout ${b2} + ` : ""}fast-forward pull)\u2026`);
-  await run2("git", ["fetch", "origin", "--prune"], { cwd: dir2, timeout: 12e4 });
-  if (b2) await run2("git", ["checkout", b2], { cwd: dir2, timeout: 6e4 });
-  await run2("git", ["pull", "--ff-only"], { cwd: dir2, timeout: 12e4 });
+  await run("git", ["fetch", "origin", "--prune"], { cwd: dir2, timeout: 12e4 });
+  if (b2) await run("git", ["checkout", b2], { cwd: dir2, timeout: 6e4 });
+  await run("git", ["pull", "--ff-only"], { cwd: dir2, timeout: 12e4 });
 }
 async function provisionRepo(target, repo, emit, opts = {}) {
   const mode = opts.mode ?? "clone";
@@ -37856,7 +37830,7 @@ async function provisionRepo(target, repo, emit, opts = {}) {
     if (!existsSync4(join6(target, ".git"))) {
       emit("git", "Initializing repository\u2026");
       await mkdir(target, { recursive: true });
-      await run2("git", ["init"], { cwd: target, timeout: 2e4 });
+      await run("git", ["init"], { cwd: target, timeout: 2e4 });
     }
     return;
   }
@@ -37866,7 +37840,7 @@ async function provisionRepo(target, repo, emit, opts = {}) {
     } else if (mode === "force") {
       emit("git", `Re-cloning ${repo.url} (force)\u2026`);
       await rm(target, { recursive: true, force: true });
-      await run2("git", cloneArgs(repo.url, target, repo.branch), { timeout: 12e4 });
+      await run("git", cloneArgs(repo.url, target, repo.branch), { timeout: 12e4 });
     } else {
       emit("git", "Repository already present \u2014 skipping clone.");
     }
@@ -37875,10 +37849,10 @@ async function provisionRepo(target, repo, emit, opts = {}) {
   const b2 = (repo.branch ?? "").trim();
   if (b2 && opts.createMissingBranch && !await remoteHasBranch(repo.url, b2)) {
     emit("git", `Cloning ${repo.url} (default branch) to create "${b2}"\u2026`);
-    await run2("git", ["clone", repo.url, target], { timeout: 12e4 });
-    await run2("git", ["checkout", "-b", b2], { cwd: target, timeout: 3e4 });
+    await run("git", ["clone", repo.url, target], { timeout: 12e4 });
+    await run("git", ["checkout", "-b", b2], { cwd: target, timeout: 3e4 });
     try {
-      await run2("git", ["push", "-u", "origin", b2], { cwd: target, timeout: 12e4 });
+      await run("git", ["push", "-u", "origin", b2], { cwd: target, timeout: 12e4 });
       emit("git", `Created and pushed branch "${b2}".`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -37887,7 +37861,7 @@ async function provisionRepo(target, repo, emit, opts = {}) {
     return;
   }
   emit("git", `Cloning ${repo.url}\u2026`);
-  await run2("git", cloneArgs(repo.url, target, repo.branch), { timeout: 12e4 });
+  await run("git", cloneArgs(repo.url, target, repo.branch), { timeout: 12e4 });
 }
 async function ensureReposCloned(physicRoot, repos, emit) {
   const list = repos;
@@ -37900,27 +37874,27 @@ async function ensureReposCloned(physicRoot, repos, emit) {
 function sampleDir() {
   if (process.env.SCAFFOLD_SAMPLE_DIR) return process.env.SCAFFOLD_SAMPLE_DIR;
   const here = dirname3(fileURLToPath3(import.meta.url));
-  const bundled = resolve2(here, "project-sample");
-  for (const candidate of [bundled, resolve2(here, "../project-sample"), resolve2(here, "../../project-sample")]) {
+  const bundled = resolve(here, "project-sample");
+  for (const candidate of [bundled, resolve(here, "../project-sample"), resolve(here, "../../project-sample")]) {
     if (existsSync4(candidate)) return candidate;
   }
   return bundled;
 }
-async function scaffoldProject(payload, profileDir2, onProgress) {
+async function scaffoldProject(payload, profileDir2, onProgress, ai2) {
   let lastStep = "start";
   const emit = (step, message) => {
     lastStep = step;
     onProgress?.({ projectId: payload.projectId, step, message });
   };
   try {
-    const root = process.env.SCAFFOLD_ROOT ? resolve2(process.env.SCAFFOLD_ROOT) : resolve2(profileDir2);
+    const root = process.env.SCAFFOLD_ROOT ? resolve(process.env.SCAFFOLD_ROOT) : resolve(profileDir2);
     const target = join6(root, payload.projectName);
     await mkdir(target, { recursive: true });
     const repo = singleRepo(reposOf(payload.spec));
     if (!repo) throw new Error("A project must declare one repo (ADR-0314).");
     emit("git", "Cloning repository\u2026");
     await provisionRepo(target, repo, emit, { createMissingBranch: true });
-    await scaffoldRepo(target, payload.projectName, payload.spec, emit, { resetClaude: true });
+    await scaffoldRepo(target, payload.projectName, payload.spec, emit, { resetClaude: true, ai: ai2 });
     await attachSubmodules(target, submodulesOf(reposOf(payload.spec)), emit, true);
     emit("version", "Writing .4pm/.4pm.json\u2026");
     await writeTemplateMarker(target);
@@ -37939,7 +37913,7 @@ async function scaffoldRepo(dir2, label, spec, emit, opts = {}) {
   if (spec) {
     emit("spec", `Writing project.spec.json into ${label}\u2026`);
     await writeFile(join6(dir2, "project.spec.json"), JSON.stringify(spec, null, 2), "utf8");
-    await aiInit(dir2, spec, emit);
+    await aiInit(dir2, spec, emit, opts.ai);
   }
 }
 async function resetTemplateManagedClaude(dir2, label, emit) {
@@ -37965,7 +37939,7 @@ function readSpecField(spec, key) {
   }
   return typeof spec[key] === "string" ? spec[key] : "";
 }
-async function aiInit(target, spec, emit) {
+async function aiInit(target, spec, emit, ai2) {
   const guideFile = readSpecField(spec, "ai_guide_file") === "AGENT.md" ? "AGENT.md" : "CLAUDE.md";
   const guideInstructions = readSpecField(spec, "ai_guide_instructions").trim();
   emit("ai-init", `AI init: subagents, README, ${guideFile}\u2026`);
@@ -37985,25 +37959,47 @@ ${(sa.description || "").trim()}
     }
   }
   const specJson = JSON.stringify(spec);
-  await generateFile(
-    join6(target, "README.md"),
-    `Write a concise README.md (Markdown only, no preamble) for this project from its spec JSON:
+  let generate3 = null;
+  let releaseSlot = () => void 0;
+  if (ai2) {
+    const slot = await ai2.acquireSlot(
+      (q2) => emit("ai-queued", `Waiting for an AI run slot \u2014 ${q2.position} ahead (${q2.running}/${q2.limit} parallel runs in use)\u2026`)
+    );
+    if (slot.kind === "granted") {
+      releaseSlot = () => slot.handle.release();
+      generate3 = (prompt, label) => ai2.generate(prompt, target, label);
+      if (slot.queued) emit("ai-init", `AI init: subagents, README, ${guideFile}\u2026`);
+    } else {
+      emit("ai-skipped", "No AI run slot freed up in time \u2014 AI init skipped; fallback content written.");
+    }
+  }
+  try {
+    await generateFile(
+      generate3,
+      join6(target, "README.md"),
+      "README.md",
+      `Write a concise README.md (Markdown only, no preamble) for this project from its spec JSON:
 ${specJson}`
-  );
-  await generateFile(
-    join6(target, guideFile),
-    `Write a ${guideFile} (Markdown only, no preamble) with guidance/conventions for AI agents working in this project, derived from its spec JSON:
+    );
+    await generateFile(
+      generate3,
+      join6(target, guideFile),
+      guideFile,
+      `Write a ${guideFile} (Markdown only, no preamble) with guidance/conventions for AI agents working in this project, derived from its spec JSON:
 ${specJson}` + (guideInstructions ? `
 Also incorporate these additional instructions/content:
 ${guideInstructions}
 ` : ""),
-    guideInstructions
-  );
+      guideInstructions
+    );
+  } finally {
+    releaseSlot();
+  }
 }
-async function generateFile(path, prompt, fallback) {
+async function generateFile(generate3, path, label, prompt, fallback) {
   try {
-    const text = await aiGenerate(prompt);
-    if (text.trim()) {
+    const text = generate3 ? await generate3(prompt, label) : null;
+    if (text && text.trim()) {
       await writeFile(path, text.trim() + "\n", "utf8");
       return;
     }
@@ -38011,21 +38007,21 @@ async function generateFile(path, prompt, fallback) {
   }
   if (fallback && fallback.trim()) await writeFile(path, fallback.trim() + "\n", "utf8");
 }
-async function addProject(payload, profileDir2, onProgress) {
+async function addProject(payload, profileDir2, onProgress, ai2) {
   let lastStep = "start";
   const emit = (step, message) => {
     lastStep = step;
     onProgress?.({ projectId: payload.projectId, step, message });
   };
   try {
-    const root = process.env.SCAFFOLD_ROOT ? resolve2(process.env.SCAFFOLD_ROOT) : resolve2(profileDir2);
+    const root = process.env.SCAFFOLD_ROOT ? resolve(process.env.SCAFFOLD_ROOT) : resolve(profileDir2);
     const target = join6(root, payload.projectName);
     await mkdir(target, { recursive: true });
     const repo = singleRepo(payload.repos ?? []);
     const mode = payload.mode ?? "clone";
     if (repo) await provisionRepo(target, repo, emit, { mode });
     if (payload.scaffoldRepos && payload.scaffoldRepos.length > 0) {
-      await scaffoldRepo(target, payload.projectName, payload.spec, emit);
+      await scaffoldRepo(target, payload.projectName, payload.spec, emit, { ai: ai2 });
     }
     await attachSubmodules(target, submodulesOf(payload.repos ?? []), emit);
     onProgress?.({ projectId: payload.projectId, step: "done", message: "Project added.", done: true });
@@ -38432,6 +38428,9 @@ var WsChannels = {
   CLI_UPDATE_RESULT: "cli.update-result",
   // command lifecycle
   COMMAND_ANNOUNCE: "command.announce",
+  // server → cli (reply): stop an AI run (ADR-0362) — queued ⇒ leave the run-slot queue, running ⇒ kill
+  // the AI process with no failover; the cli then ends the stream with `command.output {done, cancelled}`.
+  COMMAND_CANCEL: "command.cancel",
   // console transcript sync (ADR-0150): the cli streams its authoritative SessionBus
   // transcript so the web Console renders it verbatim; gated by console.watch (server → cli:
   // whether a web viewer is attached) so an unwatched cli syncs nothing.
@@ -38449,6 +38448,9 @@ var WsChannels = {
   QUOTA_CHECK: "quota.check",
   // cli → server (reply): per-org concurrent AI-run slot — acquire / renew / release (ADR-0359)
   RUN_SLOT: "run.slot",
+  // cli → server (reply): read / add the org's monthly autonomous-book counters — USER_TODO / USER_QA /
+  // AI_TODO rows vs `autonomousRequestsPerMonth` (ADR-0365)
+  AUTONOMOUS_BOOK_USAGE: "autonomous.bookUsage",
   USAGE_REPORT: "usage.report",
   // cli → server: Claude subscription usage snapshot (5h / weekly — ADR-0072)
   MACHINE_USAGE: "machine.usage",
@@ -38551,6 +38553,7 @@ function decryptPayload(key, payloadBase64, nonceBase64) {
 var RUN_SLOT_RENEW_MS = 45e3;
 var RUN_SLOT_RETRY_MS = 3e3;
 var RUN_SLOT_MAX_WAIT_MS = 30 * 6e4;
+var COMMAND_CANCELLED_EXIT_CODE = 130;
 
 // src/core/update-scheduler.ts
 import { spawn as spawn2 } from "child_process";
@@ -38696,7 +38699,7 @@ function classifyToolFailure(code, out) {
   }
   return { reason: "other", retryable: false };
 }
-function run3(cmd, args, onLine, timeoutMs = 18e4) {
+function run2(cmd, args, onLine, timeoutMs = 18e4) {
   return new Promise((resolve12) => {
     let out = "";
     let buf = "";
@@ -38736,13 +38739,13 @@ function run3(cmd, args, onLine, timeoutMs = 18e4) {
   });
 }
 async function detectOne(cmd, versionArg) {
-  const { code, out } = await run3(cmd, [versionArg], void 0, 15e3);
+  const { code, out } = await run2(cmd, [versionArg], void 0, 15e3);
   if (code !== 0) return null;
   const first = out.split("\n").map((l) => l.trim()).find(Boolean);
   return first ?? "";
 }
 async function listExtras(autoUpdateSet = /* @__PURE__ */ new Set()) {
-  const { out } = await run3("npm", ["ls", "-g", "--depth=0", "--json"], void 0, 2e4);
+  const { out } = await run2("npm", ["ls", "-g", "--depth=0", "--json"], void 0, 2e4);
   if (!out.trim()) return [];
   let deps = {};
   try {
@@ -38818,7 +38821,7 @@ async function runWorkerToolOp(op, name, manager, onLine, timeoutMs = TOOL_INSTA
     return { ok: false, exitCode: 1, error: resolved.error ?? "Invalid package." };
   }
   onLine(`$ ${manager} ${opArgs(op, manager, resolved.pkg).join(" ")}`);
-  const { code, out } = await run3(manager, opArgs(op, manager, resolved.pkg), onLine, timeoutMs);
+  const { code, out } = await run2(manager, opArgs(op, manager, resolved.pkg), onLine, timeoutMs);
   if (code === 0) return { ok: true, exitCode: code };
   const detail = extractToolError(out);
   return { ok: false, exitCode: code, error: detail ? `${manager} exited ${code}: ${detail}` : `${manager} exited ${code}` };
@@ -38851,7 +38854,7 @@ async function installPinned(name, version, manager, onLine, timeoutMs = TOOL_IN
   for (let attempt = 1; attempt <= TOOL_INSTALL_MAX_ATTEMPTS; attempt++) {
     const suffix = attempt > 1 ? ` (attempt ${attempt}/${TOOL_INSTALL_MAX_ATTEMPTS})` : "";
     onLine(`$ ${manager} ${args.join(" ")}${suffix}`);
-    const { code, out } = await run3(manager, args, onLine, timeoutMs);
+    const { code, out } = await run2(manager, args, onLine, timeoutMs);
     if (code === 0) return { ok: true };
     const { reason, retryable } = classifyToolFailure(code, out);
     if (!retryable || attempt === TOOL_INSTALL_MAX_ATTEMPTS) {
@@ -39135,6 +39138,36 @@ function clearPinnedCredential(profileDir2) {
 import { readFileSync as readFileSync8 } from "fs";
 import { homedir as homedir3 } from "os";
 import { basename, isAbsolute as isAbsolute2, join as join9 } from "path";
+
+// src/utils/agent-deny.ts
+import { isAbsolute, resolve as resolve2 } from "path";
+var HOME_SECRET_PATTERNS = [
+  "~/.4pm/**",
+  "~/.ssh/**",
+  "~/.config/gh/**",
+  "~/.git-credentials",
+  "~/.claude*",
+  "~/.claude*/**"
+];
+function absDirPattern(dir2) {
+  const abs = (isAbsolute(dir2) ? dir2 : resolve2(dir2)).replace(/\\/g, "/").replace(/\/+$/, "");
+  return `/${abs.startsWith("/") ? abs : `/${abs}`}/**`;
+}
+function agentDenyRules(profileDirs2 = []) {
+  const patterns = new Set(HOME_SECRET_PATTERNS);
+  for (const dir2 of profileDirs2) {
+    if (dir2 && dir2.trim()) patterns.add(absDirPattern(dir2.trim()));
+  }
+  const rules = [];
+  for (const p2 of patterns) rules.push(`Read(${p2})`, `Edit(${p2})`);
+  return rules;
+}
+function denySettingsArgs(cmd, profileDirs2 = []) {
+  if (!cmd.includes("claude")) return [];
+  return ["--settings", JSON.stringify({ permissions: { deny: agentDenyRules(profileDirs2) } })];
+}
+
+// src/utils/ai-cli.ts
 var REQUIRED_AI_ARGS = {
   claude: ["-p", "--output-format", "stream-json", "--verbose"],
   codex: ["exec", "--json"],
@@ -39811,12 +39844,12 @@ function pruneCommandOutputByAge(days) {
 
 // src/core/support-answer.ts
 import { spawn as spawn4 } from "child_process";
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync10, mkdirSync as mkdirSync5, mkdtempSync as mkdtempSync2, readdirSync as readdirSync5, readFileSync as readFileSync12, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync7 } from "fs";
 import { join as join14 } from "path";
 import { tmpdir as tmpdir3 } from "os";
-import { promisify as promisify3 } from "util";
+import { promisify as promisify2 } from "util";
 
 // src/core/ai-stream.ts
 function assistantText(ev) {
@@ -39921,7 +39954,7 @@ function aiProviderOf(cmd) {
   if (cmd.includes("antigravity")) return "antigravity";
   return "claude";
 }
-function estimateTokens2(text) {
+function estimateTokens(text) {
   return Math.max(1, Math.ceil(text.length / 4));
 }
 
@@ -39977,7 +40010,7 @@ function gitAuthArgs(user, password) {
 
 // src/core/support-answer.ts
 var NO_USAGE = { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
-var execFileAsync = promisify3(execFile3);
+var execFileAsync = promisify2(execFile2);
 var MAX_CONTEXT_CHARS = 12e4;
 var ANSWER_TIMEOUT_MS = 12e4;
 var LEGAL_DRAFT_TIMEOUT_MS = 54e4;
@@ -40274,7 +40307,7 @@ async function runSupportAnswer(req, ai2, profileDir2) {
     if (!text) return { body: "", error: "empty answer" };
     const { body, moderation } = req.task ? { body: text.trim(), moderation: void 0 } : parseModeratedAnswer(text);
     if (!body) return { body: "", error: "empty answer" };
-    const u2 = usage.tokens > 0 ? usage : { ...NO_USAGE, tokens: estimateTokens2(body) };
+    const u2 = usage.tokens > 0 ? usage : { ...NO_USAGE, tokens: estimateTokens(body) };
     return {
       body,
       ...moderation ? { moderation } : {},
@@ -40323,9 +40356,9 @@ function reportToolResult(tool, ok, message) {
 // src/core/autonomous.ts
 import { readFile as readFile4, writeFile as writeFile4, chmod } from "fs/promises";
 import { readFileSync as readFileSync14 } from "fs";
-import { execFile as execFile4, spawn as spawn5 } from "child_process";
+import { execFile as execFile3, spawn as spawn5 } from "child_process";
 import { join as join17 } from "path";
-import { promisify as promisify4 } from "util";
+import { promisify as promisify3 } from "util";
 
 // src/core/autonomous-config.ts
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
@@ -40436,7 +40469,7 @@ function pushRecord(h, rec) {
 }
 
 // src/core/autonomous.ts
-var run4 = promisify4(execFile4);
+var run3 = promisify3(execFile3);
 var APPROVALS_REL = ".claude/.autonomous.approvals.json";
 var AUTHORS_REL = ".claude/.autonomous.authors.json";
 var TICK_REL = ".claude/hooks/autonomous-tick.sh";
@@ -40495,12 +40528,20 @@ function tableRowsById(md) {
   }
   return rows;
 }
+var CAPPED_BOOK_FILES = { USER_TODO: "USER_TODO.md", USER_QA: "USER_QA.md", AI_TODO: "AI_TODO.md" };
+async function cappedBookIds(root) {
+  const out = {};
+  for (const [book, file] of Object.entries(CAPPED_BOOK_FILES)) {
+    out[book] = new Set(tableRowsById(await readText(join17(root, file))).keys());
+  }
+  return out;
+}
 function tickScript(root) {
   return join17(root, TICK_REL);
 }
 async function crontabList() {
   try {
-    const { stdout } = await run4("crontab", ["-l"], { timeout: 1e4 });
+    const { stdout } = await run3("crontab", ["-l"], { timeout: 1e4 });
     return stdout;
   } catch {
     return "";
@@ -40586,6 +40627,7 @@ async function uninstallCron(root) {
   await crontabSet(kept.join("\n"));
 }
 async function writeAutonomous(root, profileDir2, req, by) {
+  let added;
   try {
     switch (req.kind) {
       case "settings": {
@@ -40630,6 +40672,7 @@ async function writeAutonomous(root, profileDir2, req, by) {
         const row = `| ${id} | | | ${tableCell(req.content)} |
 `;
         await writeFile4(join17(root, BOOK_FILES.userTodo), cur.replace(/\s*$/, "\n") + row, "utf8");
+        added = 1;
         const authors = await readJsonMap(join17(root, AUTHORS_REL));
         authors[id] = { by, byLabel: req.byLabel ?? by, at: (/* @__PURE__ */ new Date()).toISOString() };
         await writeFile4(join17(root, AUTHORS_REL), JSON.stringify(authors, null, 2) + "\n", "utf8");
@@ -40642,8 +40685,10 @@ async function writeAutonomous(root, profileDir2, req, by) {
         const authors = await readJsonMap(join17(root, AUTHORS_REL));
         const at2 = (/* @__PURE__ */ new Date()).toISOString();
         const byLabel = req.byLabel ?? by;
+        added = 0;
         for (const [id, cells] of next) {
           if (prev.get(id) !== cells) authors[id] = { by, byLabel, at: at2 };
+          if (!prev.has(id)) added += 1;
         }
         await writeFile4(join17(root, file), req.content, "utf8");
         await writeFile4(join17(root, AUTHORS_REL), JSON.stringify(authors, null, 2) + "\n", "utf8");
@@ -40655,7 +40700,7 @@ async function writeAutonomous(root, profileDir2, req, by) {
         break;
       }
     }
-    return { ok: true, status: await getAutonomousStatus(root, profileDir2) };
+    return { ok: true, status: await getAutonomousStatus(root, profileDir2), ...added !== void 0 ? { added } : {} };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
@@ -40988,9 +41033,20 @@ async function runCommand(dispatch, emitRaw, opts) {
     hardKillTimer.unref?.();
   }, timeoutMs) : null;
   timeoutTimer?.unref?.();
+  let cancelled = false;
+  const onAbort = () => {
+    if (cancelled) return;
+    cancelled = true;
+    child.kill("SIGTERM");
+    hardKillTimer = setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS);
+    hardKillTimer.unref?.();
+  };
+  if (opts?.signal?.aborted) onAbort();
+  else opts?.signal?.addEventListener("abort", onAbort, { once: true });
   const clearTimers = () => {
     if (timeoutTimer) clearTimeout(timeoutTimer);
     if (hardKillTimer) clearTimeout(hardKillTimer);
+    opts?.signal?.removeEventListener("abort", onAbort);
   };
   const batcher = new OutputBatcher({
     onFlush: (chunk, truncated) => {
@@ -41017,9 +41073,10 @@ async function runCommand(dispatch, emitRaw, opts) {
         seq: seq++,
         chunk: "",
         done: true,
-        // 124 (the conventional timeout code) when we killed it for exceeding the limit, so the
-        // server settles the command as failed and the web surfaces the note instead of spinning.
-        exitCode: timedOut ? 124 : exitCode ?? -1
+        // 130 when the run was stopped (ADR-0362); 124 (the conventional timeout code) when we killed it
+        // for exceeding the limit, so the server settles the command as failed and the web surfaces the
+        // note instead of spinning.
+        exitCode: cancelled ? COMMAND_CANCELLED_EXIT_CODE : timedOut ? 124 : exitCode ?? -1
       });
       resolve12();
     });
@@ -41055,7 +41112,7 @@ function isOutOfCredits(text) {
     text
   );
 }
-function runAttempt(commandId, cmd, args, stdin, cwd2, env3, onChunk, timeoutMs) {
+function runAttempt(commandId, cmd, args, stdin, cwd2, env3, onChunk, timeoutMs, signal) {
   return new Promise((resolve12) => {
     runCommand(
       { commandId, cmd, args, path: cwd2, env: env3 },
@@ -41063,16 +41120,17 @@ function runAttempt(commandId, cmd, args, stdin, cwd2, env3, onChunk, timeoutMs)
         if (out.chunk) onChunk(out.chunk);
         if (out.done) resolve12(out.exitCode ?? -1);
       },
-      { stdin, ...timeoutMs > 0 ? { timeoutMs } : {} }
+      { stdin, ...timeoutMs > 0 ? { timeoutMs } : {}, ...signal ? { signal } : {} }
     ).catch(() => resolve12(-1));
   });
 }
-async function runAiFailover(plan, commandId, cwd2, handlers, timeoutMs = 0) {
+async function runAiFailover(plan, commandId, cwd2, handlers, timeoutMs = 0, signal) {
   const total = plan.attempts.length;
   let finalExit = -1;
   let lastCmd = plan.attempts[0]?.cmd ?? "claude";
   let lastCaptured = "";
   for (let i = 0; i < total; i++) {
+    if (signal?.aborted) return cancelledResult();
     const attempt = plan.attempts[i];
     lastCmd = attempt.cmd;
     if (total > 1) handlers.onAttemptStart(attempt.label, i, total, attempt.cmd);
@@ -41085,17 +41143,18 @@ async function runAiFailover(plan, commandId, cwd2, handlers, timeoutMs = 0) {
         handlers.onChunk(text);
       }
     };
-    finalExit = await runAttempt(commandId, attempt.cmd, attempt.args, attempt.stdin, cwd2, attempt.env, emit, timeoutMs);
+    finalExit = await runAttempt(commandId, attempt.cmd, attempt.args, attempt.stdin, cwd2, attempt.env, emit, timeoutMs, signal);
     const tail = parser.flush();
     if (tail) {
       captured += tail;
       handlers.onChunk(tail);
     }
+    if (signal?.aborted) return cancelledResult();
     lastCaptured = captured;
     const apiErr = parser.apiError();
     if (finalExit === 0 && !apiErr.isError) {
       const usage = parser.usage();
-      if (usage.tokens === 0) usage.tokens = estimateTokens2(captured);
+      if (usage.tokens === 0) usage.tokens = estimateTokens(captured);
       reportToolResult(attempt.cmd, true);
       return {
         exitCode: 0,
@@ -41114,6 +41173,17 @@ async function runAiFailover(plan, commandId, cwd2, handlers, timeoutMs = 0) {
   reportToolResult(lastCmd, false, summarizeAiFailure(lastCaptured, finalExit));
   return { exitCode: finalExit, workedDir: null, workedKey: null, workedCmd: null, usage: { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 }, sessionId: "" };
 }
+function cancelledResult() {
+  return {
+    exitCode: COMMAND_CANCELLED_EXIT_CODE,
+    workedDir: null,
+    workedKey: null,
+    workedCmd: null,
+    usage: { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 },
+    sessionId: "",
+    cancelled: true
+  };
+}
 function summarizeAiFailure(captured, exitCode) {
   if (isAuthFailure(captured)) return "Not logged in";
   if (isOutOfCredits(captured)) return "Out of usage credits";
@@ -41642,21 +41712,30 @@ async function runMemoryCompaction(ai2, cwd2, input) {
 }
 
 // src/core/git-commit-identity.ts
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify5 } from "util";
-var run5 = promisify5(execFile5);
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var run4 = promisify4(execFile4);
 async function setCommitAuthor(cwd2, machineUsername) {
   if (!machineUsername) return;
   try {
-    await run5("git", ["config", "--local", "user.name", machineUsername], { cwd: cwd2, timeout: 8e3 });
+    await run4("git", ["config", "--local", "user.name", machineUsername], { cwd: cwd2, timeout: 8e3 });
   } catch {
   }
 }
 
 // src/core/ws-client/run-slot.ts
 var NO_SLOT = { release: () => void 0 };
-function sleep2(ms2) {
-  return new Promise((resolve12) => setTimeout(resolve12, ms2));
+function sleep2(ms2, signal) {
+  return new Promise((resolve12) => {
+    if (signal?.aborted) return resolve12();
+    const timer = setTimeout(done, ms2);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve12();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
 }
 function holdLease(ctx, lease) {
   const timer = setInterval(() => {
@@ -41673,23 +41752,30 @@ function holdLease(ctx, lease) {
     }
   };
 }
-async function acquireRunSlot(ctx, onQueued) {
+async function acquireRunSlot(ctx, onQueued, signal) {
   const startedAt = Date.now();
   let ticket;
   let lastPosition = -1;
   let limit = 0;
   for (; ; ) {
+    if (signal?.aborted) return leaveQueue(ctx, ticket);
     let reply;
     try {
       reply = await ctx.request(WsChannels.RUN_SLOT, { op: "acquire", ...ticket ? { ticket } : {} });
     } catch (err) {
       logger.warn("run.slot.unavailable", { error: err.message });
-      return { kind: "granted", handle: NO_SLOT };
+      return { kind: "granted", handle: NO_SLOT, queued: ticket !== void 0 };
     }
-    if (!reply || !("granted" in reply)) return { kind: "granted", handle: NO_SLOT };
+    if (!reply || !("granted" in reply)) return { kind: "granted", handle: NO_SLOT, queued: ticket !== void 0 };
     if (reply.granted) {
-      return { kind: "granted", handle: reply.lease ? holdLease(ctx, reply.lease) : NO_SLOT };
+      const handle = reply.lease ? holdLease(ctx, reply.lease) : NO_SLOT;
+      if (signal?.aborted) {
+        handle.release();
+        return { kind: "cancelled" };
+      }
+      return { kind: "granted", handle, queued: ticket !== void 0 };
     }
+    if ("denied" in reply) return { kind: "denied", reason: reply.denied };
     ticket = reply.ticket;
     limit = reply.limit;
     if (reply.position !== lastPosition) {
@@ -41697,13 +41783,31 @@ async function acquireRunSlot(ctx, onQueued) {
       onQueued({ position: reply.position, limit: reply.limit, running: reply.running });
     }
     if (Date.now() - startedAt >= RUN_SLOT_MAX_WAIT_MS) return { kind: "timeout", limit };
-    await sleep2(reply.retryAfterMs > 0 ? reply.retryAfterMs : RUN_SLOT_RETRY_MS);
+    await sleep2(reply.retryAfterMs > 0 ? reply.retryAfterMs : RUN_SLOT_RETRY_MS, signal);
   }
 }
+function leaveQueue(ctx, ticket) {
+  if (ticket) ctx.request(WsChannels.RUN_SLOT, { op: "leave", ticket }).catch(() => void 0);
+  return { kind: "cancelled" };
+}
 
 // src/core/ws-client/command-dispatch.ts
 var MEMORY_SEED_HEADER = "CONTEXT MEMORY from earlier in this conversation (may span prior sessions/accounts). Use it as background; do not repeat it back unless relevant:";
+var activeRuns = /* @__PURE__ */ new Map();
+function cancelActiveRun(commandId) {
+  const run11 = activeRuns.get(commandId);
+  if (!run11) return { ok: false, state: "unknown" };
+  run11.controller.abort();
+  return { ok: true, state: run11.state };
+}
 function handleCommandChannels(ctx, message, payload) {
+  if (message.channel === WsChannels.COMMAND_CANCEL) {
+    const commandId = typeof payload.commandId === "string" ? payload.commandId : "";
+    const reply = cancelActiveRun(commandId);
+    logger.info("command.cancel", { commandId, ...reply });
+    ctx.send(WsChannels.COMMAND_CANCEL, reply, message.id);
+    return true;
+  }
   if (message.channel !== WsChannels.COMMAND_DISPATCH) return false;
   const dispatch = payload;
   if (ctx.hasHandledCommand(dispatch.commandId)) {
@@ -41790,6 +41894,15 @@ async function runLocalCommand(ctx, input) {
   await runAiPrompt(ctx, prompt, commandId, "local");
 }
 async function runAiPrompt(ctx, prompt, commandId, origin, oneShot = false, images, aiConfig, readOnly = false, bypass = false) {
+  const run11 = { controller: new AbortController(), state: "queued" };
+  activeRuns.set(commandId, run11);
+  try {
+    await runAiPromptInner(ctx, prompt, commandId, origin, run11, oneShot, images, aiConfig, readOnly, bypass);
+  } finally {
+    activeRuns.delete(commandId);
+  }
+}
+async function runAiPromptInner(ctx, prompt, commandId, origin, run11, oneShot = false, images, aiConfig, readOnly = false, bypass = false) {
   const config = readProfileConfig(ctx.profileDir);
   const projectTimeoutSec = config.projectAiRunTimeoutSec ?? 0;
   const machineTimeoutSec = config.aiRunTimeoutSec ?? 0;
@@ -41797,7 +41910,7 @@ async function runAiPrompt(ctx, prompt, commandId, origin, oneShot = false, imag
   const aiRunTimeoutMs = timeoutSec > 0 ? timeoutSec * 1e3 : 0;
   const perPromptLimit = config.perPromptTokenLimit ?? 0;
   if (perPromptLimit > 0) {
-    const estimated = estimateTokens2(prompt);
+    const estimated = estimateTokens(prompt);
     if (estimated > perPromptLimit) {
       rejectPromptOverLimit(ctx, commandId, origin, prompt, estimated, perPromptLimit);
       return;
@@ -41954,24 +42067,46 @@ ${guardedPrompt}`;
     }
   };
   let result;
-  let queueTimedOut = false;
+  let neverStarted = false;
   try {
-    const slot = await acquireRunSlot(ctx, ({ position, limit, running: running2 }) => {
-      const text = `\u23F3 queued \u2014 ${position} ahead, ${running2}/${limit} parallel runs in use (plan limit)`;
-      ctx.bus.push({ source: origin, kind: "log", text });
-      ctx.send(WsChannels.COMMAND_OUTPUT, { commandId, seq: seq++, chunk: `${text}
-`, log: true });
-    });
+    const slot = await acquireRunSlot(
+      ctx,
+      ({ position, limit, running: running2 }) => {
+        const text = `\u23F3 queued \u2014 ${position} ahead, ${running2}/${limit} parallel runs in use (plan limit)`;
+        ctx.bus.push({ source: origin, kind: "log", text });
+        ctx.send(WsChannels.COMMAND_OUTPUT, {
+          commandId,
+          seq: seq++,
+          chunk: `${text}
+`,
+          log: true,
+          queue: { position, limit, running: running2 }
+        });
+      },
+      run11.controller.signal
+    );
     if (slot.kind === "timeout") {
-      queueTimedOut = true;
+      neverStarted = true;
       const text = `RUN_QUEUE_TIMEOUT: waited 30 min for a free run slot (plan limit ${slot.limit} parallel runs) \u2014 not run`;
       ctx.bus.push({ source: origin, kind: "log", text, level: "warn" });
       ctx.send(WsChannels.COMMAND_OUTPUT, { commandId, seq: seq++, chunk: `${text}
 `, log: true });
       result = { exitCode: 1, workedDir: null, workedKey: null, workedCmd: null, usage: { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 }, sessionId: "" };
+    } else if (slot.kind === "denied") {
+      neverStarted = true;
+      const text = "STORAGE_QUOTA_EXCEEDED: the organization's hosted storage is full \u2014 clear storage in Settings \u203A Storage, then retry";
+      ctx.bus.push({ source: origin, kind: "log", text, level: "warn" });
+      ctx.send(WsChannels.COMMAND_OUTPUT, { commandId, seq: seq++, chunk: `${text}
+`, log: true });
+      result = { exitCode: 1, workedDir: null, workedKey: null, workedCmd: null, usage: { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 }, sessionId: "" };
+    } else if (slot.kind === "cancelled") {
+      neverStarted = true;
+      result = { exitCode: COMMAND_CANCELLED_EXIT_CODE, workedDir: null, workedKey: null, workedCmd: null, usage: { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 }, sessionId: "", cancelled: true };
     } else {
+      if (slot.queued) ctx.send(WsChannels.COMMAND_OUTPUT, { commandId, seq: seq++, chunk: "", log: true, queue: null });
+      run11.state = "running";
       try {
-        result = await runAiFailover(plan, commandId, cwd2, handlers, aiRunTimeoutMs);
+        result = await runAiFailover(plan, commandId, cwd2, handlers, aiRunTimeoutMs, run11.controller.signal);
       } finally {
         slot.handle.release();
       }
@@ -41979,6 +42114,12 @@ ${guardedPrompt}`;
   } finally {
     ctx.bus.endBusy(plan.cmd);
   }
+  if (result.cancelled) {
+    const text = "\u25A0 stopped";
+    ctx.bus.push({ source: origin, kind: "log", text, level: "warn" });
+    ctx.send(WsChannels.COMMAND_OUTPUT, { commandId, seq: seq++, chunk: `${text}
+`, log: true });
+  }
   const profileLabel = result.workedDir ? profileDisplayLabel(result.workedDir) : null;
   if (result.workedDir) {
     if (unified && result.workedKey) {
@@ -41993,14 +42134,16 @@ ${guardedPrompt}`;
     seq: seq++,
     chunk: "",
     done: true,
-    exitCode: result.exitCode
+    exitCode: result.exitCode,
+    // A stopped run (ADR-0362): the server settles it `cancelled` and the web applies nothing.
+    ...result.cancelled ? { cancelled: true } : {}
   });
   finishCommand(commandId, result.exitCode, result.usage);
   ctx.send(WsChannels.COMMAND_HISTORY, {
     commandId,
     cmd: plan.cmd,
     args: markerArgs,
-    status: result.exitCode === 0 ? "done" : "failed",
+    status: result.cancelled ? "cancelled" : result.exitCode === 0 ? "done" : "failed",
     exitCode: result.exitCode,
     tokens: result.usage.tokens,
     // The ai_tokens split for this run (ADR-0145); attached only when we metered real tokens.
@@ -42036,13 +42179,13 @@ ${guardedPrompt}`;
     });
     ctx.bus.addTokens?.(result.usage.tokens);
   }
-  if (!queueTimedOut) ctx.reportUsage(events, profileLabel);
+  if (!neverStarted) ctx.reportUsage(events, profileLabel);
   void ctx.pollUsage();
   ctx.bus.push({
     source: origin,
     kind: "exit",
-    text: result.exitCode === 0 ? "\u2713 ready \u2014 enter your next prompt" : `\u2717 ${plan.cmd} failed (exit ${result.exitCode}) \u2014 see the error above`,
-    level: result.exitCode === 0 ? "info" : "error",
+    text: result.exitCode === 0 ? "\u2713 ready \u2014 enter your next prompt" : result.cancelled ? "\u25A0 stopped \u2014 enter your next prompt" : `\u2717 ${plan.cmd} failed (exit ${result.exitCode}) \u2014 see the error above`,
+    level: result.exitCode === 0 ? "info" : result.cancelled ? "warn" : "error",
     durationMs: Date.now() - aiStartedMs
   });
   if (memCfg.enabled && result.exitCode === 0) {
@@ -42278,12 +42421,17 @@ function rejectByReview(ctx, commandId, origin, prompt, reasons) {
 import { randomUUID } from "crypto";
 import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile5, readdir as readdir2, rm as rm2, stat } from "fs/promises";
 import { join as join20 } from "path";
-function buildAutonomousCyclePrompt() {
+function buildAutonomousCyclePrompt(opts = {}) {
+  const capNote = opts.intakeBlocked ? `
+
+**Step 2 is DISABLED this cycle** \u2014 the organization reached its monthly plan limit for new \`AI_TODO\` /
+\`USER_QA\` rows. Do NOT add any row to \`AI_TODO.md\` or \`USER_QA.md\`; skip Step 2 entirely and continue
+with the already-approved work.` : "";
   return `You are running UNATTENDED as the 4PM autonomous cycle (headless, one tick). Do EXACTLY ONE small
 work cycle with the steps below, then STOP. Keep each cycle to ONE small task so you never run out of
 tokens mid-way. If a step fails, append a row to the **Incidents** table of \`AI_DONE.md\` and STOP \u2014
 do not push on. Write all books/docs/code in the language the project's \`CLAUDE.md\` specifies (default
-English).
+English).${capNote}
 
 ## Books & approval (MUST read the approvals file)
 The five "book" files at the project root \u2014 \`USER_TODO.md\`, \`USER_QA.md\`, \`AI_TODO.md\`,
@@ -42417,8 +42565,16 @@ async function runAutonomousCycle(ctx) {
     await log(`[run] cycle (tick ${hist.ticks.count}/${today})`);
     const commandId = randomUUID();
     const override = cfg.model ? { model: cfg.model } : void 0;
+    const usage = await readBookUsage(ctx);
+    const intakeBlocked = ["AI_TODO", "USER_QA"].some((b2) => {
+      const c = usage?.books[b2];
+      return !!c && c.limit !== null && c.used >= c.limit;
+    });
+    if (intakeBlocked) await log("[cap] monthly AI_TODO/USER_QA limit reached \u2014 intake skipped this cycle");
+    const booksBefore = await cappedBookIds(root);
     try {
-      await runAiPrompt(ctx, buildAutonomousCyclePrompt(), commandId, "local", false, void 0, override, false, true);
+      await runAiPrompt(ctx, buildAutonomousCyclePrompt({ intakeBlocked }), commandId, "local", false, void 0, override, false, true);
+      await reportNewBookRows(ctx, root, booksBefore);
       hist = await readHistories(root);
       hist.consecutiveFails = 0;
       await recordRun(root, hist, "success", "cycle complete", today);
@@ -42426,6 +42582,7 @@ async function runAutonomousCycle(ctx) {
       ctx.bus.autonomousDone(true);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
+      await reportNewBookRows(ctx, root, booksBefore);
       hist = await readHistories(root);
       hist.consecutiveFails += 1;
       await recordRun(root, hist, "failure", msg, today);
@@ -42442,6 +42599,25 @@ async function runAutonomousCycle(ctx) {
     running.delete(root);
   }
 }
+async function readBookUsage(ctx) {
+  try {
+    return await ctx.request(WsChannels.AUTONOMOUS_BOOK_USAGE, {});
+  } catch {
+    return null;
+  }
+}
+async function reportNewBookRows(ctx, root, before) {
+  try {
+    const after = await cappedBookIds(root);
+    const added = {};
+    for (const book of Object.keys(after)) {
+      const n = [...after[book]].filter((id) => !before[book].has(id)).length;
+      if (n > 0) added[book] = n;
+    }
+    if (Object.keys(added).length > 0) await ctx.request(WsChannels.AUTONOMOUS_BOOK_USAGE, { added });
+  } catch {
+  }
+}
 async function dayLog(root, line) {
   try {
     const dir2 = join20(root, ".claude", "logs");
@@ -42788,10 +42964,10 @@ function handleFsChannels(ctx, message, payload) {
 
 // src/core/git-diff.ts
 import { readFile as readFile8 } from "fs/promises";
-import { execFile as execFile6 } from "child_process";
+import { execFile as execFile5 } from "child_process";
 import { basename as basename5, dirname as dirname8, resolve as resolve9, sep as sep7 } from "path";
-import { promisify as promisify6 } from "util";
-var run6 = promisify6(execFile6);
+import { promisify as promisify5 } from "util";
+var run5 = promisify5(execFile5);
 function resolveInRoot5(root, relPath) {
   if (!root) return null;
   const base = resolve9(root);
@@ -42819,7 +42995,7 @@ async function gitDiff(root, path) {
   }
   let oldBuf = null;
   try {
-    const { stdout } = await run6("git", ["show", `HEAD:./${base}`], {
+    const { stdout } = await run5("git", ["show", `HEAD:./${base}`], {
       cwd: dir2,
       timeout: 15e3,
       maxBuffer: FS_TRANSFER_MAX_BYTES + 1024,
@@ -42849,12 +43025,12 @@ async function gitDiff(root, path) {
 }
 
 // src/core/git-env.ts
-import { execFile as execFile7 } from "child_process";
-import { promisify as promisify7 } from "util";
-var run7 = promisify7(execFile7);
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
+var run6 = promisify6(execFile6);
 async function hasBinary(bin, args = ["--version"]) {
   try {
-    await run7(bin, args, { timeout: 5e3 });
+    await run6(bin, args, { timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -42867,7 +43043,7 @@ async function checkGitEnv(provider) {
   let account = null;
   if (installed) {
     try {
-      const { stdout, stderr } = await run7(bin, ["auth", "status"], { timeout: 8e3 });
+      const { stdout, stderr } = await run6(bin, ["auth", "status"], { timeout: 8e3 });
       const out = `${stdout}
 ${stderr}`;
       authenticated = /logged in|logged into|✓/i.test(out);
@@ -42880,11 +43056,11 @@ ${stderr}`;
 }
 
 // src/core/git-ssh-key.ts
-import { execFile as execFile8 } from "child_process";
+import { execFile as execFile7 } from "child_process";
 import { readFile as readFile9, rm as rm4, mkdir as mkdir7 } from "fs/promises";
 import { join as join21 } from "path";
-import { promisify as promisify8 } from "util";
-var run8 = promisify8(execFile8);
+import { promisify as promisify7 } from "util";
+var run7 = promisify7(execFile7);
 function keyPaths(profileDir2) {
   const dir2 = join21(profileDir2, ".ssh");
   const key = join21(dir2, "id_4pm");
@@ -42899,14 +43075,14 @@ async function readPublicKey(pub) {
 }
 async function fingerprintOf(pub) {
   try {
-    const { stdout } = await run8("ssh-keygen", ["-lf", pub], { timeout: 5e3 });
+    const { stdout } = await run7("ssh-keygen", ["-lf", pub], { timeout: 5e3 });
     return stdout.match(/SHA256:[A-Za-z0-9+/=]+/)?.[0] ?? null;
   } catch {
     return null;
   }
 }
 async function configureGit(key) {
-  await run8(
+  await run7(
     "git",
     ["config", "--global", "core.sshCommand", `ssh -i ${key} -o IdentitiesOnly=yes`],
     { timeout: 5e3 }
@@ -42917,7 +43093,7 @@ async function generate(profileDir2) {
   await mkdir7(dir2, { recursive: true });
   await rm4(key, { force: true });
   await rm4(pub, { force: true });
-  await run8("ssh-keygen", ["-t", "ed25519", "-f", key, "-N", "", "-C", "4pm-deploy-key"], {
+  await run7("ssh-keygen", ["-t", "ed25519", "-f", key, "-N", "", "-C", "4pm-deploy-key"], {
     timeout: 15e3
   });
   await configureGit(key);
@@ -42927,7 +43103,7 @@ async function remove(profileDir2) {
   const { key, pub } = keyPaths(profileDir2);
   await rm4(key, { force: true });
   await rm4(pub, { force: true });
-  await run8("git", ["config", "--global", "--unset", "core.sshCommand"], { timeout: 5e3 }).catch(
+  await run7("git", ["config", "--global", "--unset", "core.sshCommand"], { timeout: 5e3 }).catch(
     () => void 0
   );
   return { publicKey: null, fingerprint: null };
@@ -42948,10 +43124,10 @@ async function manageSshKey(op, profileDir2) {
 }
 
 // src/core/git-history.ts
-import { execFile as execFile9 } from "child_process";
+import { execFile as execFile8 } from "child_process";
 import { resolve as resolve10, sep as sep8 } from "path";
-import { promisify as promisify9 } from "util";
-var run9 = promisify9(execFile9);
+import { promisify as promisify8 } from "util";
+var run8 = promisify8(execFile8);
 var FS = "";
 var RS = "";
 function resolveRepo(root, repo) {
@@ -42962,7 +43138,7 @@ function resolveRepo(root, repo) {
 }
 async function git(cwd2, args) {
   try {
-    const { stdout } = await run9("git", args, {
+    const { stdout } = await run8("git", args, {
       cwd: cwd2,
       timeout: 15e3,
       maxBuffer: 8 * 1024 * 1024
@@ -43104,6 +43280,74 @@ function handleGitChannels(ctx, message, payload) {
 // src/core/ws-client/handlers/misc.ts
 import { join as join22 } from "path";
 
+// src/core/ai-assist.ts
+import { execFile as execFile9 } from "child_process";
+import { promisify as promisify9 } from "util";
+var run9 = promisify9(execFile9);
+function aiCli() {
+  return process.env.AI_CLI || "claude";
+}
+function aiArgs(cli, prompt) {
+  if (cli === "claude") return ["-p", prompt, "--output-format", "json", ...denySettingsArgs(cli, [process.env.CLAUDE_CONFIG_DIR])];
+  if (cli === "codex") return ["exec", "--json", prompt];
+  return ["-p", prompt];
+}
+function estimateTokens2(prompt, output) {
+  return Math.max(1, Math.ceil((prompt.length + output.length) / 4));
+}
+function parseAi(cli, stdout, prompt) {
+  if (cli === "claude") {
+    try {
+      const j2 = JSON.parse(stdout);
+      const text2 = (j2.result ?? "").trim();
+      const tokens = (j2.usage?.input_tokens ?? 0) + (j2.usage?.output_tokens ?? 0);
+      if (text2 || tokens) return { text: text2, tokens: tokens || estimateTokens2(prompt, text2) };
+    } catch {
+    }
+  }
+  if (cli === "codex") {
+    try {
+      let text2 = "";
+      let tokens = 0;
+      for (const line of stdout.split("\n").filter(Boolean)) {
+        const obj = JSON.parse(line);
+        if (obj.text) text2 = obj.text;
+        else if (obj.message) text2 = obj.message;
+        if (obj.usage) {
+          tokens = obj.usage.total_tokens ?? (obj.usage.input_tokens ?? 0) + (obj.usage.output_tokens ?? 0);
+        }
+      }
+      if (text2 || tokens) return { text: text2.trim(), tokens: tokens || estimateTokens2(prompt, text2) };
+    } catch {
+    }
+  }
+  const text = stdout.trim();
+  return { text, tokens: estimateTokens2(prompt, text) };
+}
+async function runAi(prompt) {
+  const cli = aiCli();
+  const { stdout } = await run9(cli, aiArgs(cli, prompt), {
+    timeout: 12e4,
+    maxBuffer: 8 * 1024 * 1024
+  });
+  return parseAi(cli, stdout, prompt);
+}
+async function aiOutboundReview(input, allowedRepos, projectPath) {
+  const prompt = `You are a security reviewer for an autonomous coding agent. Decide if the following INPUT is SAFE to run. It is UNSAFE if it: (1) asks the AI using secret VALUES (api keys, env values, passwords); (2) would affect other environments (only the sandbox project is allowed, no ssh/deploy/prod); (3) edits outside the project folder "${projectPath}"; (4) commits/pushes to a repo not in this allowlist: ${allowedRepos.length ? allowedRepos.join(", ") : "(none declared)"}. Reply with ONLY JSON: {"ok": <true|false>, "reasons": ["secret"|"environment"|"path"|"repo", ...]}. INPUT:
+${input}`;
+  const { text, tokens } = await runAi(prompt);
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start < 0 || end <= start) return { ok: false, reasons: ["ai_parse"], tokens };
+  try {
+    const j2 = JSON.parse(text.slice(start, end + 1));
+    const reasons = Array.isArray(j2.reasons) ? j2.reasons.filter((r) => typeof r === "string") : [];
+    return { ok: j2.ok === true && reasons.length === 0, reasons, tokens };
+  } catch {
+    return { ok: false, reasons: ["ai_parse"], tokens };
+  }
+}
+
 // src/core/outbound-review.ts
 function compilePatterns(sources, fallback) {
   const list = sources ?? fallback;
@@ -43217,6 +43461,72 @@ function handleMiscChannels(ctx, message, payload) {
 // src/core/ws-client/handlers/project.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync7, renameSync, rmSync as rmSync7 } from "fs";
 import { join as join23 } from "path";
+
+// src/core/ai-task.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function createAiTaskRunner(ctx) {
+  return {
+    acquireSlot: (onQueued) => acquireRunSlot(ctx, onQueued),
+    generate: (prompt, cwd2, label) => generate2(ctx, prompt, cwd2, label)
+  };
+}
+async function generate2(ctx, prompt, cwd2, label) {
+  const config = readProfileConfig(ctx.profileDir);
+  const cmd = config.aiCli || "claude";
+  const unified = isUnifiedConfig(config);
+  const hint = unified ? {
+    credential: getPinnedCredential(ctx.profileDir) ?? ((config.aiFailoverMode ?? "remember") === "remember" ? getWorkingCredential(ctx.profileDir) : null)
+  } : { dir: getWorkingProfile(ctx.profileDir, cmd) };
+  const plan = planAiRun(prompt, config, hint, /* @__PURE__ */ new Map(), true);
+  const timeoutSec = config.projectAiRunTimeoutSec || config.aiRunTimeoutSec || 0;
+  ctx.bus.push({ source: "system", kind: "aireq", text: `${plan.cmd} \u2039 ${label}` });
+  let text = "";
+  const handlers = {
+    onChunk: (chunk) => {
+      text += chunk;
+    },
+    onAttemptStart: (profile, index, total, attemptCmd) => {
+      ctx.bus.push({ source: "system", kind: "log", text: `\u2192 trying ${attemptCmd} profile "${profile}" (${index + 1}/${total})\u2026` });
+      if (index > 0) text = "";
+    },
+    onAttemptFail: (profile) => {
+      ctx.bus.push({ source: "system", kind: "log", text: `profile "${profile}" failed \u2014 trying next`, level: "warn" });
+    }
+  };
+  ctx.bus.startBusy(plan.cmd);
+  let result;
+  try {
+    result = await runAiFailover(plan, `ai-task-${randomUUID2()}`, cwd2, handlers, timeoutSec * 1e3);
+  } finally {
+    ctx.bus.endBusy(plan.cmd);
+  }
+  const occurredAt = (/* @__PURE__ */ new Date()).toISOString();
+  const events = [{ metric: UsageMetric.COMMANDS, amount: 1, occurredAt }];
+  if (result.exitCode === 0 && result.usage.tokens > 0) {
+    events.push({
+      metric: UsageMetric.AI_TOKENS,
+      amount: result.usage.tokens,
+      occurredAt,
+      inputTokens: result.usage.input,
+      outputTokens: result.usage.output,
+      cacheReadTokens: result.usage.cacheRead,
+      cacheCreationTokens: result.usage.cacheCreation,
+      provider: aiProviderOf(result.workedCmd ?? plan.cmd),
+      authMode: resolveClaudeAuthMode(config)
+    });
+  }
+  ctx.reportUsage(events, result.workedDir ? profileDisplayLabel(result.workedDir) : null);
+  const ok = result.exitCode === 0 && text.trim().length > 0;
+  ctx.bus.push({
+    source: "system",
+    kind: ok ? "aires" : "log",
+    text: ok ? `${plan.cmd} \u203A ${label} \u2713` : `${label}: AI run failed (exit ${result.exitCode}) \u2014 using the fallback`,
+    ...ok ? {} : { level: "warn" }
+  });
+  return ok ? text.trim() : null;
+}
+
+// src/core/ws-client/handlers/project.ts
 function handleProjectChannels(ctx, message, payload) {
   switch (message.channel) {
     case WsChannels.PHYSIC_SYNC: {
@@ -43274,14 +43584,18 @@ function handleProjectChannels(ctx, message, payload) {
       void scaffoldProject(
         payload,
         ctx.profileDir,
-        (p2) => ctx.send(WsChannels.PROJECT_PROGRESS, p2)
+        (p2) => ctx.send(WsChannels.PROJECT_PROGRESS, p2),
+        // AI init on the standard AI path + one org run slot (ADR-0362).
+        createAiTaskRunner(ctx)
       ).then((reply) => ctx.send(WsChannels.PROJECT_CREATE, reply, message.id));
       return true;
     case WsChannels.PROJECT_ADD:
       void addProject(
         payload,
         ctx.profileDir,
-        (p2) => ctx.send(WsChannels.PROJECT_PROGRESS, p2)
+        (p2) => ctx.send(WsChannels.PROJECT_PROGRESS, p2),
+        // An add-with-scaffold runs AI init too (ADR-0362).
+        createAiTaskRunner(ctx)
       ).then((reply) => ctx.send(WsChannels.PROJECT_ADD, reply, message.id));
       return true;
     default:
@@ -43364,7 +43678,7 @@ async function runKnowledgeCompose(req, ai2, physicRoot) {
 // src/core/faq-compose.ts
 import { spawn as spawn9, execFile as execFile10 } from "child_process";
 import { existsSync as existsSync15, mkdirSync as mkdirSync8, rmSync as rmSync8 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { join as join24 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 import { promisify as promisify10 } from "util";
@@ -43486,7 +43800,7 @@ async function runClaudeWithFailover2(prompt, cwd2, ai2) {
 var MAX_OUTPUT_CHARS = 8e3;
 async function runFaqCompose(req, ai2) {
   if (!req.repo.token) return { prUrl: "", error: "no write token" };
-  const workDir = join24(tmpdir4(), "4pm-faq-sync", randomUUID2());
+  const workDir = join24(tmpdir4(), "4pm-faq-sync", randomUUID3());
   const gitEnv = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
   const auth = gitAuthArgs("x-access-token", req.repo.token);
   try {
@@ -43501,7 +43815,7 @@ async function runFaqCompose(req, ai2) {
     await execFileAsync2("git", ["-C", workDir, "add", "-A"], { env: gitEnv });
     const staged = await execFileAsync2("git", ["-C", workDir, "diff", "--cached", "--name-only"], { env: gitEnv });
     if (!staged.stdout.trim()) {
-      return { prUrl: "", output, perTicket, tokens: usage.tokens || estimateTokens2(text), finishedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      return { prUrl: "", output, perTicket, tokens: usage.tokens || estimateTokens(text), finishedAt: (/* @__PURE__ */ new Date()).toISOString() };
     }
     await execFileAsync2("git", ["-C", workDir, "commit", "-m", "docs(faq): synthesize from support tickets (4PM)"], { env: gitEnv });
     await execFileAsync2("git", [...auth, "-C", workDir, "push", "-u", "origin", req.headBranch], { env: gitEnv });
@@ -45290,7 +45604,7 @@ var WsClient = class {
     }
     const { payload, nonce } = encryptPayload(this.sessionKey, data);
     const envelope = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       replyTo,
       channel,
       wsToken: this.wsToken,
@@ -45311,7 +45625,7 @@ var WsClient = class {
       }
       const { payload, nonce } = encryptPayload(this.sessionKey, data);
       const envelope = {
-        id: randomUUID3(),
+        id: randomUUID4(),
         replyTo: null,
         channel,
         wsToken: this.wsToken,
@@ -45703,7 +46017,7 @@ function releaseInstanceLock(profileDir2) {
 
 // src/core/session-bus.ts
 import { EventEmitter } from "events";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 var REPLAY_CAP = 500;
 var SessionBus = class {
   emitter = new EventEmitter();
@@ -45734,7 +46048,7 @@ var SessionBus = class {
   /** Producer → consumers: push one transcript entry. Returns its id (for `updateEntry`). */
   push(input) {
     const entry = {
-      id: randomUUID4(),
+      id: randomUUID5(),
       level: "info",
       ...input,
       ts: Date.now()
@@ -48127,7 +48441,7 @@ var src_default = Yoga;
 
 // ../../node_modules/.pnpm/ink@5.2.1_@types+react@18.3.31_react@18.3.1/node_modules/ink/build/reconciler.js
 var import_react_reconciler = __toESM(require_react_reconciler(), 1);
-var import_constants11 = __toESM(require_constants2(), 1);
+var import_constants12 = __toESM(require_constants2(), 1);
 import process3 from "process";
 
 // ../../node_modules/.pnpm/ansi-regex@6.2.2/node_modules/ansi-regex/index.js
@@ -49369,7 +49683,7 @@ var reconciler_default = (0, import_react_reconciler.default)({
   scheduleTimeout: setTimeout,
   cancelTimeout: clearTimeout,
   noTimeout: -1,
-  getCurrentEventPriority: () => import_constants11.DefaultEventPriority,
+  getCurrentEventPriority: () => import_constants12.DefaultEventPriority,
   beforeActiveInstanceBlur() {
   },
   afterActiveInstanceBlur() {