@4pm/cli 1.23.0 → 1.24.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;
@@ -32755,7 +32755,7 @@ async function checkAndUpdate(serverUrl, autoUpdate) {
 init_wrapper();
 import { randomUUID as randomUUID3 } 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");
@@ -38372,6 +38405,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",
@@ -38411,6 +38447,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 +38547,11 @@ 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;
+
 // src/core/update-scheduler.ts
 import { spawn as spawn2 } from "child_process";
 
@@ -38625,8 +38668,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?.();
   });
 }
@@ -38654,14 +38697,14 @@ function classifyToolFailure(code, out) {
   return { reason: "other", retryable: false };
 }
 function run3(cmd, args, onLine, timeoutMs = 18e4) {
-  return new Promise((resolve11) => {
+  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();
@@ -39044,11 +39087,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 +39100,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 +39113,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 {
   }
 }
@@ -39438,16 +39481,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 {
@@ -39937,6 +39980,7 @@ var NO_USAGE = { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0
 var execFileAsync = promisify3(execFile3);
 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 +40092,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 +40119,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 +40185,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 +40217,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 +40230,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,7 +40269,8 @@ 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" };
@@ -40428,10 +40507,10 @@ async function crontabList() {
   }
 }
 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 +40679,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 +40739,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 +40940,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) {
@@ -40779,7 +41008,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();
@@ -40792,7 +41021,7 @@ async function runCommand(dispatch, emit, opts) {
         // server settles the command as failed and the web surfaces the note instead of spinning.
         exitCode: timedOut ? 124 : exitCode ?? -1
       });
-      resolve11();
+      resolve12();
     });
     child.on("error", (err) => {
       clearTimers();
@@ -40804,7 +41033,7 @@ async function runCommand(dispatch, emit, opts) {
         done: true,
         exitCode: -1
       });
-      resolve11();
+      resolve12();
     });
   });
 }
@@ -40827,15 +41056,15 @@ function isOutOfCredits(text) {
   );
 }
 function runAttempt(commandId, cmd, args, stdin, cwd2, env3, onChunk, timeoutMs) {
-  return new Promise((resolve11) => {
+  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));
+    ).catch(() => resolve12(-1));
   });
 }
 async function runAiFailover(plan, commandId, cwd2, handlers, timeoutMs = 0) {
@@ -40918,7 +41147,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 +41210,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 +41272,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 +41284,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 +41580,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 +41615,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();
@@ -41424,6 +41653,54 @@ async function setCommitAuthor(cwd2, machineUsername) {
   }
 }
 
+// src/core/ws-client/run-slot.ts
+var NO_SLOT = { release: () => void 0 };
+function sleep2(ms2) {
+  return new Promise((resolve12) => setTimeout(resolve12, ms2));
+}
+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) {
+  const startedAt = Date.now();
+  let ticket;
+  let lastPosition = -1;
+  let limit = 0;
+  for (; ; ) {
+    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 };
+    }
+    if (!reply || !("granted" in reply)) return { kind: "granted", handle: NO_SLOT };
+    if (reply.granted) {
+      return { kind: "granted", handle: reply.lease ? holdLease(ctx, reply.lease) : NO_SLOT };
+    }
+    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);
+  }
+}
+
 // 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:";
 function handleCommandChannels(ctx, message, payload) {
@@ -41677,8 +41954,28 @@ ${guardedPrompt}`;
     }
   };
   let result;
+  let queueTimedOut = 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 });
+    });
+    if (slot.kind === "timeout") {
+      queueTimedOut = 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 {
+      try {
+        result = await runAiFailover(plan, commandId, cwd2, handlers, aiRunTimeoutMs);
+      } finally {
+        slot.handle.release();
+      }
+    }
   } finally {
     ctx.bus.endBusy(plan.cmd);
   }
@@ -41739,7 +42036,7 @@ ${guardedPrompt}`;
     });
     ctx.bus.addTokens?.(result.usage.tokens);
   }
-  ctx.reportUsage(events, profileLabel);
+  if (!queueTimedOut) ctx.reportUsage(events, profileLabel);
   void ctx.pollUsage();
   ctx.bus.push({
     source: origin,
@@ -42222,11 +42519,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 +42542,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 +42567,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 +42585,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 +42595,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 +42624,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 +42644,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 +42669,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 +42712,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) {
@@ -42492,13 +42789,13 @@ 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 { basename as basename5, dirname as dirname8, resolve as resolve9, sep as sep7 } from "path";
 import { promisify as promisify6 } from "util";
 var run6 = promisify6(execFile6);
 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 +42810,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 {
@@ -42652,15 +42949,15 @@ 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 { resolve as resolve10, sep as sep8 } from "path";
 import { promisify as promisify9 } from "util";
 var run9 = promisify9(execFile9);
 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) {
@@ -42677,7 +42974,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 +42986,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();
@@ -42918,7 +43215,7 @@ 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";
 function handleProjectChannels(ctx, message, payload) {
   switch (message.channel) {
@@ -42931,11 +43228,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 +43245,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);
@@ -43012,7 +43309,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 +43332,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,7 +43363,7 @@ async function runKnowledgeCompose(req, ai2, physicRoot) {
 
 // src/core/faq-compose.ts
 import { spawn as spawn9, execFile as execFile10 } from "child_process";
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, rmSync as rmSync8 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 import { join as join24 } from "path";
 import { tmpdir as tmpdir4 } from "os";
@@ -43136,7 +43433,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 +43466,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();
@@ -43193,7 +43490,7 @@ async function runFaqCompose(req, ai2) {
   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 });
@@ -43233,9 +43530,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 +43856,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 +43887,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 +43898,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 +43979,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 +44005,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 +44086,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 +44141,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 +44226,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 +44319,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 +44330,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 +44405,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 +44426,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 +44446,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 +44475,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 +44494,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 +44980,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 +45014,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 +45077,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 +45119,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 +45178,7 @@ var WsClient = class {
           if (code === CLOSE_DRAINING) {
             this.bus.log(t("error.serverDraining"));
           }
-          resolve11();
+          resolve12();
         });
         socket.on("error", (err) => {
           this.clearHeartbeat();
@@ -45002,7 +45304,7 @@ 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;
@@ -45022,7 +45324,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 +45378,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 +45408,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 +45667,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,7 +45696,7 @@ 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 {
   }
 }
@@ -45689,7 +45991,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 +46021,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 +46032,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 +46056,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 +46109,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 +46122,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 +46137,7 @@ function startControlServer(bus, profileDir2, info) {
   });
   server.listen(socketPath, () => {
     try {
-      chmodSync4(socketPath, 384);
+      chmodSync5(socketPath, 384);
     } catch {
     }
   });
@@ -45840,8 +46147,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 {
     }
   };
@@ -50923,24 +51230,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 +51443,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 +51811,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 +51819,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 +52497,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 +52532,7 @@ async function runStart(profileDir2, profileName) {
     }
   } finally {
     stopIdleClear?.();
+    await revokeAll().catch(() => void 0);
     stopControl?.();
     release();
   }
@@ -52236,7 +52544,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 +52597,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 +52685,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 +52695,7 @@ async function runAutoRun(profileDir2, profileName) {
         socket.destroy();
       } catch {
       }
-      resolve11(c);
+      resolve12(c);
     };
     const socket = connect3(socketPath);
     socket.setEncoding("utf8");
@@ -52430,21 +52738,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 +52847,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 +52859,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 +52873,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 +52962,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 +53032,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) {