@4pm/cli 1.23.0 → 1.25.0

package/dist/index.js

@@ -5713,14 +5713,14 @@ var require_react_development = __commonJS({
               var thenableResult = result;
               var wasAwaited = false;
               var thenable = {
-                then: function(resolve11, reject) {
+                then: function(resolve12, reject) {
                   wasAwaited = true;
                   thenableResult.then(function(returnValue2) {
                     popActScope(prevActScopeDepth);
                     if (actScopeDepth === 0) {
-                      recursivelyFlushAsyncActWork(returnValue2, resolve11, reject);
+                      recursivelyFlushAsyncActWork(returnValue2, resolve12, reject);
                     } else {
-                      resolve11(returnValue2);
+                      resolve12(returnValue2);
                     }
                   }, function(error2) {
                     popActScope(prevActScopeDepth);
@@ -5750,20 +5750,20 @@ var require_react_development = __commonJS({
                   ReactCurrentActQueue.current = null;
                 }
                 var _thenable = {
-                  then: function(resolve11, reject) {
+                  then: function(resolve12, reject) {
                     if (ReactCurrentActQueue.current === null) {
                       ReactCurrentActQueue.current = [];
-                      recursivelyFlushAsyncActWork(returnValue, resolve11, reject);
+                      recursivelyFlushAsyncActWork(returnValue, resolve12, reject);
                     } else {
-                      resolve11(returnValue);
+                      resolve12(returnValue);
                     }
                   }
                 };
                 return _thenable;
               } else {
                 var _thenable2 = {
-                  then: function(resolve11, reject) {
-                    resolve11(returnValue);
+                  then: function(resolve12, reject) {
+                    resolve12(returnValue);
                   }
                 };
                 return _thenable2;
@@ -5779,7 +5779,7 @@ var require_react_development = __commonJS({
             actScopeDepth = prevActScopeDepth;
           }
         }
-        function recursivelyFlushAsyncActWork(returnValue, resolve11, reject) {
+        function recursivelyFlushAsyncActWork(returnValue, resolve12, reject) {
           {
             var queue = ReactCurrentActQueue.current;
             if (queue !== null) {
@@ -5788,16 +5788,16 @@ var require_react_development = __commonJS({
                 enqueueTask(function() {
                   if (queue.length === 0) {
                     ReactCurrentActQueue.current = null;
-                    resolve11(returnValue);
+                    resolve12(returnValue);
                   } else {
-                    recursivelyFlushAsyncActWork(returnValue, resolve11, reject);
+                    recursivelyFlushAsyncActWork(returnValue, resolve12, reject);
                   }
                 });
               } catch (error2) {
                 reject(error2);
               }
             } else {
-              resolve11(returnValue);
+              resolve12(returnValue);
             }
           }
         }
@@ -16203,9 +16203,9 @@ var require_react_reconciler_development = __commonJS({
           var node = row;
           while (node !== null) {
             if (node.tag === SuspenseComponent) {
-              var state = node.memoizedState;
-              if (state !== null) {
-                var dehydrated = state.dehydrated;
+              var state2 = node.memoizedState;
+              if (state2 !== null) {
+                var dehydrated = state2.dehydrated;
                 if (dehydrated === null || isSuspenseInstancePending(dehydrated) || isSuspenseInstanceFallback(dehydrated)) {
                   return node;
                 }
@@ -16549,8 +16549,8 @@ var require_react_reconciler_development = __commonJS({
             stores: null
           };
         }
-        function basicStateReducer(state, action) {
-          return typeof action === "function" ? action(state) : action;
+        function basicStateReducer(state2, action) {
+          return typeof action === "function" ? action(state2) : action;
         }
         function mountReducer(reducer, initialArg, init) {
           var hook = mountWorkInProgressHook();
@@ -18537,10 +18537,10 @@ var require_react_reconciler_development = __commonJS({
               }
             }
           }
-          var state = workInProgress2.memoizedState = instance.state !== null && instance.state !== void 0 ? instance.state : null;
+          var state2 = workInProgress2.memoizedState = instance.state !== null && instance.state !== void 0 ? instance.state : null;
           adoptClassInstance(workInProgress2, instance);
           {
-            if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
+            if (typeof ctor.getDerivedStateFromProps === "function" && state2 === null) {
               var componentName = getComponentNameFromType(ctor) || "Component";
               if (!didWarnAboutUninitializedState.has(componentName)) {
                 didWarnAboutUninitializedState.add(componentName);
@@ -19463,8 +19463,8 @@ var require_react_reconciler_development = __commonJS({
                 var _instance = workInProgress2.stateNode;
                 var ctor = workInProgress2.type;
                 var tempInstance = new ctor(workInProgress2.memoizedProps, _instance.context);
-                var state = tempInstance.state;
-                _instance.updater.enqueueSetState(_instance, state, null);
+                var state2 = tempInstance.state;
+                _instance.updater.enqueueSetState(_instance, state2, null);
                 break;
               }
               case true: {
@@ -20239,8 +20239,8 @@ var require_react_reconciler_development = __commonJS({
           var node = firstChild;
           while (node !== null) {
             if (node.tag === SuspenseComponent) {
-              var state = node.memoizedState;
-              if (state !== null) {
+              var state2 = node.memoizedState;
+              if (state2 !== null) {
                 scheduleSuspenseWorkOnFiber(node, renderLanes2, workInProgress2);
               }
             } else if (node.tag === SuspenseListComponent) {
@@ -20669,9 +20669,9 @@ var require_react_reconciler_development = __commonJS({
               }
               break;
             case SuspenseComponent: {
-              var state = workInProgress2.memoizedState;
-              if (state !== null) {
-                if (state.dehydrated !== null) {
+              var state2 = workInProgress2.memoizedState;
+              if (state2 !== null) {
+                if (state2.dehydrated !== null) {
                   pushSuspenseContext(workInProgress2, setDefaultShallowSuspenseContext(suspenseStackCursor.current));
                   workInProgress2.flags |= DidCapture;
                   return null;
@@ -32753,9 +32753,9 @@ 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 existsSync17, mkdirSync as mkdirSync8 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9 } from "fs";
 
 // vendor/@4pm/utils/helpers.ts
 function backoffJitterMs(attempt, baseMs = 500, maxMs = 1e4) {
@@ -37017,6 +37017,39 @@ var CLI_SLASH_COMMANDS = [
 ];
 var CLI_SLASH_COMMAND_NAMES = CLI_SLASH_COMMANDS.map((c) => c.name);
 
+// vendor/@4pm/dto/git-credential.ts
+var hostSchema = external_exports.string().trim().toLowerCase().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+(:\d{1,5})?$/, "invalid host");
+var gitCredentialRepoInputSchema = external_exports.object({
+  url: external_exports.string().trim().max(500),
+  subdir: external_exports.string().trim().max(120).optional().default(""),
+  primary: external_exports.boolean().optional().default(false)
+});
+var testGitCredentialRequestSchema = external_exports.object({
+  repos: external_exports.array(gitCredentialRepoInputSchema).max(50).optional()
+});
+var putGitCredentialRequestSchema = external_exports.object({
+  appId: external_exports.string().trim().regex(/^\d{1,20}$/, "App ID must be numeric"),
+  /** PEM; omit to keep the stored key (required on first save — enforced server-side). */
+  privateKey: external_exports.string().trim().max(16384).optional(),
+  enterprise: external_exports.boolean().default(false),
+  host: hostSchema.optional(),
+  apiBaseUrl: external_exports.string().trim().url().startsWith("https://").max(500).nullable().optional(),
+  caCert: external_exports.string().trim().max(32768).nullable().optional(),
+  installationOverrides: external_exports.array(external_exports.object({ url: external_exports.string().trim().max(500), installationId: external_exports.string().trim().regex(/^\d{1,20}$/).nullable() })).max(50).optional(),
+  /** The wizard's in-progress repos (else the project's spec / draft repos are used). */
+  repos: external_exports.array(gitCredentialRepoInputSchema).max(50).optional()
+}).superRefine((v2, ctx) => {
+  if (v2.enterprise && !v2.host) {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["host"], message: "host is required for GitHub Enterprise" });
+  }
+});
+function githubHostKind(host) {
+  const h = host.toLowerCase();
+  if (h === "github.com") return "github";
+  if (h.endsWith(".ghe.com")) return "ghe-cloud";
+  return "ghes";
+}
+
 // vendor/@4pm/validation/schemas.ts
 var passwordSchema = external_exports.string().min(8, "password: at least 8 characters").max(32, "password: at most 32 characters").regex(/[a-zA-Z]/, "password: needs at least 1 letter").regex(/[0-9]/, "password: needs at least 1 digit");
 var usernameSchema = external_exports.string().min(3).max(32).regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/, "username: invalid characters");
@@ -37531,116 +37564,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 : [];
@@ -37662,7 +37591,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;
@@ -37676,11 +37605,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}`);
@@ -37695,13 +37624,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 {
         }
@@ -37720,18 +37649,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}`);
@@ -37744,22 +37673,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.`);
@@ -37773,7 +37702,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) {
@@ -37787,7 +37716,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;
@@ -37798,9 +37727,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);
@@ -37813,9 +37742,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";
@@ -37823,7 +37752,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;
   }
@@ -37833,7 +37762,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.");
     }
@@ -37842,10 +37771,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);
@@ -37854,7 +37783,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;
@@ -37867,27 +37796,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);
@@ -37906,7 +37835,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) {
@@ -37932,7 +37861,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`);
@@ -37952,25 +37881,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;
     }
@@ -37978,21 +37929,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 });
@@ -38372,6 +38323,9 @@ var WsChannels = {
   // server → cli (reply): manage the rented worker's ssh deploy key (ADR-0173) — generate
   // (ed25519, on the worker) / get / delete. The private key never leaves the worker.
   GIT_SSH_KEY: "git.ssh-key",
+  // cli → server (reply): a short-lived GitHub-App installation token for the served project's repo,
+  // per job scope; also the cli's "scope revoked" report (ADR-0356). The App key stays on the server.
+  GIT_TOKEN: "git.token",
   PROJECT_CREATE: "project.create",
   PROJECT_ADD: "project.add",
   PROJECT_PROGRESS: "project.progress",
@@ -38396,6 +38350,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.
@@ -38411,6 +38368,8 @@ var WsChannels = {
   // command.dispatch({ ai:true }) → the profile-failover AI path (ADR-0100).
   // quota & usage (ADR-0020)
   QUOTA_CHECK: "quota.check",
+  // cli → server (reply): per-org concurrent AI-run slot — acquire / renew / release (ADR-0359)
+  RUN_SLOT: "run.slot",
   USAGE_REPORT: "usage.report",
   // cli → server: Claude subscription usage snapshot (5h / weekly — ADR-0072)
   MACHINE_USAGE: "machine.usage",
@@ -38509,6 +38468,12 @@ function decryptPayload(key, payloadBase64, nonceBase64) {
   return JSON.parse(plaintext.toString("utf8"));
 }
 
+// vendor/@4pm/ws/messages/run-slot.ts
+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";
 
@@ -38625,8 +38590,8 @@ function resolveInstallTimeoutMs(sec) {
   return sec && sec > 0 ? sec * 1e3 : TOOL_INSTALL_TIMEOUT_DEFAULT_MS;
 }
 function sleep(ms2) {
-  return new Promise((resolve11) => {
-    const t2 = setTimeout(resolve11, ms2);
+  return new Promise((resolve12) => {
+    const t2 = setTimeout(resolve12, ms2);
     t2.unref?.();
   });
 }
@@ -38653,15 +38618,15 @@ function classifyToolFailure(code, out) {
   }
   return { reason: "other", retryable: false };
 }
-function run3(cmd, args, onLine, timeoutMs = 18e4) {
-  return new Promise((resolve11) => {
+function run2(cmd, args, onLine, timeoutMs = 18e4) {
+  return new Promise((resolve12) => {
     let out = "";
     let buf = "";
     let child = null;
     const done = (code) => {
       clearTimeout(timer);
       if (onLine && buf.trim()) onLine(buf.trim());
-      resolve11({ code, out });
+      resolve12({ code, out });
     };
     const timer = setTimeout(() => {
       child?.kill();
@@ -38693,13 +38658,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 {
@@ -38775,7 +38740,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}` };
@@ -38808,7 +38773,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) {
@@ -39044,11 +39009,11 @@ function getWorkingProfile(profileDir2, cmd) {
   return readState(profileDir2)[cmd] ?? null;
 }
 function setWorkingProfile(profileDir2, cmd, dir2) {
-  const state = readState(profileDir2);
-  if (state[cmd] === dir2) return;
-  state[cmd] = dir2;
+  const state2 = readState(profileDir2);
+  if (state2[cmd] === dir2) return;
+  state2[cmd] = dir2;
   try {
-    writeFileSync4(statePath(profileDir2), JSON.stringify(state, null, 2), "utf8");
+    writeFileSync4(statePath(profileDir2), JSON.stringify(state2, null, 2), "utf8");
   } catch {
   }
 }
@@ -39057,11 +39022,11 @@ function getWorkingCredential(profileDir2) {
   return readState(profileDir2)[WORKING_CREDENTIAL_KEY] ?? null;
 }
 function setWorkingCredential(profileDir2, key) {
-  const state = readState(profileDir2);
-  if (state[WORKING_CREDENTIAL_KEY] === key) return;
-  state[WORKING_CREDENTIAL_KEY] = key;
+  const state2 = readState(profileDir2);
+  if (state2[WORKING_CREDENTIAL_KEY] === key) return;
+  state2[WORKING_CREDENTIAL_KEY] = key;
   try {
-    writeFileSync4(statePath(profileDir2), JSON.stringify(state, null, 2), "utf8");
+    writeFileSync4(statePath(profileDir2), JSON.stringify(state2, null, 2), "utf8");
   } catch {
   }
 }
@@ -39070,20 +39035,20 @@ function getPinnedCredential(profileDir2) {
   return readState(profileDir2)[PINNED_CREDENTIAL_KEY] ?? null;
 }
 function setPinnedCredential(profileDir2, key) {
-  const state = readState(profileDir2);
-  if (state[PINNED_CREDENTIAL_KEY] === key) return;
-  state[PINNED_CREDENTIAL_KEY] = key;
+  const state2 = readState(profileDir2);
+  if (state2[PINNED_CREDENTIAL_KEY] === key) return;
+  state2[PINNED_CREDENTIAL_KEY] = key;
   try {
-    writeFileSync4(statePath(profileDir2), JSON.stringify(state, null, 2), "utf8");
+    writeFileSync4(statePath(profileDir2), JSON.stringify(state2, null, 2), "utf8");
   } catch {
   }
 }
 function clearPinnedCredential(profileDir2) {
-  const state = readState(profileDir2);
-  if (!(PINNED_CREDENTIAL_KEY in state)) return;
-  delete state[PINNED_CREDENTIAL_KEY];
+  const state2 = readState(profileDir2);
+  if (!(PINNED_CREDENTIAL_KEY in state2)) return;
+  delete state2[PINNED_CREDENTIAL_KEY];
   try {
-    writeFileSync4(statePath(profileDir2), JSON.stringify(state, null, 2), "utf8");
+    writeFileSync4(statePath(profileDir2), JSON.stringify(state2, null, 2), "utf8");
   } catch {
   }
 }
@@ -39092,6 +39057,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"],
@@ -39438,16 +39433,16 @@ async function fetchUsage(token) {
   }
 }
 function runUsageCli(dir2, aiCli2) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let out = "";
     let child = null;
     const finish = () => {
       clearTimeout(timer);
-      resolve11(out);
+      resolve12(out);
     };
     const timer = setTimeout(() => {
       child?.kill();
-      resolve11(out);
+      resolve12(out);
     }, 3e4);
     timer.unref?.();
     try {
@@ -39768,12 +39763,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) {
@@ -39878,7 +39873,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));
 }
 
@@ -39934,9 +39929,10 @@ 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;
 var DOC_EXTENSIONS = [".md", ".mdx", ".txt"];
 function kbRoot(profileDir2) {
   return join14(profileDir2, "support-kb");
@@ -40048,6 +40044,7 @@ function buildPrompt(docs, question, askerRole) {
   ].join("\n");
 }
 function buildDraftPrompt(docs, context, task) {
+  if (task === "legal_draft") return buildLegalDraftPrompt(docs, context);
   const goal = task === "reply_draft" ? [
     "You are drafting a reply FROM the 4PM support team TO the customer in the support ticket below.",
     "Address the customer's latest message, using the whole conversation for context. Be accurate,",
@@ -40074,6 +40071,31 @@ function buildDraftPrompt(docs, context, task) {
     context
   ].join("\n");
 }
+function buildLegalDraftPrompt(docs, context) {
+  return [
+    "You are drafting the body of one of 4PM's legal documents (Terms of Service, Privacy Policy,",
+    "Add-on Terms, Rented Machine Addendum, \u2026) for the platform admin to review and publish.",
+    "Write or revise the WHOLE document body in the target locale given in the context. Keep the",
+    "existing heading structure and numbering unless the admin's instructions say otherwise.",
+    "When the target locale is not English and an English reference is given, follow its meaning closely.",
+    "Rules:",
+    "- Every {{placeholder}} (e.g. {{companyName}}) must be kept verbatim \u2014 never fill or rename it.",
+    "- Describe plans, prices, upgrades, downgrades, cancellations, renewals, refunds and add-ons ONLY",
+    "  as stated in the PLAN CATALOG and BILLING FACTS below or the documentation; never invent",
+    "  commitments, prices or legal guarantees. Where something is unknown write `[TODO: \u2026]`.",
+    "- Plain, precise legal English (or the target language); short numbered sections and bullet lists.",
+    "- This is a draft, not legal advice; do not add a disclaimer about that inside the document.",
+    "",
+    "Output ONLY the document body in markdown \u2014 no title line, no preamble, no explanation, no code",
+    "fences around the whole document.",
+    "",
+    "===== DOCUMENTATION =====",
+    docs,
+    "",
+    "===== CONTEXT =====",
+    context
+  ].join("\n");
+}
 function imageExt(mime) {
   switch (mime) {
     case "image/png":
@@ -40115,8 +40137,8 @@ function parseModeratedAnswer(text) {
   }
   return { body: text.trim() };
 }
-function runClaudeOnce(cmd, profile, prompt, extraEnv, imageDir, denyDirs = []) {
-  return new Promise((resolve11, reject) => {
+function runClaudeOnce(cmd, profile, prompt, extraEnv, imageDir, denyDirs = [], timeoutMs = ANSWER_TIMEOUT_MS) {
+  return new Promise((resolve12, reject) => {
     const isClaude = cmd.includes("claude");
     const args = [
       "-p",
@@ -40147,7 +40169,7 @@ function runClaudeOnce(cmd, profile, prompt, extraEnv, imageDir, denyDirs = [])
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
       reject(new Error("claude answer timed out"));
-    }, ANSWER_TIMEOUT_MS);
+    }, timeoutMs);
     timer.unref();
     child.stdout.on("data", (d) => out += parser.push(d.toString()));
     child.stderr.on("data", (d) => err += d.toString());
@@ -40160,17 +40182,25 @@ function runClaudeOnce(cmd, profile, prompt, extraEnv, imageDir, denyDirs = [])
       clearTimeout(timer);
       cleanup();
       out += parser.flush();
-      resolve11({ code: code ?? -1, out, err, usage: parser.usage() });
+      resolve12({ code: code ?? -1, out, err, usage: parser.usage() });
     });
     child.stdin.write(prompt);
     child.stdin.end();
   });
 }
-async function runClaudeWithFailover(prompt, ai2, imageDir) {
+async function runClaudeWithFailover(prompt, ai2, imageDir, timeoutMs = ANSWER_TIMEOUT_MS) {
   const attempts = ai2.profiles.length > 0 ? ai2.profiles : [null];
   let lastReason = "no attempt";
   for (let i = 0; i < attempts.length; i++) {
-    const { code, out, err, usage } = await runClaudeOnce(ai2.cmd, attempts[i], prompt, ai2.env, imageDir, ai2.profiles.map((p2) => p2.dir));
+    const { code, out, err, usage } = await runClaudeOnce(
+      ai2.cmd,
+      attempts[i],
+      prompt,
+      ai2.env,
+      imageDir,
+      ai2.profiles.map((p2) => p2.dir),
+      timeoutMs
+    );
     if (code === 0 && out.trim()) return { text: out.trim(), usage };
     const combined = err || out;
     lastReason = `exited ${code}: ${combined.slice(0, 500)}`;
@@ -40191,11 +40221,12 @@ async function runSupportAnswer(req, ai2, profileDir2) {
     const docs = collectDocs(dir2);
     if (!docs.trim()) return { body: "", error: "KB repo has no documentation" };
     const prompt = req.task ? buildDraftPrompt(docs, question, req.task) : buildPrompt(docs, question, req.askerRole);
-    const { text, usage } = await runClaudeWithFailover(prompt, ai2, imageDir);
+    const timeoutMs = req.task === "legal_draft" ? LEGAL_DRAFT_TIMEOUT_MS : ANSWER_TIMEOUT_MS;
+    const { text, usage } = await runClaudeWithFailover(prompt, ai2, imageDir, timeoutMs);
     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 } : {},
@@ -40244,9 +40275,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";
@@ -40357,7 +40388,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";
@@ -40421,17 +40452,17 @@ function tickScript(root) {
 }
 async function crontabList() {
   try {
-    const { stdout } = await run4("crontab", ["-l"], { timeout: 1e4 });
+    const { stdout } = await run3("crontab", ["-l"], { timeout: 1e4 });
     return stdout;
   } catch {
     return "";
   }
 }
 async function crontabSet(content) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const child = spawn5("crontab", ["-"], { stdio: ["pipe", "ignore", "ignore"] });
-    child.on("error", () => resolve11(false));
-    child.on("close", (code) => resolve11(code === 0));
+    child.on("error", () => resolve12(false));
+    child.on("close", (code) => resolve12(code === 0));
     child.stdin.end(content.endsWith("\n") ? content : content + "\n");
   });
 }
@@ -40600,14 +40631,14 @@ function detectContainerized() {
   }
 }
 function canReach(host, port) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const socket = connect({ host, port });
     let done = false;
     const finish = (ok) => {
       if (done) return;
       done = true;
       socket.destroy();
-      resolve11(ok);
+      resolve12(ok);
     };
     socket.setTimeout(PROBE_TIMEOUT_MS);
     socket.once("connect", () => finish(true));
@@ -40660,32 +40691,177 @@ async function probeNetwork() {
 }
 
 // src/core/git-auth.ts
-import { writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join18 } from "path";
-function tokenTarget(method) {
-  if (method === "gitlab-group-token") {
-    return { host: process.env.FOURPM_GIT_HOST || "gitlab.com", user: "oauth2" };
-  }
-  if (method === "github-app") {
-    return { host: process.env.FOURPM_GIT_HOST || "github.com", user: "x-access-token" };
+import { chmodSync as chmodSync3, existsSync as existsSync12, mkdirSync as mkdirSync6, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
+import { request as httpsRequest } from "https";
+import { delimiter, dirname as dirname4, join as join18, resolve as resolve3 } from "path";
+var JOB_ID_ENV = "FOURPM_JOB_ID";
+var PROFILE_DIR_ENV = "FOURPM_PROFILE_DIR";
+var GIT_HOST_ENV = "FOURPM_GIT_HOST";
+var GIT_HOST_KIND_ENV = "FOURPM_GIT_HOST_KIND";
+var DEFAULT_SCOPE = "link";
+var HELPER_ENV_ENTRIES = 3;
+var DEFAULT_SCOPE_IDLE_MS = 10 * 60 * 1e3;
+var state = { host: null, transport: null, baseEnv: null, scopes: /* @__PURE__ */ new Map(), defaultTimer: null };
+function cliInvocation() {
+  const quote = (s3) => `"${s3.replace(/(["\\$`])/g, "\\$1")}"`;
+  const script = process.argv[1];
+  return [process.execPath, ...process.execArgv, ...script ? [script] : []].map(quote).join(" ");
+}
+function helperCommand() {
+  return `!${cliInvocation()} git-credential`;
+}
+function findRealGh(pathValue, shimDir) {
+  for (const dir2 of pathValue.split(delimiter)) {
+    if (!dir2 || dir2 === shimDir) continue;
+    const candidate = join18(dir2, process.platform === "win32" ? "gh.exe" : "gh");
+    if (existsSync12(candidate)) return candidate;
   }
   return null;
 }
-function applyGitAuth(method) {
-  if (!method) return false;
-  const target = tokenTarget(method);
-  const token = process.env.FOURPM_GIT_TOKEN;
-  if (!target || !token) return false;
-  try {
-    const line = `https://${target.user}:${token}@${target.host}
+function shimScript(realGh, cli) {
+  return `#!/bin/sh
+# 4PM gh shim (ADR-0356) \u2014 injects a short-lived GitHub-App token for the served project.
+if [ -z "$GH_TOKEN$GH_ENTERPRISE_TOKEN$GITHUB_TOKEN" ]; then
+  T="$(${cli} git-token 2>/dev/null)"
+  if [ -n "$T" ]; then
+    case "$${GIT_HOST_KIND_ENV}" in
+      ghes) export GH_HOST="$${GIT_HOST_ENV}" GH_ENTERPRISE_TOKEN="$T"; unset GH_TOKEN ;;
+      ghe-cloud) export GH_HOST="$${GIT_HOST_ENV}" GH_TOKEN="$T"; unset GH_ENTERPRISE_TOKEN ;;
+      *) export GH_TOKEN="$T"; unset GH_ENTERPRISE_TOKEN ;;
+    esac
+  fi
+fi
+exec "${realGh}" "$@"
 `;
-    writeFileSync8(join18(homedir4(), ".git-credentials"), line, { encoding: "utf8", mode: 384 });
+}
+function clearEnv() {
+  if (!state.baseEnv) return;
+  const { count, path } = state.baseEnv;
+  for (let i = count; i < count + HELPER_ENV_ENTRIES; i++) {
+    delete process.env[`GIT_CONFIG_KEY_${i}`];
+    delete process.env[`GIT_CONFIG_VALUE_${i}`];
+  }
+  if (count > 0) process.env.GIT_CONFIG_COUNT = String(count);
+  else delete process.env.GIT_CONFIG_COUNT;
+  process.env.PATH = path;
+  delete process.env[GIT_HOST_ENV];
+  delete process.env[GIT_HOST_KIND_ENV];
+  state.baseEnv = null;
+}
+function configureGitAuth(method, host, profileDir2, transport) {
+  try {
+    const active = method === "github-app" && !!host;
+    if (!active || state.host && state.host !== host) {
+      if (state.host) void revokeAll();
+      clearEnv();
+      state.host = null;
+    }
+    if (!active) return false;
+    state.transport = transport;
+    if (state.host === host && state.baseEnv) return true;
+    const baseCount = Number(process.env.GIT_CONFIG_COUNT ?? "0") || 0;
+    state.baseEnv = { count: baseCount, path: process.env.PATH ?? "" };
+    const prefix = `credential.https://${host}`;
+    const entries2 = [
+      [`${prefix}.helper`, ""],
+      [`${prefix}.helper`, helperCommand()],
+      [`${prefix}.useHttpPath`, "true"]
+    ];
+    entries2.forEach(([key, value], i) => {
+      process.env[`GIT_CONFIG_KEY_${baseCount + i}`] = key;
+      process.env[`GIT_CONFIG_VALUE_${baseCount + i}`] = value;
+    });
+    process.env.GIT_CONFIG_COUNT = String(baseCount + HELPER_ENV_ENTRIES);
+    process.env[PROFILE_DIR_ENV] = resolve3(profileDir2);
+    const script = process.argv[1];
+    const devTsconfig = script ? resolve3(dirname4(script), "..", "tsconfig.json") : "";
+    if (process.execArgv.some((a) => a.includes("tsx")) && devTsconfig && existsSync12(devTsconfig) && !process.env.TSX_TSCONFIG_PATH) {
+      process.env.TSX_TSCONFIG_PATH = devTsconfig;
+    }
+    process.env[GIT_HOST_ENV] = host;
+    process.env[GIT_HOST_KIND_ENV] = githubHostKind(host);
+    if (process.platform !== "win32") {
+      const shimDir = join18(profileDir2, "bin");
+      const realGh = findRealGh(state.baseEnv.path, shimDir);
+      if (realGh) {
+        mkdirSync6(shimDir, { recursive: true });
+        const shim = join18(shimDir, "gh");
+        writeFileSync8(shim, shimScript(realGh, cliInvocation()), { encoding: "utf8", mode: 493 });
+        chmodSync3(shim, 493);
+        process.env.PATH = `${shimDir}${delimiter}${state.baseEnv.path}`;
+      } else {
+        rmSync6(join18(shimDir, "gh"), { force: true });
+      }
+    }
+    state.host = host;
+    logger.info("git.auth.github-app", { host });
     return true;
-  } catch {
+  } catch (err) {
+    logger.warn("git.auth.configure.failed", { error: String(err) });
     return false;
   }
 }
+function touchDefaultScope() {
+  if (state.defaultTimer) clearTimeout(state.defaultTimer);
+  state.defaultTimer = setTimeout(() => void endGitScope(DEFAULT_SCOPE), DEFAULT_SCOPE_IDLE_MS);
+  state.defaultTimer.unref?.();
+}
+async function issueGitToken(scope, host, path) {
+  try {
+    if (!state.host || !state.transport || host.toLowerCase() !== state.host) return null;
+    const s3 = scope || DEFAULT_SCOPE;
+    const reply = await state.transport({ op: "issue", scope: s3, repo: { host, path } });
+    if (!reply.token) return null;
+    const list = state.scopes.get(s3) ?? [];
+    if (!list.some((t2) => t2.token === reply.token)) list.push({ token: reply.token, apiBase: reply.apiBase ?? "" });
+    state.scopes.set(s3, list);
+    if (s3 === DEFAULT_SCOPE) touchDefaultScope();
+    return reply.token;
+  } catch (err) {
+    logger.warn("git.token.issue.failed", { error: String(err) });
+    return null;
+  }
+}
+function revokeAtGithub(t2) {
+  return new Promise((resolve12) => {
+    try {
+      const req = httpsRequest(
+        new URL(`${t2.apiBase.replace(/\/+$/, "")}/installation/token`),
+        {
+          method: "DELETE",
+          timeout: 1e4,
+          headers: { Authorization: `token ${t2.token}`, Accept: "application/vnd.github+json", "User-Agent": "4pm-cli" }
+        },
+        (res) => {
+          res.resume();
+          res.on("end", () => resolve12());
+        }
+      );
+      req.on("timeout", () => req.destroy());
+      req.on("error", () => resolve12());
+      req.end();
+    } catch {
+      resolve12();
+    }
+  });
+}
+async function endGitScope(scope) {
+  const tokens = state.scopes.get(scope);
+  if (!tokens) return;
+  state.scopes.delete(scope);
+  if (scope === DEFAULT_SCOPE && state.defaultTimer) {
+    clearTimeout(state.defaultTimer);
+    state.defaultTimer = null;
+  }
+  await Promise.all(tokens.filter((t2) => t2.apiBase).map((t2) => revokeAtGithub(t2)));
+  try {
+    await state.transport?.({ op: "revoked", scope });
+  } catch {
+  }
+}
+async function revokeAll() {
+  await Promise.all([...state.scopes.keys()].map((s3) => endGitScope(s3)));
+}
 
 // src/core/ws-client/transcript.ts
 function toDtoEntry(e) {
@@ -40716,13 +40892,18 @@ import { randomUUID as randomCommandId } from "crypto";
 // src/core/executor.ts
 import { spawn as spawn6 } from "child_process";
 var KILL_GRACE_MS = 5e3;
-async function runCommand(dispatch, emit, opts) {
+async function runCommand(dispatch, emitRaw, opts) {
   let seq = 0;
+  const emit = (output) => {
+    emitRaw(output);
+    if (output.done) void endGitScope(dispatch.commandId);
+  };
   let child;
   try {
     child = spawn6(dispatch.cmd, dispatch.args ?? [], {
       cwd: dispatch.path,
-      env: { ...process.env, ...dispatch.env },
+      // FOURPM_JOB_ID scopes the git helper / gh shim tokens to this run (ADR-0356).
+      env: { ...process.env, ...dispatch.env, [JOB_ID_ENV]: dispatch.commandId },
       shell: false
     });
   } catch (err) {
@@ -40759,9 +40940,20 @@ async function runCommand(dispatch, emit, 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) => {
@@ -40779,7 +40971,7 @@ async function runCommand(dispatch, emit, opts) {
   });
   child.stdout?.on("data", (data) => batcher.push(data.toString("utf8")));
   child.stderr?.on("data", (data) => batcher.push(data.toString("utf8")));
-  await new Promise((resolve11) => {
+  await new Promise((resolve12) => {
     child.on("close", (exitCode) => {
       clearTimers();
       batcher.flush();
@@ -40788,11 +40980,12 @@ async function runCommand(dispatch, emit, 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
       });
-      resolve11();
+      resolve12();
     });
     child.on("error", (err) => {
       clearTimers();
@@ -40804,7 +40997,7 @@ async function runCommand(dispatch, emit, opts) {
         done: true,
         exitCode: -1
       });
-      resolve11();
+      resolve12();
     });
   });
 }
@@ -40826,24 +41019,25 @@ function isOutOfCredits(text) {
     text
   );
 }
-function runAttempt(commandId, cmd, args, stdin, cwd2, env3, onChunk, timeoutMs) {
-  return new Promise((resolve11) => {
+function runAttempt(commandId, cmd, args, stdin, cwd2, env3, onChunk, timeoutMs, signal) {
+  return new Promise((resolve12) => {
     runCommand(
       { commandId, cmd, args, path: cwd2, env: env3 },
       (out) => {
         if (out.chunk) onChunk(out.chunk);
-        if (out.done) resolve11(out.exitCode ?? -1);
+        if (out.done) resolve12(out.exitCode ?? -1);
       },
-      { stdin, ...timeoutMs > 0 ? { timeoutMs } : {} }
-    ).catch(() => resolve11(-1));
+      { 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);
@@ -40856,17 +41050,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,
@@ -40885,6 +41080,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";
@@ -40918,7 +41124,7 @@ function formatTimestampInZone(date, timeZone) {
 }
 
 // src/ui/slash-commands.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { join as join19 } from "path";
 var CONFIG_KEYS = [
   "aiCli",
@@ -40981,7 +41187,7 @@ function runConfig(ctx) {
       ctx.print(t("slash.config.wroteDefault", { verb, path }));
       ctx.print(t("slash.config.addClaudeHint"));
     };
-    if (existsSync12(path)) {
+    if (existsSync13(path)) {
       ctx.confirm(
         t("slash.config.replaceConfirm", { path }),
         () => writeDefaults(t("slash.config.verbReplaced"))
@@ -41043,8 +41249,8 @@ function runHistory(ctx) {
   ctx.print(t("slash.history.header", { n: recent.length, total: all.length }));
   recent.forEach((e, i) => {
     const time = new Date(e.startedAt).toLocaleTimeString();
-    const state = e.status === "done" ? "\u2713" : e.status === "failed" ? `\u2717 exit ${e.exitCode}` : t("slash.history.running");
-    ctx.print(`  [${i + 1}] ${time}  ${commandLine(e.cmd, e.args)}  \xB7 ${state}`);
+    const state2 = e.status === "done" ? "\u2713" : e.status === "failed" ? `\u2717 exit ${e.exitCode}` : t("slash.history.running");
+    ctx.print(`  [${i + 1}] ${time}  ${commandLine(e.cmd, e.args)}  \xB7 ${state2}`);
   });
 }
 function runOutput(ctx) {
@@ -41055,8 +41261,8 @@ function runOutput(ctx) {
     return;
   }
   const entry = all.slice().reverse()[n - 1];
-  const state = entry.exitCode != null ? ` (exit ${entry.exitCode})` : "";
-  ctx.print(t("slash.output.header", { n, cmd: commandLine(entry.cmd, entry.args), status: entry.status, state }));
+  const state2 = entry.exitCode != null ? ` (exit ${entry.exitCode})` : "";
+  ctx.print(t("slash.output.header", { n, cmd: commandLine(entry.cmd, entry.args), status: entry.status, state: state2 }));
   const out = readCommandOutput(entry.commandId);
   if (out == null) {
     ctx.print(t("slash.output.none"), "warn");
@@ -41351,7 +41557,7 @@ function buildPrompt2(input) {
   ].join("\n");
 }
 function runOnce(cmd, profile, prompt, cwd2, extraEnv, denyDirs = []) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const args = [
       "-p",
       "--output-format",
@@ -41386,7 +41592,7 @@ function runOnce(cmd, profile, prompt, cwd2, extraEnv, denyDirs = []) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve11({ code: code ?? -1, out, err });
+      resolve12({ code: code ?? -1, out, err });
     });
     child.stdin.write(prompt);
     child.stdin.end();
@@ -41413,20 +41619,101 @@ 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, 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(() => {
+    ctx.request(WsChannels.RUN_SLOT, { op: "renew", lease }).catch(() => void 0);
+  }, RUN_SLOT_RENEW_MS);
+  timer.unref?.();
+  let released = false;
+  return {
+    release: () => {
+      if (released) return;
+      released = true;
+      clearInterval(timer);
+      ctx.request(WsChannels.RUN_SLOT, { op: "release", lease }).catch(() => void 0);
+    }
+  };
+}
+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, queued: ticket !== void 0 };
+    }
+    if (!reply || !("granted" in reply)) return { kind: "granted", handle: NO_SLOT, queued: ticket !== void 0 };
+    if (reply.granted) {
+      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 };
+    }
+    ticket = reply.ticket;
+    limit = reply.limit;
+    if (reply.position !== lastPosition) {
+      lastPosition = reply.position;
+      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, 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)) {
@@ -41513,6 +41800,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;
@@ -41520,7 +41816,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;
@@ -41677,11 +41973,52 @@ ${guardedPrompt}`;
     }
   };
   let result;
+  let neverStarted = false;
   try {
-    result = await runAiFailover(plan, commandId, cwd2, handlers, aiRunTimeoutMs);
+    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") {
+      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 === "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, run11.controller.signal);
+      } finally {
+        slot.handle.release();
+      }
+    }
   } 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) {
@@ -41696,14 +42033,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.
@@ -41739,13 +42078,13 @@ ${guardedPrompt}`;
     });
     ctx.bus.addTokens?.(result.usage.tokens);
   }
-  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) {
@@ -42222,11 +42561,11 @@ async function allAiProfilesExhausted(ctx, cfg) {
 
 // src/core/fs-browse.ts
 import { readdir as readdir3 } from "fs/promises";
-import { resolve as resolve3, sep as sep2 } from "path";
+import { resolve as resolve4, sep as sep2 } from "path";
 async function listDir(path, root) {
   if (!root) return { path: "", entries: [] };
-  const base = resolve3(root);
-  const requested = resolve3(base, path && path.trim() ? path : ".");
+  const base = resolve4(root);
+  const requested = resolve4(base, path && path.trim() ? path : ".");
   const target = requested === base || requested.startsWith(base + sep2) ? requested : base;
   try {
     const dirents = await readdir3(target, { withFileTypes: true });
@@ -42245,12 +42584,12 @@ async function listDir(path, root) {
 
 // src/core/fs-read.ts
 import { readFile as readFile6 } from "fs/promises";
-import { resolve as resolve4, sep as sep3 } from "path";
+import { resolve as resolve5, sep as sep3 } from "path";
 var MAX_BYTES = 256 * 1024;
 function resolveInRoot(root, relPath) {
   if (!root) return null;
-  const base = resolve4(root);
-  const target = resolve4(base, relPath || ".");
+  const base = resolve5(root);
+  const target = resolve5(base, relPath || ".");
   return target === base || target.startsWith(base + sep3) ? target : null;
 }
 async function readWorkerFile(root, path) {
@@ -42270,12 +42609,12 @@ async function readWorkerFile(root, path) {
 
 // src/core/fs-write.ts
 import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname4, resolve as resolve5, sep as sep4 } from "path";
+import { dirname as dirname5, resolve as resolve6, sep as sep4 } from "path";
 var MAX_BYTES2 = 2 * 1024 * 1024;
 function resolveInRoot2(root, relPath) {
   if (!root) return null;
-  const base = resolve5(root);
-  const target = resolve5(base, relPath || ".");
+  const base = resolve6(root);
+  const target = resolve6(base, relPath || ".");
   return target === base || target.startsWith(base + sep4) ? target : null;
 }
 async function writeWorkerFile(root, relPath, content) {
@@ -42288,7 +42627,7 @@ async function writeWorkerFile(root, relPath, content) {
     return { ok: false, path: target, bytes: 0, error: `content too large (max ${MAX_BYTES2} bytes)` };
   }
   try {
-    await mkdir4(dirname4(target), { recursive: true });
+    await mkdir4(dirname5(target), { recursive: true });
     await writeFile5(target, content, "utf8");
     return { ok: true, path: target, bytes };
   } catch (err) {
@@ -42298,11 +42637,11 @@ async function writeWorkerFile(root, relPath, content) {
 
 // src/core/fs-mutate.ts
 import { mkdir as mkdir5, writeFile as writeFile6, rename, rm as rm3, stat as stat2 } from "fs/promises";
-import { basename as basename3, dirname as dirname5, resolve as resolve6, sep as sep5 } from "path";
+import { basename as basename3, dirname as dirname6, resolve as resolve7, sep as sep5 } from "path";
 var MAX_BYTES3 = 2 * 1024 * 1024;
 function resolveInRoot3(root, rel) {
-  const base = resolve6(root);
-  const target = resolve6(base, rel || ".");
+  const base = resolve7(root);
+  const target = resolve7(base, rel || ".");
   return target === base || target.startsWith(base + sep5) ? target : null;
 }
 async function isDir(p2) {
@@ -42327,19 +42666,19 @@ async function mutateFs(root, req) {
     switch (req.op) {
       case "mkdir": {
         const target = resolveInRoot3(root, req.path ?? "");
-        if (!target || target === resolve6(root)) return escaped(req.path ?? "");
+        if (!target || target === resolve7(root)) return escaped(req.path ?? "");
         await mkdir5(target, { recursive: true });
         return { ok: true, path: target };
       }
       case "create": {
         const target = resolveInRoot3(root, req.path ?? "");
-        if (!target || target === resolve6(root)) return escaped(req.path ?? "");
+        if (!target || target === resolve7(root)) return escaped(req.path ?? "");
         if (await exists(target)) return { ok: false, path: target, error: "already exists" };
         const content = req.content ?? "";
         if (Buffer.byteLength(content, "utf8") > MAX_BYTES3) {
           return { ok: false, path: target, error: `content too large (max ${MAX_BYTES3} bytes)` };
         }
-        await mkdir5(dirname5(target), { recursive: true });
+        await mkdir5(dirname6(target), { recursive: true });
         await writeFile6(target, content, "utf8");
         return { ok: true, path: target };
       }
@@ -42347,18 +42686,18 @@ async function mutateFs(root, req) {
         const from = resolveInRoot3(root, req.from ?? "");
         let to2 = resolveInRoot3(root, req.to ?? "");
         if (!from || !to2) return escaped(req.from ?? req.to ?? "");
-        if (from === resolve6(root)) return { ok: false, path: from, error: "cannot move the project root" };
-        if (await isDir(to2)) to2 = resolve6(to2, basename3(from));
-        if (to2 !== resolve6(root) && !to2.startsWith(resolve6(root) + sep5)) return escaped(req.to ?? "");
+        if (from === resolve7(root)) return { ok: false, path: from, error: "cannot move the project root" };
+        if (await isDir(to2)) to2 = resolve7(to2, basename3(from));
+        if (to2 !== resolve7(root) && !to2.startsWith(resolve7(root) + sep5)) return escaped(req.to ?? "");
         if (await exists(to2)) return { ok: false, path: to2, error: "destination already exists" };
-        await mkdir5(dirname5(to2), { recursive: true });
+        await mkdir5(dirname6(to2), { recursive: true });
         await rename(from, to2);
         return { ok: true, path: to2 };
       }
       case "delete": {
         const target = resolveInRoot3(root, req.path ?? "");
         if (!target) return escaped(req.path ?? "");
-        if (target === resolve6(root)) return { ok: false, path: target, error: "cannot delete the project root" };
+        if (target === resolve7(root)) return { ok: false, path: target, error: "cannot delete the project root" };
         await rm3(target, { recursive: true, force: true });
         return { ok: true, path: target };
       }
@@ -42372,11 +42711,11 @@ async function mutateFs(root, req) {
 
 // src/core/fs-transfer.ts
 import { mkdir as mkdir6, readFile as readFile7, stat as stat3, writeFile as writeFile7 } from "fs/promises";
-import { basename as basename4, dirname as dirname6, extname, resolve as resolve7, sep as sep6 } from "path";
+import { basename as basename4, dirname as dirname7, extname, resolve as resolve8, sep as sep6 } from "path";
 function resolveInRoot4(root, relPath) {
   if (!root) return null;
-  const base = resolve7(root);
-  const target = resolve7(base, relPath || ".");
+  const base = resolve8(root);
+  const target = resolve8(base, relPath || ".");
   return target === base || target.startsWith(base + sep6) ? target : null;
 }
 var MIME_BY_EXT = {
@@ -42415,7 +42754,7 @@ async function uploadBinaryFile(root, relPath, contentBase64) {
     return { ok: false, path: target, bytes: 0, error: `file too large (max ${FS_TRANSFER_MAX_BYTES} bytes)` };
   }
   try {
-    await mkdir6(dirname6(target), { recursive: true });
+    await mkdir6(dirname7(target), { recursive: true });
     await writeFile7(target, buf);
     return { ok: true, path: target, bytes: buf.byteLength };
   } catch (err) {
@@ -42491,14 +42830,14 @@ 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 { basename as basename5, dirname as dirname7, resolve as resolve8, sep as sep7 } from "path";
-import { promisify as promisify6 } from "util";
-var run6 = promisify6(execFile6);
+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 promisify5 } from "util";
+var run5 = promisify5(execFile5);
 function resolveInRoot5(root, relPath) {
   if (!root) return null;
-  const base = resolve8(root);
-  const target = resolve8(base, relPath || ".");
+  const base = resolve9(root);
+  const target = resolve9(base, relPath || ".");
   return target === base || target.startsWith(base + sep7) ? target : null;
 }
 function looksBinary(buf) {
@@ -42513,7 +42852,7 @@ async function gitDiff(root, path) {
   if (!target) {
     return { path, oldContent: "", newContent: "", isBinary: false };
   }
-  const dir2 = dirname7(target);
+  const dir2 = dirname8(target);
   const base = basename5(target);
   let newBuf = null;
   try {
@@ -42522,7 +42861,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,
@@ -42552,12 +42891,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;
@@ -42570,7 +42909,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);
@@ -42583,11 +42922,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");
@@ -42602,14 +42941,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 }
@@ -42620,7 +42959,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);
@@ -42630,7 +42969,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 };
@@ -42651,21 +42990,21 @@ async function manageSshKey(op, profileDir2) {
 }
 
 // src/core/git-history.ts
-import { execFile as execFile9 } from "child_process";
-import { resolve as resolve9, sep as sep8 } from "path";
-import { promisify as promisify9 } from "util";
-var run9 = promisify9(execFile9);
+import { execFile as execFile8 } from "child_process";
+import { resolve as resolve10, sep as sep8 } from "path";
+import { promisify as promisify8 } from "util";
+var run8 = promisify8(execFile8);
 var FS = "";
 var RS = "";
 function resolveRepo(root, repo) {
   if (!root) return null;
-  const base = resolve9(root);
-  const requested = resolve9(base, repo && repo.trim() ? repo : ".");
+  const base = resolve10(root);
+  const requested = resolve10(base, repo && repo.trim() ? repo : ".");
   return requested === base || requested.startsWith(base + sep8) ? requested : base;
 }
 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
@@ -42677,7 +43016,7 @@ async function git(cwd2, args) {
 }
 async function gitRepos(root) {
   if (!root) return { repos: [] };
-  const base = resolve9(root);
+  const base = resolve10(root);
   const top = (await git(base, ["rev-parse", "--show-toplevel"])).trim();
   if (!top || !(top === base || top.startsWith(base + sep8))) return { repos: [] };
   const repos = [];
@@ -42689,7 +43028,7 @@ async function gitRepos(root) {
     const m2 = line.trim().match(/^[-+U ]?[0-9a-f]{7,40}\s+(\S+)/);
     const subPath = m2?.[1];
     if (!subPath) continue;
-    const abs = resolve9(base, subPath);
+    const abs = resolve10(base, subPath);
     if (!(abs === base || abs.startsWith(base + sep8))) continue;
     const remote = (await git(abs, ["remote", "get-url", "origin"])).trim();
     const branch = (await git(abs, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
@@ -42807,6 +43146,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;
@@ -42918,8 +43325,74 @@ function handleMiscChannels(ctx, message, payload) {
 }
 
 // src/core/ws-client/handlers/project.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, renameSync, rmSync as rmSync6 } from "fs";
+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: {
@@ -42931,11 +43404,11 @@ function handleProjectChannels(ctx, message, payload) {
         const oldRoot = ctx.physicFolderPath(oldName);
         if (oldRoot) void uninstallCron(oldRoot).catch(() => void 0);
       }
-      if (oldPath && oldName !== sync.newName && existsSync13(oldPath) && !existsSync13(newPath)) {
+      if (oldPath && oldName !== sync.newName && existsSync14(oldPath) && !existsSync14(newPath)) {
         renameSync(oldPath, newPath);
       } else {
-        if (oldPath && oldName !== sync.newName && existsSync13(oldPath)) rmSync6(oldPath, { recursive: true, force: true });
-        mkdirSync6(newPath, { recursive: true });
+        if (oldPath && oldName !== sync.newName && existsSync14(oldPath)) rmSync7(oldPath, { recursive: true, force: true });
+        mkdirSync7(newPath, { recursive: true });
       }
       ctx.physicRoot = ctx.physicFolderPath(sync.newName);
       ctx.bus.setProject(sync.newName);
@@ -42948,7 +43421,7 @@ function handleProjectChannels(ctx, message, payload) {
       if (del.name) {
         const delRoot = ctx.physicFolderPath(del.name);
         if (delRoot) void uninstallCron(delRoot).catch(() => void 0);
-        rmSync6(join23(ctx.profileDir, del.name), { recursive: true, force: true });
+        rmSync7(join23(ctx.profileDir, del.name), { recursive: true, force: true });
         ctx.bus.log(t("project.folderDeleted", { name: del.name }));
       }
       void manageSshKey("delete", ctx.profileDir).catch(() => void 0);
@@ -42977,14 +43450,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:
@@ -43012,7 +43489,7 @@ Extra focus from the author: ${req.prompt}` : "";
   ].join("\n");
 }
 function runOnce2(cmd, profile, prompt, cwd2, extraEnv, denyDirs = []) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const args = ["-p", ...profile?.model ? ["--model", profile.model] : [], ...denySettingsArgs(cmd, [...denyDirs, profile?.dir])];
     const env3 = {
       ...process.env,
@@ -43035,7 +43512,7 @@ function runOnce2(cmd, profile, prompt, cwd2, extraEnv, denyDirs = []) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve11({ code: code ?? -1, out, err });
+      resolve12({ code: code ?? -1, out, err });
     });
     child.stdin.write(prompt);
     child.stdin.end();
@@ -43066,8 +43543,8 @@ async function runKnowledgeCompose(req, ai2, physicRoot) {
 
 // src/core/faq-compose.ts
 import { spawn as spawn9, execFile as execFile10 } from "child_process";
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, rmSync as rmSync7 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, rmSync as rmSync8 } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
 import { join as join24 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 import { promisify as promisify10 } from "util";
@@ -43136,7 +43613,7 @@ function parsePerTicket(text) {
   return [];
 }
 function runClaudeOnce2(cmd, profile, prompt, cwd2, extraEnv, denyDirs = []) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const isClaude = cmd.includes("claude");
     const args = [
       "-p",
@@ -43169,7 +43646,7 @@ function runClaudeOnce2(cmd, profile, prompt, cwd2, extraEnv, denyDirs = []) {
     child.on("close", (code) => {
       clearTimeout(timer);
       out += parser.flush();
-      resolve11({ code: code ?? -1, out, err, usage: parser.usage() });
+      resolve12({ code: code ?? -1, out, err, usage: parser.usage() });
     });
     child.stdin.write(prompt);
     child.stdin.end();
@@ -43189,11 +43666,11 @@ 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 {
-    mkdirSync7(workDir, { recursive: true });
+    mkdirSync8(workDir, { recursive: true });
     await execFileAsync2("git", [...auth, "clone", "--depth", "1", "--branch", req.repo.branch, req.repo.url, workDir], { env: gitEnv });
     await execFileAsync2("git", ["-C", workDir, "config", "user.name", "4PM FAQ Bot"], { env: gitEnv });
     await execFileAsync2("git", ["-C", workDir, "config", "user.email", "faq-bot@4pm.app"], { env: gitEnv });
@@ -43204,7 +43681,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 });
@@ -43233,9 +43710,9 @@ async function runFaqCompose(req, ai2) {
     logger.warn("faq.compose.failed", { error: String(err) });
     return { prUrl: "", error: String(err) };
   } finally {
-    if (existsSync14(workDir)) {
+    if (existsSync15(workDir)) {
       try {
-        rmSync7(workDir, { recursive: true, force: true });
+        rmSync8(workDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -43559,7 +44036,7 @@ async function writeSecrets(root, req) {
 
 // src/core/agent-tools.ts
 import { readFile as readFile12, writeFile as writeFile10, mkdir as mkdir9 } from "fs/promises";
-import { dirname as dirname8, join as join27 } from "path";
+import { dirname as dirname9, join as join27 } from "path";
 var SHARED_REL = ".claude/settings.json";
 var LOCAL_REL = ".claude/settings.local.json";
 var SECRETS_DENY = "Read(./project.secrets.json)";
@@ -43590,7 +44067,7 @@ async function writeAgentTools(root, scope, permissions) {
     const next = normalizePermissions(permissions);
     if (scope === "shared" && !next.deny.includes(SECRETS_DENY)) next.deny = [...next.deny, SECRETS_DENY];
     obj.permissions = next;
-    await mkdir9(dirname8(path), { recursive: true });
+    await mkdir9(dirname9(path), { recursive: true });
     await writeFile10(path, JSON.stringify(obj, null, 2) + "\n", "utf8");
     return { ok: true };
   } catch (err) {
@@ -43601,7 +44078,7 @@ async function writeAgentTools(root, scope, permissions) {
 // src/core/packages.ts
 import { createHash as createHash4 } from "crypto";
 import { readFile as readFile13, writeFile as writeFile11, mkdir as mkdir10, readdir as readdir5, rm as rm6, stat as stat4 } from "fs/promises";
-import { dirname as dirname9, join as join28, relative } from "path";
+import { dirname as dirname10, join as join28, relative } from "path";
 var AGENTS_REL2 = ".claude/agents";
 var SKILLS_REL2 = ".claude/skills";
 var MANIFEST_REL = ".claude/.4pm-packages.json";
@@ -43682,7 +44159,7 @@ async function readManifest(root) {
 }
 async function writeManifest(root, manifest) {
   const path = join28(root, MANIFEST_REL);
-  await mkdir10(dirname9(path), { recursive: true });
+  await mkdir10(dirname10(path), { recursive: true });
   await writeFile11(path, JSON.stringify(manifest, null, 2), "utf8");
 }
 async function writeArtifactFiles(root, kind, slug, files) {
@@ -43708,7 +44185,7 @@ async function writeArtifactFiles(root, kind, slug, files) {
     for (const [rel, buf] of byPath) {
       if (rel.includes("..") || rel.startsWith("/")) continue;
       const dest = join28(base, rel);
-      await mkdir10(dirname9(dest), { recursive: true });
+      await mkdir10(dirname10(dest), { recursive: true });
       await writeFile11(dest, buf);
     }
   }
@@ -43789,7 +44266,7 @@ async function removePackage(root, slug) {
 
 // src/core/graph.ts
 import { readFile as readFile14, readdir as readdir6 } from "fs/promises";
-import { join as join29, relative as relative2, dirname as dirname10, resolve as resolve10, extname as extname2, basename as basename6 } from "path";
+import { join as join29, relative as relative2, dirname as dirname11, resolve as resolve11, extname as extname2, basename as basename6 } from "path";
 var MAX_FILES = 2e3;
 var MAX_NODES = 3e3;
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "out", "coverage", ".turbo"]);
@@ -43844,7 +44321,7 @@ async function buildDocs(root) {
     for (const m2 of text.matchAll(/\[[^\]]*\]\(([^)]+)\)/g)) {
       const href = (m2[1] ?? "").split("#")[0].trim();
       if (!href || !href.endsWith(".md") || href.startsWith("http")) continue;
-      const target = relative2(root, resolve10(dirname10(f2), href)).split("\\").join("/");
+      const target = relative2(root, resolve11(dirname11(f2), href)).split("\\").join("/");
       if (ids.has(target) && target !== rel) {
         const key = `${rel}->${target}`;
         if (!seen.has(key)) {
@@ -43929,7 +44406,7 @@ async function buildGraph(root, mode) {
 
 // src/core/rag.ts
 import { readFile as readFile15, writeFile as writeFile12, statfs as statfs2, mkdir as mkdir11 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { execFile as execFile11, spawn as spawn10 } from "child_process";
 import { totalmem as totalmem2, cpus as cpus2 } from "os";
 import { join as join30 } from "path";
@@ -44022,7 +44499,7 @@ async function ragStatus(root) {
   const modelPresent = modelName.length > 0;
   return {
     installed: fastembed && sqliteVec && modelPresent,
-    installing: existsSync15(join30(root, RAG_REL, ".installing")),
+    installing: existsSync16(join30(root, RAG_REL, ".installing")),
     python: { found: py.found, version: py.version },
     deps: { pip, fastembed, sqliteVec },
     model: { present: modelPresent, name: modelName },
@@ -44033,7 +44510,7 @@ async function ragStatus(root) {
   };
 }
 async function readIndexMeta(root) {
-  const indexing = existsSync15(join30(root, RAG_REL, ".indexing"));
+  const indexing = existsSync16(join30(root, RAG_REL, ".indexing"));
   try {
     const m2 = JSON.parse(await readFile15(join30(root, RAG_REL, ".index.json"), "utf8"));
     return {
@@ -44108,8 +44585,8 @@ async function ensureEngine(root) {
 async function ragReindex(root) {
   const py = await detectPython();
   if (!py.found) return { ok: false, started: false, error: "python3 not found" };
-  if (!existsSync15(join30(root, RAG_REL, ".installed"))) return { ok: false, started: false, error: "RAG is not installed" };
-  if (existsSync15(join30(root, RAG_REL, ".indexing"))) return { ok: true, started: true };
+  if (!existsSync16(join30(root, RAG_REL, ".installed"))) return { ok: false, started: false, error: "RAG is not installed" };
+  if (existsSync16(join30(root, RAG_REL, ".indexing"))) return { ok: true, started: true };
   await ensureEngine(root);
   const script = `
 set +e
@@ -44129,7 +44606,7 @@ rm -f "${RAG_REL}/.indexing"
 async function ragQuery(root, queryText, k2 = 8) {
   const py = await detectPython();
   if (!py.found) return { results: [], error: "python3 not found" };
-  if (!existsSync15(join30(root, RAG_REL, "index.db"))) return { results: [], error: "no index \u2014 reindex first" };
+  if (!existsSync16(join30(root, RAG_REL, "index.db"))) return { results: [], error: "no index \u2014 reindex first" };
   await ensureEngine(root);
   try {
     const { stdout } = await run10(
@@ -44149,7 +44626,7 @@ async function ragInstall(root, model) {
   }
   const py = await detectPython();
   if (!py.found) return { ok: false, started: false, error: "python3 not found on the worker" };
-  if (existsSync15(join30(root, RAG_REL, ".installing"))) return { ok: true, started: true };
+  if (existsSync16(join30(root, RAG_REL, ".installing"))) return { ok: true, started: true };
   try {
     await mkdir11(join30(root, RAG_REL), { recursive: true });
   } catch {
@@ -44178,7 +44655,7 @@ rm -f "${RAG_REL}/.installing"
 }
 
 // src/core/config-sync.ts
-import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync16 } from "fs";
 import { join as join31 } from "path";
 var SERVER_MANAGED_KEYS = [
   "physicPath",
@@ -44197,7 +44674,7 @@ var SERVER_MANAGED_KEYS = [
 ];
 function readConfigText(profileDir2) {
   const path = join31(profileDir2, "config.json");
-  if (existsSync16(path)) {
+  if (existsSync17(path)) {
     try {
       return readFileSync16(path, "utf8");
     } catch {
@@ -44683,14 +45160,14 @@ var WsClient = class {
    */
   awaitConnected(timeoutMs) {
     if (this.sessionKey && this.bus.status === "connected") return Promise.resolve(true);
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       const waiter = () => {
         clearTimeout(timer);
-        resolve11(true);
+        resolve12(true);
       };
       const timer = setTimeout(() => {
         this.connectWaiters = this.connectWaiters.filter((w2) => w2 !== waiter);
-        resolve11(false);
+        resolve12(false);
       }, timeoutMs);
       this.connectWaiters.push(waiter);
     });
@@ -44717,16 +45194,16 @@ var WsClient = class {
       this.forceReconnect = false;
       return Promise.resolve();
     }
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       const timer = setTimeout(() => {
         this.wakeReconnect = null;
-        resolve11();
+        resolve12();
       }, ms2);
       this.wakeReconnect = () => {
         clearTimeout(timer);
         this.wakeReconnect = null;
         this.forceReconnect = false;
-        resolve11();
+        resolve12();
       };
     });
   }
@@ -44780,7 +45257,7 @@ var WsClient = class {
    * One WS session: token → connect → handshake → handle messages until close.
    */
   connectOnce() {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       void (async () => {
         this.sessionEstablished = false;
         this.bus.setStatus("connecting");
@@ -44822,7 +45299,12 @@ var WsClient = class {
         if (token.aiMemory && !this.aiMemory) this.aiMemory = token.aiMemory.text;
         this.outboundReviewEnabled = token.outboundReview?.enabled === true;
         this.restrictToFolder = token.aiRestrictToFolder === true;
-        applyGitAuth(token.gitAuth ?? null);
+        configureGitAuth(
+          token.gitAuth ?? null,
+          token.gitAuthHost ?? null,
+          this.context.profileDir,
+          (req) => this.request(WsChannels.GIT_TOKEN, req)
+        );
         this.machineUsername = token.machineUsername ?? "";
         this.servingRepos = token.repos ?? [];
         void this.ensureServingReposCloned();
@@ -44876,7 +45358,7 @@ var WsClient = class {
           if (code === CLOSE_DRAINING) {
             this.bus.log(t("error.serverDraining"));
           }
-          resolve11();
+          resolve12();
         });
         socket.on("error", (err) => {
           this.clearHeartbeat();
@@ -44988,7 +45470,7 @@ var WsClient = class {
     }
     const { payload, nonce } = encryptPayload(this.sessionKey, data);
     const envelope = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       replyTo,
       channel,
       wsToken: this.wsToken,
@@ -45002,14 +45484,14 @@ var WsClient = class {
    * Used for quota.check before spawning an AI cli (ADR-0020).
    */
   request(channel, data) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       if (!this.socket || !this.sessionKey) {
         reject(new Error("Not connected to the server."));
         return;
       }
       const { payload, nonce } = encryptPayload(this.sessionKey, data);
       const envelope = {
-        id: randomUUID3(),
+        id: randomUUID4(),
         replyTo: null,
         channel,
         wsToken: this.wsToken,
@@ -45022,7 +45504,7 @@ var WsClient = class {
       }, 15e3);
       timer.unref?.();
       this.pending.set(envelope.id, {
-        resolve: (value) => resolve11(value),
+        resolve: (value) => resolve12(value),
         timer
       });
       this.socket.send(JSON.stringify(envelope));
@@ -45076,8 +45558,8 @@ var WsClient = class {
   /** Create the physic folder at an absolute path if missing (best-effort). */
   ensurePhysicFolderPath(folder) {
     try {
-      if (!existsSync17(folder)) {
-        mkdirSync8(folder, { recursive: true });
+      if (!existsSync18(folder)) {
+        mkdirSync9(folder, { recursive: true });
         this.bus.log(t("project.createdFolder", { folder }));
       }
     } catch (err) {
@@ -45106,7 +45588,7 @@ var WsClient = class {
       projects: [],
       version: CLI_VERSION,
       physicPath,
-      physicPathExists: physicPath ? existsSync17(physicPath) : void 0,
+      physicPathExists: physicPath ? existsSync18(physicPath) : void 0,
       // Real coarse state (ADR-0152): !paused and a recent tick (was hard-coded false).
       autonomousRunning: physicPath ? isAutonomousRunning(physicPath, this.context.profileDir) : false,
       // The machine-user AI-run limit (0 = unlimited) + profile count so a dispatch can resolve the
@@ -45365,7 +45847,7 @@ var WsClient = class {
 };
 
 // src/core/instance-lock.ts
-import { readFileSync as readFileSync17, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
+import { readFileSync as readFileSync17, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "fs";
 import { join as join33 } from "path";
 function lockPath(profileDir2) {
   return join33(profileDir2, "start.lock");
@@ -45394,14 +45876,14 @@ function acquireInstanceLock(profileDir2) {
 function releaseInstanceLock(profileDir2) {
   try {
     const pid = Number.parseInt(readFileSync17(lockPath(profileDir2), "utf8").trim(), 10);
-    if (pid === process.pid) rmSync8(lockPath(profileDir2), { force: true });
+    if (pid === process.pid) rmSync9(lockPath(profileDir2), { force: true });
   } catch {
   }
 }
 
 // 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();
@@ -45432,7 +45914,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()
@@ -45689,7 +46171,7 @@ var SessionBus = class {
 
 // src/core/control-server.ts
 import { createServer } from "net";
-import { chmodSync as chmodSync4, rmSync as rmSync9 } from "fs";
+import { chmodSync as chmodSync5, rmSync as rmSync10 } from "fs";
 import { join as join35 } from "path";
 
 // src/core/control-protocol.ts
@@ -45719,7 +46201,7 @@ function createFrameParser() {
 }
 
 // src/core/control-token.ts
-import { chmodSync as chmodSync3, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "fs";
+import { chmodSync as chmodSync4, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "fs";
 import { randomBytes as randomBytes3, timingSafeEqual } from "crypto";
 import { join as join34 } from "path";
 function controlTokenPath(profileDir2) {
@@ -45730,7 +46212,7 @@ function writeControlToken(profileDir2) {
   const path = controlTokenPath(profileDir2);
   writeFileSync10(path, token, { mode: 384 });
   try {
-    chmodSync3(path, 384);
+    chmodSync4(path, 384);
   } catch {
   }
   return token;
@@ -45754,7 +46236,7 @@ function tokenMatches(expected, given) {
 function startControlServer(bus, profileDir2, info) {
   const socketPath = join35(profileDir2, CONTROL_SOCKET_FILE);
   try {
-    rmSync9(socketPath, { force: true });
+    rmSync10(socketPath, { force: true });
   } catch {
   }
   const clients = /* @__PURE__ */ new Set();
@@ -45807,8 +46289,10 @@ function startControlServer(bus, profileDir2, info) {
         if (!authed) {
           if (frame.t === "auth" && tokenMatches(token, frame.token)) {
             authed = true;
-            clients.add(sock);
-            sendSnapshot(sock);
+            if (!frame.rpc) {
+              clients.add(sock);
+              sendSnapshot(sock);
+            }
           } else {
             send(sock, { t: "authError" });
             sock.destroy();
@@ -45818,6 +46302,9 @@ function startControlServer(bus, profileDir2, info) {
         if (frame.t === "submit") bus.submitLocal(frame.input);
         else if (frame.t === "reconnect") bus.requestReconnect();
         else if (frame.t === "autonomousRun") bus.submitAutonomous();
+        else if (frame.t === "gitToken") {
+          void issueGitToken(frame.scope, frame.host, frame.path).then((tok) => send(sock, { t: "gitToken", token: tok }));
+        }
       }
     });
     const drop = () => {
@@ -45830,7 +46317,7 @@ function startControlServer(bus, profileDir2, info) {
   });
   server.listen(socketPath, () => {
     try {
-      chmodSync4(socketPath, 384);
+      chmodSync5(socketPath, 384);
     } catch {
     }
   });
@@ -45840,8 +46327,8 @@ function startControlServer(bus, profileDir2, info) {
     clients.clear();
     server.close();
     try {
-      rmSync9(socketPath, { force: true });
-      rmSync9(controlTokenPath(profileDir2), { force: true });
+      rmSync10(socketPath, { force: true });
+      rmSync10(controlTokenPath(profileDir2), { force: true });
     } catch {
     }
   };
@@ -47820,7 +48307,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
@@ -49062,7 +49549,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() {
@@ -50923,24 +51410,24 @@ var App = class extends import_react9.PureComponent {
       })
     }));
   };
-  findNextFocusable = (state) => {
-    const activeIndex = state.focusables.findIndex((focusable) => {
-      return focusable.id === state.activeFocusId;
+  findNextFocusable = (state2) => {
+    const activeIndex = state2.focusables.findIndex((focusable) => {
+      return focusable.id === state2.activeFocusId;
     });
-    for (let index = activeIndex + 1; index < state.focusables.length; index++) {
-      const focusable = state.focusables[index];
+    for (let index = activeIndex + 1; index < state2.focusables.length; index++) {
+      const focusable = state2.focusables[index];
       if (focusable?.isActive) {
         return focusable.id;
       }
     }
     return void 0;
   };
-  findPreviousFocusable = (state) => {
-    const activeIndex = state.focusables.findIndex((focusable) => {
-      return focusable.id === state.activeFocusId;
+  findPreviousFocusable = (state2) => {
+    const activeIndex = state2.focusables.findIndex((focusable) => {
+      return focusable.id === state2.activeFocusId;
     });
     for (let index = activeIndex - 1; index >= 0; index--) {
-      const focusable = state.focusables[index];
+      const focusable = state2.focusables[index];
       if (focusable?.isActive) {
         return focusable.id;
       }
@@ -51136,8 +51623,8 @@ var Ink = class {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve11, reject) => {
-      this.resolveExitPromise = resolve11;
+    this.exitPromise ||= new Promise((resolve12, reject) => {
+      this.resolveExitPromise = resolve12;
       this.rejectExitPromise = reject;
     });
     return this.exitPromise;
@@ -51504,7 +51991,7 @@ var import_react21 = __toESM(require_react(), 1);
 var import_react26 = __toESM(require_react(), 1);
 
 // src/core/input-history.ts
-import { existsSync as existsSync19, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
 import { join as join36 } from "path";
 var MAX_HISTORY = 200;
 function historyPath(profileDir2) {
@@ -51512,7 +51999,7 @@ function historyPath(profileDir2) {
 }
 function loadInputHistory(profileDir2) {
   const path = historyPath(profileDir2);
-  if (!existsSync19(path)) return [];
+  if (!existsSync20(path)) return [];
   try {
     const data = JSON.parse(readFileSync20(path, "utf8"));
     return Array.isArray(data) ? data.filter((x) => typeof x === "string") : [];
@@ -52190,7 +52677,7 @@ async function runStart(profileDir2, profileName) {
           logger.error("ws.run.crash", { message: e.message, stack: e.stack });
           if (client.isStopped) return;
           bus.log(t("start.recovered", { message: e.message }), "error");
-          await new Promise((resolve11) => setTimeout(resolve11, 1e3));
+          await new Promise((resolve12) => setTimeout(resolve12, 1e3));
         }
       }
     };
@@ -52225,6 +52712,7 @@ async function runStart(profileDir2, profileName) {
     }
   } finally {
     stopIdleClear?.();
+    await revokeAll().catch(() => void 0);
     stopControl?.();
     release();
   }
@@ -52236,7 +52724,7 @@ import { join as join38 } from "path";
 // src/core/control-client.ts
 import { connect as connect2 } from "net";
 function connectControl(socketPath, bus, token) {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const socket = connect2(socketPath);
     socket.setEncoding("utf8");
     let ready = false;
@@ -52289,7 +52777,7 @@ function connectControl(socketPath, bus, token) {
           bus.setTokens(frame.tokens);
           for (const entry of frame.transcript) bus.pushEntry(entry);
           ready = true;
-          resolve11({ info: frame.info, close });
+          resolve12({ info: frame.info, close });
           break;
         case "transcript":
           bus.pushEntry(frame.entry);
@@ -52377,7 +52865,7 @@ async function runAutoRun(profileDir2, profileName) {
   initI18n(readProfileConfig(profileDir2).locale);
   const socketPath = join39(profileDir2, CONTROL_SOCKET_FILE);
   const token = readControlToken(profileDir2);
-  const code = await new Promise((resolve11) => {
+  const code = await new Promise((resolve12) => {
     let settled = false;
     const done = (c) => {
       if (settled) return;
@@ -52387,7 +52875,7 @@ async function runAutoRun(profileDir2, profileName) {
         socket.destroy();
       } catch {
       }
-      resolve11(c);
+      resolve12(c);
     };
     const socket = connect3(socketPath);
     socket.setEncoding("utf8");
@@ -52430,21 +52918,91 @@ async function runAutoRun(profileDir2, profileName) {
   process.exitCode = code;
 }
 
+// src/commands/git-credential.ts
+import { connect as connect4 } from "net";
+import { join as join40 } from "path";
+var REQUEST_TIMEOUT_MS = 2e4;
+function requestToken(host, path) {
+  const profileDir2 = process.env[PROFILE_DIR_ENV];
+  if (!profileDir2) return Promise.resolve(null);
+  const token = readControlToken(profileDir2);
+  return new Promise((resolve12) => {
+    let done = false;
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve12(value);
+    };
+    const socket = connect4(join40(profileDir2, CONTROL_SOCKET_FILE));
+    socket.setEncoding("utf8");
+    const timer = setTimeout(() => finish(null), REQUEST_TIMEOUT_MS);
+    socket.on("connect", () => {
+      try {
+        socket.write(encodeFrame({ t: "auth", token: token ?? "", rpc: true }));
+        socket.write(encodeFrame({ t: "gitToken", scope: process.env[JOB_ID_ENV] ?? "", host, path }));
+      } catch {
+        finish(null);
+      }
+    });
+    const parse = createFrameParser();
+    socket.on("data", (chunk) => {
+      for (const frame of parse(chunk)) {
+        if (frame.t === "gitToken") finish(frame.token);
+        else if (frame.t === "authError") finish(null);
+      }
+    });
+    socket.on("error", () => finish(null));
+    socket.on("close", () => finish(null));
+  });
+}
+async function readCredentialInput() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const out = {};
+  for (const line of Buffer.concat(chunks).toString("utf8").split("\n")) {
+    const i = line.indexOf("=");
+    if (i > 0) out[line.slice(0, i)] = line.slice(i + 1).trim();
+  }
+  return out;
+}
+async function runGitCredential(action) {
+  if (action !== "get") {
+    await readCredentialInput().catch(() => void 0);
+    return;
+  }
+  const input = await readCredentialInput();
+  const host = (input.host ?? "").toLowerCase();
+  if (input.protocol !== "https" || !host || host !== (process.env[GIT_HOST_ENV] ?? "").toLowerCase()) return;
+  const token = await requestToken(host, input.path ?? "");
+  if (token) process.stdout.write(`username=x-access-token
+password=${token}
+`);
+}
+async function runGitToken() {
+  const host = process.env[GIT_HOST_ENV] ?? "";
+  if (!host) return;
+  const token = await requestToken(host, "");
+  if (token) process.stdout.write(`${token}
+`);
+}
+
 // src/commands/ai-login.ts
 import { spawn as spawn12 } from "child_process";
-import { mkdirSync as mkdirSync9 } from "fs";
+import { mkdirSync as mkdirSync10 } from "fs";
 import { basename as basename8 } from "path";
 function runProviderLogin(cmd, envVar, dir2) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const child = spawn12(cmd, [], {
       stdio: "inherit",
       env: { ...process.env, [envVar]: dir2 }
     });
     child.on("error", (err) => {
       console.error(t("aiLogin.launchFailed", { cmd, message: err.message }));
-      resolve11(1);
+      resolve12(1);
     });
-    child.on("exit", (code) => resolve11(code ?? 0));
+    child.on("exit", (code) => resolve12(code ?? 0));
   });
 }
 async function runAiLogin(profileDir2, profileName, aiFilter) {
@@ -52469,7 +53027,7 @@ async function runAiLogin(profileDir2, profileName, aiFilter) {
       continue;
     }
     const dir2 = resolveHomePath(cred.profile);
-    mkdirSync9(dir2, { recursive: true });
+    mkdirSync10(dir2, { recursive: true });
     console.log(t("aiLogin.loggingIn", { provider: cred.provider, profile: cred.profile, envVar, dir: dir2 }));
     console.log(t("aiLogin.completeSignIn"));
     const code = await runProviderLogin(cred.provider, envVar, dir2);
@@ -52481,7 +53039,7 @@ async function runAiLogin(profileDir2, profileName, aiFilter) {
 }
 
 // src/commands/unlink.ts
-import { rmSync as rmSync10 } from "fs";
+import { rmSync as rmSync11 } from "fs";
 async function runUnlink(profileDir2, profileName) {
   initI18n(readProfileConfig(profileDir2).locale);
   const cred = readCredential(profileDir2, profileName);
@@ -52495,7 +53053,7 @@ async function runUnlink(profileDir2, profileName) {
   } catch (err) {
     console.log(t("unlink.revokeFailed", { message: err.message }));
   }
-  rmSync10(profileDir2, { recursive: true, force: true });
+  rmSync11(profileDir2, { recursive: true, force: true });
   clearDefaultProfileIf(profileName);
   console.log(t("unlink.deleted"));
 }
@@ -52584,10 +53142,10 @@ function Picker({
   ] });
 }
 function selectFromList(items, title) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let chosen = null;
     const app = render_default(/* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Picker, { items, title, onDone: (v2) => chosen = v2 }));
-    void app.waitUntilExit().then(() => resolve11(chosen));
+    void app.waitUntilExit().then(() => resolve12(chosen));
   });
 }
 
@@ -52654,6 +53212,14 @@ async function main() {
       await runAttach(profileDir(name), name);
       break;
     }
+    case "git-credential": {
+      await runGitCredential(rest[0]);
+      break;
+    }
+    case "git-token": {
+      await runGitToken();
+      break;
+    }
     case "auto-run": {
       const name = await pickLinkedProfile(explicitProfile, "auto-run");
       if (!name) {