token-goat 2.9.30 → 2.9.31

package/dist/{token-goat-chunk-OJBNYTJP.mjs → token-goat-chunk-7MAOA6X4.mjs}

@@ -2,33 +2,34 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   compareSemver
-} from "./token-goat-chunk-B2RZZCSS.mjs";
+} from "./token-goat-chunk-CXHOFN7R.mjs";
 import {
+  emitErr,
   jsonc,
   stripBom
-} from "./token-goat-chunk-XKI4SEMX.mjs";
+} from "./token-goat-chunk-QQTWJY2O.mjs";
 import {
   HOOKS_CONFIG_FILE,
   copilotHooksOwnersPath,
   readCopilotHooksOwners
 } from "./token-goat-chunk-G5PJ7AGM.mjs";
+import {
+  claudeConfigDir
+} from "./token-goat-chunk-BPGCUMR7.mjs";
 import {
   toolMatcherFor
-} from "./token-goat-chunk-P4QMM4WK.mjs";
+} from "./token-goat-chunk-C75NA7PL.mjs";
 import {
   COPILOT_CLI_TOOL_NAME_MAP,
   copilotCliUserRoot,
   foldToolName
-} from "./token-goat-chunk-VPBBTSJR.mjs";
-import {
-  claudeConfigDir
-} from "./token-goat-chunk-BPGCUMR7.mjs";
+} from "./token-goat-chunk-76FGDLRO.mjs";
 import {
   loadConfig,
   nativeHooksEnabled,
   parse,
   stringify
-} from "./token-goat-chunk-7IN2MKDS.mjs";
+} from "./token-goat-chunk-7EZTZOMC.mjs";
 import {
   registerReset
 } from "./token-goat-chunk-YZAAZU2S.mjs";
@@ -65,7 +66,11 @@ import {
   writeConfigText,
   writeIfDifferent,
   writeJsonSettings
-} from "./token-goat-chunk-GOLEOXZP.mjs";
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  echoedValue,
+  fencedCommand
+} from "./token-goat-chunk-GGGG7RWB.mjs";
 import {
   powershellHookLine,
   quotePosixShellWord,
@@ -78,7 +83,7 @@ import {
 } from "./token-goat-chunk-FNFBKLRD.mjs";
 import {
   dataDir
-} from "./token-goat-chunk-VES7EL7O.mjs";
+} from "./token-goat-chunk-CO3UYX6G.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -173,10 +178,18 @@ var SHIM_SPAWN_LADDER = `    const res = entryPath
       ? spawnSync(process.execPath, [entryPath, 'hook', eventName], {
           input,
           encoding: 'utf8',
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: 'SIGKILL',
           maxBuffer: SHIM_MAX_BUFFER_BYTES,
         })`;
+var SHIM_FALLBACK_TIMEOUT_MS = { claudecode: 2e4, codex: 45e3, copilot: 45e3, grok: 3e3, kimi: 2e4, pi: 2e4, relay: 1e4 };
+var SHIM_SESSION_START_TIMEOUT_MS = 1e4;
+var SESSION_START_TEST_BUDGET_ENV = "TG_TEST_SESSION_START_BUDGET_MS";
+var SESSION_START_TEST_BUDGET_MIN_MS = 1e3;
+var SESSION_START_TEST_BUDGET_MAX_MS = 6e5;
+function shimFallbackTimeoutConst(harness) {
+  return `const SHIM_FALLBACK_TIMEOUT_MS = ${SHIM_FALLBACK_TIMEOUT_MS[harness]}`;
+}
 var SHIM_MAX_BUFFER_CONST = `const SHIM_MAX_BUFFER_BYTES = 32 * 1024 * 1024`;
 var SHIM_ASYNC_DETACH = `const ASYNC_DETACH_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit'])
 const ASYNC_DETACH_SKIP_EXT_RE = /\\.(md|mdx|markdown|rst)$/i
@@ -194,6 +207,14 @@ function bashResultByteLength(resp) {
   }
   return 0
 }
+// A token-goat read|section|symbol result is never detached, however short: see isAsyncDetachEligible in src/hook_adapters.ts.
+const TG_LEDGER_PREFIX_RE = /^(?:(?:cd\\s+(?:"[^"]*"|'[^']*'|\\S+)|export[ \\t]+[A-Za-z_]\\w*=(?:"[^"]*"|'[^']*'|[^\\s"'])*(?:[ \\t]+[A-Za-z_]\\w*=(?:"[^"]*"|'[^']*'|[^\\s"'])*)*)[ \\t]*(?:&&|;|\\r?\\n)\\s*)+/
+const TG_LEDGER_READ_RE = /^(?:[A-Za-z_][A-Za-z0-9_]*=\\S+\\s+)*(?:env\\s+(?:(?:(?:-u|--unset)\\s+\\S+|-(?![A-Za-z]*C|-c)\\S*|[A-Za-z_][A-Za-z0-9_]*=\\S+)\\s+)*)?(?:token-goat|tg|node(?:\\.exe)?\\s+["']?(?:\\S*[\\\\/])?token-goat(?:\\.mjs)?["']?)\\s+(?:read|section|symbol)\\b/i
+function isLedgerReadCommand(cmd) {
+  if (typeof cmd !== 'string') return false
+  const body = cmd.trim().replace(/^\\(\\s*/, '')
+  return TG_LEDGER_READ_RE.test((body.replace(TG_LEDGER_PREFIX_RE, '') || body).trim())
+}
 function isAsyncDetachEligible(eventName, input) {
   if (eventName === 'subagent_stop') return true
   if (eventName !== 'post_tool_use') return false
@@ -210,7 +231,7 @@ function isAsyncDetachEligible(eventName, input) {
             : ''
       return !ASYNC_DETACH_SKIP_EXT_RE.test(filePath)
     }
-    if (toolName === 'Bash') return bashResultByteLength(payload['tool_response']) < ASYNC_DETACH_BASH_MAX_BYTES
+    if (toolName === 'Bash') return !isLedgerReadCommand((payload['tool_input'] || {})['command']) && bashResultByteLength(payload['tool_response']) < ASYNC_DETACH_BASH_MAX_BYTES
     return false
   } catch {
     return false
@@ -254,6 +275,7 @@ ${SHIM_TRY_SERVER}
 ${SHIM_TRY_IN_PROCESS}
 
 ${SHIM_MAX_BUFFER_CONST}
+${shimFallbackTimeoutConst("claudecode")}
 
 ${SHIM_ASYNC_DETACH}
 
@@ -304,9 +326,9 @@ async function main() {
   // spawning a second node process altogether; fall back to the entry path directly via
   // process.execPath, then finally to the old PATH-based shell:true invocation (an
   // older cached hook config with no argv[3], or a config wired directly to
-  // \`token-goat hook <event>\` rather than through this shim). A 3000ms
-  // timeout/killSignal on both spawnSync fallbacks means token-goat degrades to its own
-  // fail-open '{}' rather than being force-killed by Claude Code's own hook timeout.
+  // \`token-goat hook <event>\` rather than through this shim). A
+  // SHIM_FALLBACK_TIMEOUT_MS timeout/killSignal on both spawnSync fallbacks means token-goat degrades to its own
+  // fail-open '{}' rather than being force-killed by Claude Code's own hook timeout (30 s on UserPromptSubmit).
   const entryPath = process.argv[3]
   let stdout = await tryInProcess(entryPath, eventName, input, asyncDetachAtMs)
   if (stdout === undefined) {
@@ -322,7 +344,7 @@ ${SHIM_SPAWN_LADDER}
           input,
           encoding: 'utf8',
           shell: true,
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: 'SIGKILL',
           maxBuffer: SHIM_MAX_BUFFER_BYTES,
         })
@@ -351,15 +373,16 @@ function buildGuidanceBody(fallbackToolClause, opts = {}) {
     "",
     `This gate decides *whether* to reach for a read tool at all. ${fallbackToolClause} only pick the *fallback* once token-goat has been ruled out for this read \u2014 they never authorize skipping the gate.`,
     "",
-    "Fallback clauses may name your harness's own native read, search, and edit tools, or its shell helpers. Shell binaries and editor programs are commands invoked through the shell tool, never tool identifiers, and must never appear in an agent's tools frontmatter or an allowed-tools list. This paragraph deliberately names no specific tool or binary: instruction-file loaders harvest such names into a tool allowlist and then warn that every one of them is unknown.",
+    "Shell binaries and editor programs are commands run through the shell tool, never tool identifiers: keep them out of an agent's tools and allowed-tools lists, where loaders harvest the names and warn that each is unknown.",
     "",
     "Exemptions (gate passes, read directly): the file is under ~200 lines and you need all of it; it was never indexed (new, untracked, or generated this turn); it is a genuinely opaque binary (not an image); the target has no symbol handle (e.g. a literal mid-function).",
     "",
     "Failure shapes to catch yourself in, and the command that replaces each:",
-    '- not knowing which command answers a question you can already state in words \u2192 `answer "<question>"`, which resolves the subject in the index, runs the right command, prints `via: <command>`, and refuses rather than guess',
+    '- not knowing which command answers a question you can already state in words \u2192 `answer "<question>"`, which runs the right command and refuses rather than guess',
     '- a shell text search with context flags to find a function body \u2192 `read "file::symbol"`',
     '- paging one function with view/view_range \u2192 `read "file::symbol"`',
-    "- a read refused by a `[tg]` deny, retried with a shifted range or a different read tool \u2192 the command the deny names",
+    '- issuing sequential or overlapping line-range reads across a file (paging) \u2192 `read "file::symbol"` / `outline file` / `skeleton file` / rg <pattern> <file>',
+    "- a read refused by a `[tg]` deny, retried with a shifted range, different lines, or another read tool \u2192 never retry reading the file at different lines; run the command the deny names or use bash-output / token-goat read",
     '- reading a symbol plus chasing its callers and containing doc section as separate reads \u2192 `brief "file::symbol"`',
     '- reading one heading of a large doc \u2192 `section "file::Heading"`',
     "- searching for a symbol's callers \u2192 `refs file::symbol --callers`",
@@ -370,11 +393,10 @@ function buildGuidanceBody(fallbackToolClause, opts = {}) {
     "- pulling one value or subtree out of a JSON/YAML/XML file (manifest, lockfile, spec, config) \u2192 `json-query file 'a.b.c'` / `yaml-query file 'a.b.c'` / `xml-query file 'a.b.c'`",
     "- opening an image to check its dimensions, format, or size \u2192 `image-meta file`",
     "- opening a screenshot, diagram, or scan to read the text in it \u2192 `image-text file`",
-    "- opening a PDF or Office document \u2192 inspect its format first, then read a narrow slice: PDF `pdf-meta`/`pdf-outline` then `pdf-locate` to find the pages and `pdf-extract` only those; Word `docx-outline` then `docx-tables`/`docx-text`; PowerPoint `pptx-outline` then `pptx-slide`/`pptx-notes`; Excel `xlsx-sheets` then `xlsx-columns`/`xlsx-head`/`xlsx-range`/`xlsx-query`",
     "- running tests immediately on edited code without fast static validation \u2192 run language validator first (e.g. `ruff check --select F821 <file>`, `node --check`, `tsc --noEmit`) to catch missing imports and syntax errors before test execution",
     "- passing concatenated or unquoted paths to shell tools \u2192 verify whitespace and argument separation in multi-path commands (e.g. `git add path1 path2`, never `git add path1path2`)",
     "",
-    'Commands: `search "<query>"`, `answer "<question>"`, `symbol NAME`, `read "file::symbol"`, `brief "file::symbol"`, `section "file::Heading"`, `semantic "description"`, `outline file`/`skeleton file`, `map --compact`, `refs file::symbol --callers`, `changed --symbol`, `config-get file KEY`, `json-query file \'a.b.c\'`/`yaml-query`/`xml-query`, `json-outline file`/`yaml-outline`/`xml-outline`, `bash-output`/`web-output`/`mcp-output`, ' + (gdrive ? "`gdrive-sections <file-id>`, " : "") + "`image-meta file`/`image-text file`, `pdf-meta`/`pdf-outline`/`pdf-locate`/`pdf-extract`, `docx-outline`/`docx-tables`/`docx-text`, `pptx-outline`/`pptx-slide`/`pptx-notes`/`pptx-text`, `xlsx-sheets`/`xlsx-columns`/`xlsx-head`/`xlsx-range`/`xlsx-query`.",
+    "Commands: `symbol NAME`, `changed --symbol`, `config-get file KEY`, `json-outline`/`yaml-outline`/`xml-outline`, " + (gdrive ? "`gdrive-sections <file-id>`, " : "") + "and `token-goat --help` for the rest.",
     "",
     "Sub-agent briefs must carry this gate verbatim: a sub-agent inherits none of this context and its reads spend the same token budget.",
     "",
@@ -388,17 +410,6 @@ function buildGuidanceBlock(h) {
   return [h.beginMarker, buildGuidanceBody(h.fallbackToolClause, h.gdrive === void 0 ? {} : { gdrive: h.gdrive }), h.endMarker].join("\n");
 }
 
-// src/install.ts
-init_define_import_meta_env();
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-
-// src/canonical_skill.ts
-init_define_import_meta_env();
-import { gunzipSync } from "node:zlib";
-var CANONICAL_SKILL_GZIP_BASE64 = "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";
-var CANONICAL_SKILL_MD = gunzipSync(Buffer.from(CANONICAL_SKILL_GZIP_BASE64, "base64")).toString("utf8");
-
 // src/native_hook.ts
 init_define_import_meta_env();
 import { spawnSync } from "node:child_process";
@@ -522,6 +533,9 @@ function nativeSelftest(bin) {
   return result;
 }
 var _decisions = /* @__PURE__ */ new Map();
+var COPY_FAILED = "its copy could not be put in place in the data directory (a scanner or another process held the file)";
+var COPY_STALE = "the data-directory copy is missing or differs from the packaged binary";
+var TRANSIENT_WHY = /could not be put in place|no answer within/;
 registerReset(() => {
   _selftests.clear();
   _decisions.clear();
@@ -533,13 +547,33 @@ function nativeHookBinary(entryPath = process.argv[1], opts = {}) {
   const cached = _decisions.get(key);
   if (cached !== void 0) return cached ?? void 0;
   const packaged = packagedNativeBinary(entryPath);
-  let bin = packaged;
-  if (packaged !== void 0 && process.platform === "win32") {
-    const copy = nativeCopyPath(entryPath);
-    const current = sync ? syncNativeCopy(packaged, copy) : nativeCopyCurrent(packaged, copy);
-    bin = current ? copy : void 0;
+  let bin;
+  let why;
+  if (packaged !== void 0) {
+    for (let attempt = 1; attempt <= 2 && bin === void 0; attempt++) {
+      if (attempt === 2) {
+        if (why === void 0 || !TRANSIENT_WHY.test(why)) break;
+        _selftests.clear();
+      }
+      why = void 0;
+      let candidate = packaged;
+      if (process.platform === "win32") {
+        const copy = nativeCopyPath(entryPath);
+        const current = sync ? syncNativeCopy(packaged, copy) : nativeCopyCurrent(packaged, copy);
+        if (current) candidate = copy;
+        else {
+          candidate = void 0;
+          why = sync ? COPY_FAILED : COPY_STALE;
+        }
+      }
+      if (candidate !== void 0) {
+        const test = nativeSelftest(candidate);
+        if (test.ok) bin = candidate;
+        else why = `its self-test failed: ${test.reason ?? "no reason given"}`;
+      }
+    }
   }
-  if (bin !== void 0 && !nativeSelftest(bin).ok) bin = void 0;
+  if (bin === void 0 && sync && why !== void 0 && why !== COPY_STALE) emitErr(`token-goat: wrote the Node form of the hooks, not the native hook client, because ${why}. Run \`token-goat doctor --repair\` (or install again) to retry.`);
   _decisions.set(key, bin ?? null);
   if (sync) _decisions.set(`false\0${entryPath}`, bin ?? null);
   return bin;
@@ -630,6 +664,17 @@ function parseNativeInvocation(argv) {
   return { bin, harness: h >= 0 ? flags[h + 1] : void 0, wrapped: argv.slice(split + 1) };
 }
 
+// src/install.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// src/canonical_skill.ts
+init_define_import_meta_env();
+import { gunzipSync } from "node:zlib";
+var CANONICAL_SKILL_GZIP_BASE64 = "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";
+var CANONICAL_SKILL_MD = gunzipSync(Buffer.from(CANONICAL_SKILL_GZIP_BASE64, "base64")).toString("utf8");
+
 // src/install.ts
 var HOOK_EVENT_MAP = [
   ["PreToolUse", "pre_tool_use"],
@@ -639,6 +684,7 @@ var HOOK_EVENT_MAP = [
   ["PreCompact", "pre_compact"],
   ["PostCompact", "post_compact"],
   ["UserPromptSubmit", "user_prompt_submit"],
+  ["Stop", "stop"],
   ["SubagentStop", "subagent_stop"],
   ["SessionStart", "session_start"]
 ];
@@ -748,7 +794,7 @@ var SettingsParseError = class extends Error {
 };
 function readSettings(p, opts = {}) {
   const refuse = (problem, detail) => new SettingsParseError(
-    (opts.command === "uninstall" ? `settings file '${p}' is unreadable: it ${problem}. Uninstall left it untouched, along with the hook shim it may still name and the file's backups; fix the file and run uninstall again.` : `settings file '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+    (opts.command === "uninstall" ? `settings file ${echoedValue(p)} is unreadable: it ${problem}. Uninstall left it untouched, along with the hook shim it may still name and the file's backups; fix the file and run uninstall again.` : `settings file ${echoedValue(p)} ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
   );
   let raw;
   try {
@@ -919,6 +965,13 @@ function isInstalled(scope = "user") {
   const gaps = hookEventGaps(scope);
   return gaps !== null && gaps.missing.length === 0 && gaps.outdated.length === 0 && gaps.broken.length === 0;
 }
+function hasFiringHook(scope) {
+  const gaps = hookEventGaps(scope);
+  return gaps !== null && gaps.missing.length + gaps.broken.length < HOOK_EVENT_MAP.length;
+}
+function claudeHooksInstalledAnyScope() {
+  return hasFiringHook("user") || hasFiringHook("project");
+}
 var LIVE_HOOK_MARKER_PATTERNS = [SHIM_COMMAND_MARKER, COMMAND_MARKER].map(anchoredMarkerPattern);
 var SHIM_FILE_WORD = /(?:^|[\\/])token-goat-shim\.c?js$/;
 function isLiveTokenGoatHookCommand(command, args) {
@@ -946,7 +999,7 @@ function hookEventGaps(scope = "user") {
   const broken = [];
   for (const [eventKey, eventArg] of HOOK_EVENT_MAP) {
     const expected = expectedHookEntryFor(scriptPath, eventArg, { sync: false });
-    if (groupHasTokenGoat(hooks[eventKey], (c, a) => hookEntryMatches(c, a, expected))) continue;
+    if (groupHasTokenGoat(hooks[eventKey], (c, a) => hookEntryMatches(c, a, expected) && isLiveTokenGoatHookCommand(c, a))) continue;
     if (groupHasTokenGoat(hooks[eventKey], isLiveTokenGoatHookCommand)) outdated.push(eventKey);
     else if (groupHasTokenGoat(hooks[eventKey], isBrokenNativeHookCommand)) broken.push(eventKey);
     else missing.push(eventKey);
@@ -1149,6 +1202,7 @@ ${SHIM_TRY_SERVER}
 ${SHIM_TRY_IN_PROCESS}
 
 ${SHIM_MAX_BUFFER_CONST}
+${shimFallbackTimeoutConst("codex")}
 
 async function main() {
   const eventName = process.argv[2] || ''
@@ -1172,7 +1226,7 @@ async function main() {
   // CLI bridge's inner hook call (a bare 'token-goat' on PATH failing to resolve
   // crashes this call, and Codex -- like Copilot -- fails closed on a non-zero-exit
   // hook). Falls back further to the old PATH-based shell:true invocation when argv[3]
-  // is absent (an older cached hook config). A 3000ms timeout/killSignal on both
+  // is absent (an older cached hook config). A SHIM_FALLBACK_TIMEOUT_MS timeout/killSignal on both
   // spawnSync fallbacks bounds them well under Codex's own hook timeout budget, so
   // token-goat degrades to its own fail-open '{}' rather than being force-killed by
   // Codex first.
@@ -1184,7 +1238,7 @@ ${SHIM_SPAWN_LADDER}
           input,
           encoding: 'utf8',
           shell: true,
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: 'SIGKILL',
           maxBuffer: SHIM_MAX_BUFFER_BYTES,
         })
@@ -1251,35 +1305,41 @@ function groupHasTokenGoat2(groups, matcher, predicate) {
 
 // src/bridges/codex_install.ts
 var CODEX_COMMAND_MARKER = "token-goat-shim";
-var CODEX_MATCHERS = ["view_image|Bash|exec|shell|bash", "apply_patch", "web_search"];
+var CODEX_MATCHERS = ["view_image|Bash|exec|shell|bash", "apply_patch", "web_search", "spawn_agent|multi_agent_v1wait_agent"];
 var CODEX_HOOK_EVENTS = ["PreToolUse", "PostToolUse"];
 var CODEX_EVENT_ARG = {
   PreToolUse: "pre_tool_use",
   PostToolUse: "post_tool_use"
 };
-var CODEX_GLOBAL_HOOK_EVENTS = ["PreCompact", "UserPromptSubmit", "SubagentStop"];
+var CODEX_GLOBAL_HOOK_EVENTS = ["PreCompact", "UserPromptSubmit", "Stop", "SubagentStop"];
 var CODEX_GLOBAL_EVENT_ARG = {
   PreCompact: "pre_compact",
   UserPromptSubmit: "user_prompt_submit",
+  Stop: "stop",
   SubagentStop: "subagent_stop"
 };
 var CodexConfigParseError = class extends Error {
 };
+function codexHomeDir() {
+  const override = process.env["CODEX_HOME"];
+  if (override !== void 0 && override !== "") return path3.resolve(override);
+  return path3.join(os.homedir(), ".codex");
+}
 function codexConfigPath() {
-  return path3.join(os.homedir(), ".codex", "config.toml");
+  return path3.join(codexHomeDir(), "config.toml");
 }
 function codexAgentsPath() {
-  return path3.join(os.homedir(), ".codex", "AGENTS.md");
+  return path3.join(codexHomeDir(), "AGENTS.md");
 }
 function codexHookScriptPath() {
-  return path3.join(os.homedir(), ".codex", "hooks", SHIM_FILE);
+  return path3.join(codexHomeDir(), "hooks", SHIM_FILE);
 }
 function codexLegacyHookScriptPath() {
-  return path3.join(os.homedir(), ".codex", "hooks", LEGACY_SHIM_FILE);
+  return path3.join(codexHomeDir(), "hooks", LEGACY_SHIM_FILE);
 }
 function readCodexConfig(p, opts = {}) {
   const refuse = (problem, detail) => new CodexConfigParseError(
-    (opts.command === "uninstall" ? `Codex config file '${p}' is unreadable: it ${problem}. Uninstall left it untouched, along with the hook shim it may still name, the AGENTS.md block and the file's backups; fix the file and run uninstall again.` : `Codex config file '${p}' ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
+    (opts.command === "uninstall" ? `Codex config file ${echoedValue(p)} is unreadable: it ${problem}. Uninstall left it untouched, along with the hook shim it may still name, the AGENTS.md block and the file's backups; fix the file and run uninstall again.` : `Codex config file ${echoedValue(p)} ${problem}. Fix or back up the file before running install.`) + (detail === void 0 ? "" : ` (${detail})`)
   );
   let raw;
   try {
@@ -1710,6 +1770,449 @@ function stripAgentsBlock(p) {
 // src/bridges/copilot_cli.ts
 init_define_import_meta_env();
 
+// src/bridges/copilot_session_start.ts
+init_define_import_meta_env();
+var COPILOT_SESSION_START_HELPERS = `
+const SHIM_SESSION_START_TIMEOUT_MS = ${SHIM_SESSION_START_TIMEOUT_MS}
+
+// Test-only seam, mirrored by the native owner: a plain decimal in range replaces the budget so a test need not race the clock; anything else is ignored.
+function sessionStartBudgetMs() {
+  const text = process.env.${SESSION_START_TEST_BUDGET_ENV}
+  if (typeof text !== 'string' || !/^[0-9]+$/.test(text)) return SHIM_SESSION_START_TIMEOUT_MS
+  const value = Number(text)
+  return value >= ${SESSION_START_TEST_BUDGET_MIN_MS} && value <= ${SESSION_START_TEST_BUDGET_MAX_MS} ? value : SHIM_SESSION_START_TIMEOUT_MS
+}
+const SESSION_START_CLEANUP_RESERVE_MS = 1000
+// How long past the deadline the shim keeps its stdin listener for a payload already in the pipe: on Windows the pipe read completes on a worker thread, so the completion can land many event-loop turns after the listener attaches. Measured resume-to-data under 52 busy loops on 26 CPUs: p50 5.7 ms, max 204 ms.
+const SESSION_START_LATE_PAYLOAD_GRACE_MS = 1000
+const SESSION_START_MAX_INPUT_BYTES = 1024 * 1024
+
+function failOpenSessionStart(reason) {
+  process.stderr.write('[token-goat] SessionStart failed open: ' + reason + '\\n')
+  process.stdout.write('{}')
+}
+
+function readSessionStartInput(timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    const closers = []
+    let totalBytes = 0
+    let frameStart = -1
+    let frameEnd = -1
+    let inString = false
+    let escaped = false
+    let settled = false
+    let timer
+
+    function cleanup() {
+      clearTimeout(timer)
+      process.stdin.removeListener('data', onData)
+      process.stdin.removeListener('end', onEnd)
+      process.stdin.removeListener('error', onError)
+      process.stdin.pause()
+      if (typeof process.stdin.unref === 'function') process.stdin.unref()
+      process.stdin.destroy()
+    }
+
+    function finish(error, value) {
+      if (settled) return
+      settled = true
+      cleanup()
+      if (error) reject(new Error(error))
+      else resolve(value)
+    }
+
+    function onData(chunk) {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+      const chunkStart = totalBytes
+      totalBytes += bytes.length
+      if (totalBytes > SESSION_START_MAX_INPUT_BYTES) {
+        finish('input exceeded 1 MiB')
+        return
+      }
+      chunks.push(bytes)
+
+      for (let index = 0; index < bytes.length; index += 1) {
+        const byte = bytes[index]
+        const position = chunkStart + index
+        if (frameEnd !== -1) {
+          if (byte !== 0x20 && byte !== 0x09 && byte !== 0x0a && byte !== 0x0d) {
+            finish('input contained trailing data')
+            return
+          }
+          continue
+        }
+        if (frameStart === -1) {
+          if (byte === 0x20 || byte === 0x09 || byte === 0x0a || byte === 0x0d) continue
+          if (byte !== 0x7b) {
+            finish('input was not a JSON object')
+            return
+          }
+          frameStart = position
+          closers.push(0x7d)
+          continue
+        }
+        if (inString) {
+          if (escaped) escaped = false
+          else if (byte === 0x5c) escaped = true
+          else if (byte === 0x22) inString = false
+          continue
+        }
+        if (byte === 0x22) {
+          inString = true
+        } else if (byte === 0x7b) {
+          closers.push(0x7d)
+        } else if (byte === 0x5b) {
+          closers.push(0x5d)
+        } else if (byte === 0x7d || byte === 0x5d) {
+          if (closers.pop() !== byte) {
+            finish('input contained malformed JSON')
+            return
+          }
+          if (closers.length === 0) frameEnd = position + 1
+        }
+      }
+
+      if (frameEnd !== -1) {
+        const framed = Buffer.concat(chunks, totalBytes)
+        const raw = framed.subarray(frameStart, frameEnd).toString('utf8')
+        try {
+          const parsed = JSON.parse(raw)
+          if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            finish('input was not a JSON object')
+            return
+          }
+        } catch {
+          finish('input contained malformed JSON')
+          return
+        }
+        finish(undefined, raw)
+      }
+    }
+
+    function onEnd() {
+      finish(frameStart === -1 ? 'stdin closed without input' : 'stdin closed before the JSON object was complete')
+    }
+
+    function onError() {
+      finish('stdin could not be read')
+    }
+
+    // A payload already in the pipe must be framed even when the deadline has passed: expiry opens one bounded grace window that data, end or error closes at once, so only a payload that never arrives costs the full grace.
+    timer = setTimeout(() => { timer = setTimeout(() => finish('input deadline exceeded'), SESSION_START_LATE_PAYLOAD_GRACE_MS) }, Math.max(0, timeoutMs))
+    process.stdin.on('data', onData)
+    process.stdin.on('end', onEnd)
+    process.stdin.on('error', onError)
+    process.stdin.resume()
+  })
+}
+
+// Plain-JS mirror of session_start_owed.ts::resetSessionStartOwed for a main-thread key: tests/session_start_owed_reset.test.ts pins both to the same files. It runs before anything can throw so a helper killed before its own stamp still leaves the start begun, and an earlier start's marker cannot read settled.
+function resetSessionStartOwedFiles(payload) {
+  stampSessionStartOwedFiles(payload, true)
+}
+
+// A start this shim failed open on is owed whatever the helper's own marker says: the helper judges "settled in time" from its own clock, and the shim can still discard its response (a helper whose exit outlasts the budget, a cleanup that fails, an unreadable response). The shim is the party that knows it printed nothing, so it re-stamps the start begun after the helper tree is gone. A plain-JS mirror of session_start_owed.ts::recordSessionStartBegun.
+function stampSessionStartOwedFiles(payload, dropClaim) {
+  try {
+    const raw = payload && (payload.session_id !== undefined ? payload.session_id : payload.sessionId)
+    if (typeof raw !== 'string' || raw === '' || raw.indexOf(':agent:') !== -1) return
+    // A subagent's key is salted, and its start is not the parent's to reset.
+    if (payload.agent_id || payload.agentId) return
+    const override = (process.env.TOKEN_GOAT_HOME || '').trim()
+    const rooted = override !== '' && require('node:path').isAbsolute(override) &&
+      (process.platform !== 'win32' || !['', '/', String.fromCharCode(92)].includes(require('node:path').parse(override).root))
+    const home = rooted ? override : require('node:path').join(require('node:os').homedir(), '.token-goat')
+    const stem = raw.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64)
+    if (stem === '') return
+    // The claim goes, and the settle file is rewritten as a begun stamp: only a begun, unsettled start is owed.
+    if (dropClaim) require('node:fs').rmSync(require('node:path').join(home, 'sessions', stem + '.session-start-owed'), { force: true })
+    require('node:fs').mkdirSync(require('node:path').join(home, 'sessions'), { recursive: true })
+    require('node:fs').writeFileSync(require('node:path').join(home, 'sessions', stem + '.session-start'), JSON.stringify({ begunAtMs: Date.now() }), 'utf8')
+  } catch {
+    // Best-effort: the helper clears the marker itself when it gets that far.
+  }
+}
+
+async function runBoundedSessionStart(entryPath, eventName, payload, harness, deadline) {
+  resetSessionStartOwedFiles(payload)
+  // Do not probe entryPath here: even existsSync can block on a network filesystem.
+  if (typeof entryPath !== 'string' || entryPath === '') throw new Error('hook entry unavailable')
+  const remainingMs = deadline - Date.now()
+  if (remainingMs <= 0) throw new Error('overall deadline exceeded')
+  // Reject before spawning when only the process-tree teardown reserve remains.
+  if (remainingMs <= SESSION_START_CLEANUP_RESERVE_MS) {
+    throw new Error('insufficient time for process-tree cleanup')
+  }
+
+  const args = [entryPath, 'hook', eventName]
+  const env = Object.assign({}, process.env, { TOKEN_GOAT_HOOK_SERVER: '0' })
+  if (process.platform === 'win32') env.TG_SESSION_START_DEFER_WORKER = '1'
+  // Lets the helper's settle marker say how close to the deadline it finished.
+  env.TG_SESSION_START_DEADLINE_EPOCH = String(deadline)
+  if (harness === 'vscode') {
+    args.push('--harness', 'vscode')
+    env.TOKEN_GOAT_HARNESS_OVERRIDE = 'vscode'
+    env.TOKEN_GOAT_VSCODE_HOOKS_DIR = __dirname
+  } else {
+    env.TOKEN_GOAT_HARNESS_OVERRIDE = 'copilot_cli'
+    env.TOKEN_GOAT_COPILOT_HOOKS_DIR = __dirname
+  }
+
+  let stdout
+  try {
+    stdout = await superviseSessionStart({ args, env, payload, deadline })
+  } catch (error) {
+    // The caller prints the failed-open line and exactly {}: the start is owed, whatever marker the helper left.
+    stampSessionStartOwedFiles(payload, false)
+    throw error
+  }
+  try {
+    const parsed = JSON.parse(stdout.trim())
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('hook helper returned a non-object response')
+    }
+    return JSON.stringify(parsed)
+  } catch {
+    stampSessionStartOwedFiles(payload, false)
+    throw new Error('hook helper returned invalid JSON')
+  }
+}
+
+function superviseSessionStart({ args, env, payload, deadline }) {
+  if (process.platform === 'win32') return superviseWindowsSessionStart({ args, env, payload, deadline })
+  const { spawn } = require('node:child_process')
+  // On POSIX, retain the canonical root until its detached group is killed.
+  const supervisor = [
+    "const keeper = setInterval(() => {}, 1000); keeper.unref()",
+    "let finished = false",
+    "function done(code) { if (finished) return; finished = true; keeper.ref(); process.send({ type: 'hookExit', code }) }",
+    "process.exit = code => done(code === undefined ? (process.exitCode || 0) : Number(code))",
+    "process.once('beforeExit', code => done(code))",
+    "process.once('uncaughtException', () => done(1))",
+    "process.once('unhandledRejection', () => done(1))",
+    "import(require('node:url').pathToFileURL(require('node:path').resolve(process.argv[1])).href).catch(() => done(1))",
+  ].join(';')
+  return new Promise((resolve, reject) => {
+    const root = spawn(process.execPath, ['-e', supervisor, ...args], {
+      env, windowsHide: true,
+      // owner: this shim, which SIGKILLs the whole group in beginCleanup and, when that fails or the supervisor died first, in cleanupFailed; dies when the helper reports its exit, on an error, a timeout or the hard deadline (descendants that left the group, or the shim itself being SIGKILLed, are not covered).
+      detached: process.platform !== 'win32',
+      stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+    })
+    let helperCode
+    let rootClosed = false
+    let cleaning = false
+    let cleaned = false
+    let settled = false
+    let failure
+    let outputBytes = 0
+    const output = []
+    let stderrBytes = 0
+    let timer
+    let hardTimer
+
+    function alive(pid) {
+      if (!pid) return false
+      try { process.kill(pid, 0); return true } catch (error) { return error.code === 'EPERM' }
+    }
+
+    function finish(error) {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      clearTimeout(hardTimer)
+      root.removeListener('message', onMessage)
+      root.removeListener('exit', onExit)
+      root.removeListener('close', onClose)
+      root.stdout.removeListener('data', onOutput)
+      root.stderr.removeListener('data', onStderr)
+      root.stdin.destroy()
+      root.stdout.destroy()
+      root.stderr.destroy()
+      if (root.connected) root.disconnect()
+      // owner: this shim, which has killed the group by now (beginCleanup, or the group kill in cleanupFailed); dies when that kill lands, and the unref only lets the shim exit.
+      root.unref()
+      if (error) reject(new Error(error))
+      else resolve(Buffer.concat(output, outputBytes).toString('utf8'))
+    }
+
+    function complete() {
+      // close, not exit, proves all buffered stdout was drained. The hard deadline
+      // below also covers an escaped descendant retaining a pipe indefinitely.
+      if (!cleaned || !rootClosed) return
+      if (!failure && (helperCode !== 0 || outputBytes === 0)) failure = 'hook helper exited without a response'
+      finish(failure)
+    }
+
+    function killGroup() { process.kill(-root.pid, 'SIGKILL') }
+
+    function cleanupFailed(reason) {
+      // The group outlives its leader while any member runs, so this reaches descendants even after the supervisor died; ESRCH means no member is left. Descendants that left the group are still unverified.
+      if (root.pid) {
+        try { killGroup() } catch (error) {
+          if (error.code !== 'ESRCH') reason += '; group kill failed'
+        }
+      }
+      // Verify the known owned PIDs before falling back to direct kills. Unknown
+      // descendants cannot be certified clean when the tree utility has failed.
+      const remaining = [root.pid].filter(alive)
+      for (const pid of remaining) {
+        try { process.kill(pid, 'SIGKILL') } catch (error) {
+          if (error.code !== 'ESRCH') reason += '; direct kill failed for PID ' + pid
+        }
+      }
+      finish((failure ? failure + '; ' : '') + 'process-tree cleanup failed: ' + reason
+        + '; remaining owned PIDs before fallback: ' + (remaining.join(',') || 'none')
+        + '; remaining known PIDs after fallback: ' + (remaining.filter(alive).join(',') || 'none')
+        + '; descendant termination not verified')
+    }
+
+    function beginCleanup(reason) {
+      if (reason && !failure) failure = reason
+      if (settled || cleaning) return
+      cleaning = true
+      clearTimeout(timer)
+      if (!root.pid) { finish(failure || 'hook helper could not run'); return }
+      try {
+        killGroup()
+        cleaned = true
+        complete()
+      } catch (error) {
+        cleanupFailed(error.code || 'group kill failed')
+      }
+    }
+
+    function onOutput(chunk) {
+      outputBytes += chunk.length
+      if (outputBytes > SESSION_START_MAX_INPUT_BYTES) { beginCleanup('hook helper output exceeded 1 MiB'); return }
+      output.push(chunk)
+    }
+
+    function onStderr(chunk) {
+      stderrBytes += chunk.length
+      if (stderrBytes > SESSION_START_MAX_INPUT_BYTES) beginCleanup('hook helper stderr exceeded 1 MiB')
+    }
+
+    function onMessage(message) {
+      if (message && message.type === 'hookExit') {
+        helperCode = message.code
+        beginCleanup(message.code === 0 ? undefined : 'hook helper exited without a response')
+      }
+    }
+
+    function onExit() {
+      if (!cleaning) cleanupFailed('supervisor exited before tree cleanup')
+    }
+
+    function onClose() { rootClosed = true; complete() }
+
+    root.on('message', onMessage)
+    root.once('exit', onExit)
+    root.once('close', onClose)
+    root.once('error', () => beginCleanup('hook helper could not run'))
+    root.stdin.on('error', () => beginCleanup('hook helper input failed'))
+    root.stdout.on('data', onOutput)
+    root.stderr.on('data', onStderr)
+    root.stdout.on('error', () => beginCleanup('hook helper stdout failed'))
+    root.stderr.on('error', () => beginCleanup('hook helper stderr failed'))
+    const remaining = deadline - Date.now()
+    // Reserve the final second of the single budget for owned-tree teardown.
+    timer = setTimeout(() => beginCleanup('hook helper timed out'), Math.max(0, remaining - SESSION_START_CLEANUP_RESERVE_MS))
+    hardTimer = setTimeout(() => cleanupFailed('overall deadline exceeded'), Math.max(0, remaining))
+    root.stdin.end(JSON.stringify(payload))
+  })
+}
+
+function superviseWindowsSessionStart({ args, env, payload, deadline }) {
+  const { spawn } = require('node:child_process')
+  const path = require('node:path')
+  // Pure path arithmetic on the trusted installed entry, never PATH lookup or
+  // synchronous filesystem probing in the externally visible parent.
+  const binary = path.join(path.dirname(args[0]), 'native', 'win32-' + process.arch, 'tg-hook.exe')
+  return new Promise((resolve, reject) => {
+    // owner: the native tg-hook client, which holds a strict Job Object and ends every descendant when this shim closes its handle; dies when the job closes or the deadline passes.
+    const root = spawn(binary, ['--session-start-owner-v1', String(deadline), process.execPath, ...args], {
+      env, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'],
+    })
+    const output = []
+    const diagnostics = []
+    let outputBytes = 0
+    let diagnosticBytes = 0
+    let settled = false
+    let timer
+    function finish(error, candidate) {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      root.stdin.destroy()
+      root.stdout.destroy()
+      root.stderr.destroy()
+      // Killing the owner closes the sole non-inherited job handle. Never
+      // traverse a dead canonical PID or launch an unowned Windows fallback.
+      if (error && root.pid) root.kill('SIGKILL')
+      // owner: this shim, which kills the native owner on any error (its job handle closing ends the tree) and finds it closed on success; dies when that kill lands or the owner has exited.
+      root.unref()
+      if (error) reject(new Error(error))
+      else resolve(JSON.stringify(candidate))
+    }
+    root.once('error', error => finish('native startup owner unavailable: ' + error.message))
+    root.stdin.on('error', error => finish('native startup owner input failed: ' + error.message))
+    root.stdout.on('error', error => finish('native startup owner stdout failed: ' + error.message))
+    root.stderr.on('error', error => finish('native startup owner stderr failed: ' + error.message))
+    root.stdout.on('data', chunk => {
+      outputBytes += chunk.length
+      if (outputBytes > SESSION_START_MAX_INPUT_BYTES + 4096) finish('native startup owner output exceeded 1 MiB')
+      else output.push(chunk)
+    })
+    root.stderr.on('data', chunk => {
+      diagnosticBytes += chunk.length
+      if (diagnosticBytes > SESSION_START_MAX_INPUT_BYTES) finish('native startup owner stderr exceeded 1 MiB')
+      else diagnostics.push(chunk)
+    })
+    root.once('close', code => {
+      if (settled) return
+      const diagnostic = Buffer.concat(diagnostics).toString('utf8').trim()
+      if (code !== 0) { finish('native startup owner failed: ' + (diagnostic || 'exit ' + code)); return }
+      let ack
+      try { ack = JSON.parse(Buffer.concat(output).toString('utf8')) } catch {
+        finish('native startup owner returned invalid protocol JSON'); return
+      }
+      if (!ack || ack.protocol !== 'tg-session-start-owner-v1' || ack.capability !== 'atomic-job-list'
+          || ack.activeProcesses !== 0 || ack.rootExited !== true || ack.pipesDrained !== true
+          || !ack.candidate || typeof ack.candidate !== 'object' || Array.isArray(ack.candidate)) {
+        finish('native startup owner incompatible protocol or unverified cleanup'); return
+      }
+      if (ack.workerWake === true) {
+        // The installed native entry owns this shim too. Relay only a bounded
+        // request; it, not an inner owner, must launch outside every startup job.
+        if (process.argv[4] && process.argv[4].startsWith('--session-start-deadline=')) {
+          process.stderr.write('\\x1eTG_WORKER_WAKE_V1\\x1e\\n')
+        } else if (process.env.TOKEN_GOAT_NO_WORKER_SPAWN !== '1') {
+          const workerEnv = Object.assign({}, process.env)
+          delete workerEnv.TG_SESSION_START_DEFER_WORKER
+          try {
+            const worker = spawn(process.execPath, [args[0], '--worker-daemon', '--claim-worker'], {
+              env: workerEnv, cwd: require('node:os').tmpdir(), windowsHide: true, stdio: 'ignore',
+              // owner: none, the daemon outlives this shim on purpose; dies when its pid file or data directory is gone, when it sits idle, or on worker stop.
+              detached: true,
+            })
+            worker.on('error', () => {})
+            // owner: none, the daemon outlives this shim on purpose; dies when its pid file or data directory is gone, when it sits idle, or on worker stop.
+            worker.unref()
+          } catch {
+            // Queue remains durable; ordinary lifecycle activation can retry.
+          }
+        }
+      }
+      finish(undefined, ack.candidate)
+    })
+    timer = setTimeout(() => finish('native startup owner overall deadline exceeded'), Math.max(0, deadline - Date.now()))
+    root.stdin.end(JSON.stringify(payload))
+  })
+}
+`;
+
 // src/bridges/shrink_block.ts
 init_define_import_meta_env();
 var MATERIALIZE_SHRUNK_IMAGE_JS = `// Best-effort sweep of previously materialized shrunk copies in the OS temp dir. The temp file only needs to outlive the single tool call whose path argument was rewritten to it, so anything older than an hour is finished with; the "token-goat-shrink-" prefix check confines the sweep to this mechanism's own files (same defense-in-depth rule as pruneShrinkCache in src/image_shrink.ts). Throttled per process; runs only when a shrink payload actually arrives, so the common no-image path never pays for it.
@@ -1761,12 +2264,17 @@ var COPILOT_CLI_HOOK_SCRIPT = `#!/usr/bin/env node
 // token-goat Copilot CLI hook shim. Translates Copilot's hook event names and
 // request/response schema to/from token-goat's internal hook protocol.
 'use strict'
+${SHIM_MAX_BUFFER_CONST}
 const { spawnSync } = require('node:child_process')
 const fs = require('node:fs')
 const os = require('node:os')
 const path = require('node:path')
 const { pathToFileURL } = require('node:url')
 
+// How long the fallback spawn of the real hook may run before the shim answers an empty fail-open '{}' for it. The hook entries token-goat installs give Copilot 60 s (HOOK_TIMEOUT_SEC in copilot_cli_install.ts); the number is SHIM_FALLBACK_TIMEOUT_MS.copilot in shim_common.ts, and a hook Copilot kills fails open the same way, so a cap of a few seconds only discarded the verdict of a cold start that was merely slow (bundle load, DB open, a loaded machine). Kept under that 60 s so the shim, not Copilot, ends a hook that really is stuck.
+${shimFallbackTimeoutConst("copilot")}
+${COPILOT_SESSION_START_HELPERS}
+
 // Copilot event name -> token-goat internal HookEventName (src/types.ts's
 // HOOK_EVENTS). Only these nine have a token-goat handler; every other real
 // Copilot event (sessionEnd, errorOccurred, notification, permissionRequest)
@@ -1815,6 +2323,7 @@ const COPILOT_TO_TG_EVENT = {
 // one of these keys is answered with nothing, so a Copilot build that also
 // honored the PascalCase spelling could not brief a subagent twice.
 const VSCODE_ONLY_TO_TG_EVENT = {
+  SessionStart: 'session_start',
   SubagentStart: 'subagent_start',
 }
 
@@ -2074,9 +2583,9 @@ async function relayVscode(entryPath, tgEvent, payload) {
       input: JSON.stringify(input),
       encoding: 'utf8',
       windowsHide: true,
-      timeout: 3000,
+      timeout: SHIM_FALLBACK_TIMEOUT_MS,
       killSignal: 'SIGKILL',
-      maxBuffer: 32 * 1024 * 1024,
+      maxBuffer: SHIM_MAX_BUFFER_BYTES,
       env: Object.assign({}, process.env, { TOKEN_GOAT_HARNESS_OVERRIDE: 'vscode', TOKEN_GOAT_VSCODE_HOOKS_DIR: __dirname }),
     }
     const res = entryPath
@@ -2094,6 +2603,7 @@ async function relayVscode(entryPath, tgEvent, payload) {
 }
 
 async function main() {
+  const startedAt = Math.floor(require('node:perf_hooks').performance.timeOrigin)
   const copilotEvent = process.argv[2] || ''
 
   // ownGet, not a bare lookup: the map is a plain object literal, so eight keys it never declares ('constructor', 'toString', '__proto__' and the rest of Object.prototype) come back truthy and sail past the check below. tgEvent is then a Function, and 'token-goat hook ' + tgEvent is concatenated into a shell command string by the fallback at the bottom of this shim. No member of Object.prototype stringifies with a shell metacharacter, so this was a failed spawn rather than a second command -- but argv reaching a shell string through a gate that reads like it stops it is the shape worth closing, not the payload that happened to be harmless. The four shims built on shim_common.ts validate against a closed Set, which has no equivalent hole.
@@ -2104,24 +2614,56 @@ async function main() {
     return
   }
 
+  let sessionStartDeadline
+  if (tgEvent === 'session_start') {
+    const inherited = process.argv[4]
+    const epoch = inherited === undefined ? startedAt + sessionStartBudgetMs()
+      : inherited.startsWith('--session-start-deadline=') ? Number(inherited.slice('--session-start-deadline='.length)) : NaN
+    if (!Number.isSafeInteger(epoch) || epoch <= 0 || epoch > startedAt + sessionStartBudgetMs()) {
+      failOpenSessionStart('invalid inherited startup deadline')
+      return
+    }
+    sessionStartDeadline = epoch
+  }
   let raw = ''
-  try {
-    raw = require('node:fs').readFileSync(0, 'utf8')
-  } catch {
-    process.stdout.write('{}')
-    return
+  if (sessionStartDeadline !== undefined) {
+    try {
+      raw = await readSessionStartInput(sessionStartDeadline - Date.now())
+    } catch (error) {
+      failOpenSessionStart(error && error.message ? error.message : 'input could not be read')
+      return
+    }
+  } else {
+    try {
+      raw = require('node:fs').readFileSync(0, 'utf8')
+    } catch {
+      process.stdout.write('{}')
+      return
+    }
   }
 
   let payload
   try {
     payload = JSON.parse(raw)
   } catch {
-    process.stdout.write('{}')
+    if (sessionStartDeadline !== undefined) failOpenSessionStart('input contained malformed JSON')
+    else process.stdout.write('{}')
     return
   }
 
   if (isVscodePayload(payload)) {
-    process.stdout.write(await relayVscode(process.argv[3], tgEvent, payload))
+    if (sessionStartDeadline === undefined) {
+      process.stdout.write(await relayVscode(process.argv[3], tgEvent, payload))
+    } else {
+      try {
+        const input = typeof payload.session_id === 'string' && payload.session_id !== ''
+          ? payload
+          : Object.assign({}, payload, { session_id: stableFallbackSessionId(process.cwd()) })
+        process.stdout.write(await runBoundedSessionStart(process.argv[3], tgEvent, input, 'vscode', sessionStartDeadline))
+      } catch (error) {
+        failOpenSessionStart(error && error.message ? error.message : 'hook helper failed')
+      }
+    }
     return
   }
   if (vscodeOnly) {
@@ -2214,23 +2756,28 @@ async function main() {
   // template string) is safe here specifically because entryPath and tgEvent never touch a
   // shell -- no DEP0190 concern, unlike the shell:true fallback below.
   const entryPath = process.argv[3]
-  // Try the in-process hook lib first (tryInProcess above), which avoids spawning a
-  // second node process altogether. If that's unavailable, invoking the entry directly
-  // via process.execPath sidesteps PATH/cmd.exe resolution for this inner call, per the
-  // note above this function's original single-spawn form documented. A 3000ms
-  // timeout/killSignal on both spawnSync fallbacks keeps them well under Copilot CLI's
-  // own hook timeout budget (~30000ms), so token-goat degrades to its own fail-open
-  // '{}' rather than being force-killed by Copilot first.
-  let stdout = await tryInProcess(entryPath, tgEvent, canonical, 'copilot_cli')
+  // SessionStart bypasses the resident server and in-process path: only a child-process deadline can interrupt synchronous handler or SQLite work. TOKEN_GOAT_HOOK_SERVER=0 below also prevents that child from leaving a server process behind.
+  let stdout
+  if (sessionStartDeadline !== undefined) {
+    try {
+      stdout = await runBoundedSessionStart(entryPath, tgEvent, canonical, 'copilot_cli', sessionStartDeadline)
+    } catch (error) {
+      failOpenSessionStart(error && error.message ? error.message : 'hook helper failed')
+      return
+    }
+  } else {
+    // Other events retain the in-process fast path and existing fallback behavior.
+    stdout = await tryInProcess(entryPath, tgEvent, canonical, 'copilot_cli')
+  }
   if (stdout === undefined) {
     const res = entryPath
       ? spawnSync(process.execPath, [entryPath, 'hook', tgEvent], {
           input: JSON.stringify(canonical),
           encoding: 'utf8',
           windowsHide: true,
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: 'SIGKILL',
-          maxBuffer: 32 * 1024 * 1024,
+          maxBuffer: SHIM_MAX_BUFFER_BYTES,
           env: Object.assign({}, process.env, { TOKEN_GOAT_HARNESS_OVERRIDE: 'copilot_cli', TOKEN_GOAT_COPILOT_HOOKS_DIR: __dirname }),
         })
       : spawnSync('token-goat hook ' + tgEvent, {
@@ -2238,9 +2785,9 @@ async function main() {
           encoding: 'utf8',
           shell: true,
           windowsHide: true,
-          timeout: 3000,
+          timeout: SHIM_FALLBACK_TIMEOUT_MS,
           killSignal: 'SIGKILL',
-          maxBuffer: 32 * 1024 * 1024,
+          maxBuffer: SHIM_MAX_BUFFER_BYTES,
           env: Object.assign({}, process.env, { TOKEN_GOAT_HARNESS_OVERRIDE: 'copilot_cli', TOKEN_GOAT_COPILOT_HOOKS_DIR: __dirname }),
         })
     if (res.status !== 0 || !res.stdout) {
@@ -2586,7 +3133,7 @@ function installCopilotMcpServer() {
   const config = readServersJson(mcpPath, LABEL);
   const current = serversOf(config, mcpPath, LABEL, MCP_SERVERS_KEY)[TOKEN_GOAT_ENTRY_KEY];
   if (current !== void 0 && !isCopilotManagedServer(current) && !isReadmeServer(current)) {
-    throw new Error(`Copilot CLI mcp-config.json already has a "${TOKEN_GOAT_ENTRY_KEY}" MCP server entry token-goat did not write, at ${mcpPath}; remove it manually first`);
+    throw new Error(`Copilot CLI mcp-config.json already has a ${echoedValue(TOKEN_GOAT_ENTRY_KEY)} MCP server entry token-goat did not write, at ${mcpPath}; remove it manually first`);
   }
   const nextText = setTokenGoatServer(config.text, copilotManagedServer(), MCP_SERVERS_KEY);
   if (nextText === config.text) return false;
@@ -2656,8 +3203,8 @@ function visualStudioDuplicateNote(projectRoot = process.cwd()) {
   const found = visualStudioManagedRegistrations(projectRoot);
   if (found.length < 2) return null;
   const lead = `Note: Visual Studio reads ${found.join(" and ")}, and each registers token-goat, so it will list the token-goat server more than once for this solution.`;
-  if (!found.includes(visualStudioSolutionVscodeMcpPath(projectRoot))) return `${lead} Keep one: run "token-goat uninstall --visualstudio" or "token-goat uninstall --visualstudio -p".`;
-  return `${lead} Keep one: if you do not use VS Code in this folder, run "token-goat uninstall --vscode -p"; otherwise run "token-goat uninstall --visualstudio${found.includes(visualStudioUserMcpPath()) ? "" : " -p"}".`;
+  if (!found.includes(visualStudioSolutionVscodeMcpPath(projectRoot))) return `${lead} Keep one: run ${fencedCommand("token-goat uninstall --visualstudio")} or ${fencedCommand("token-goat uninstall --visualstudio -p")}.`;
+  return `${lead} Keep one: if you do not use VS Code in this folder, run ${fencedCommand("token-goat uninstall --vscode -p")}; otherwise run ${fencedCommand("token-goat uninstall --visualstudio" + (found.includes(visualStudioUserMcpPath()) ? "" : " -p"))}.`;
 }
 function visualStudioMcpStatus(opts = {}) {
   const checkedPaths = [visualStudioUserMcpPath()];
@@ -2708,7 +3255,7 @@ function installVisualStudioScoped(opts) {
   if (visualStudioOtherScopeHasManagedServer(opts)) {
     const otherScope = scope === "project" ? "user" : "project";
     throw new Error(
-      `token-goat is already registered in Visual Studio ${otherScope} scope (${otherScopeMcpPath(opts)}). Visual Studio reads both files, so installing into ${scope} scope too would register it twice. Run "token-goat uninstall --visualstudio${otherScope === "project" ? " --project" : ""}" first if you want to move it, or drop --visualstudio from this run.`
+      `token-goat is already registered in Visual Studio ${otherScope} scope (${otherScopeMcpPath(opts)}). Visual Studio reads both files, so installing into ${scope} scope too would register it twice. Run ${fencedCommand("token-goat uninstall --visualstudio" + (otherScope === "project" ? " --project" : ""))} first if you want to move it, or drop --visualstudio from this run.`
     );
   }
   const mcpExisted = fs6.existsSync(mcpPath);
@@ -2926,6 +3473,20 @@ function releaseCopilotHooksFile(hooksDir, owner, keepBackups = false) {
 function installCopilotCli(opts = {}) {
   return withInstallScope(projectScopeRoot(opts), () => installCopilotCliScoped(opts));
 }
+function syncCopilotHooksAndInstructions(opts) {
+  const hooks = installCopilotHooksFile(copilotCliHooksDir(opts), "copilot");
+  const instructionsPath = copilotCliInstructionsPath(opts);
+  const instructionsExisted = fs7.existsSync(instructionsPath);
+  const instructionsChanged = writeCopilotInstructionsBlock(instructionsPath);
+  if (!instructionsExisted) recordCreatedConfig(instructionsPath);
+  return { hooks, instructionsChanged };
+}
+function repairCopilotCliHooks(opts = {}) {
+  return withInstallScope(projectScopeRoot(opts), () => {
+    const { hooks, instructionsChanged } = syncCopilotHooksAndInstructions(opts);
+    return hooks.changed || instructionsChanged;
+  });
+}
 function installCopilotCliScoped(opts) {
   const instructionsPath = copilotCliInstructionsPath(opts);
   const userScope = opts.local !== true;
@@ -2933,10 +3494,8 @@ function installCopilotCliScoped(opts) {
   const scopeDirExisted = fs7.existsSync(scopeDir);
   const mcpChanged = userScope ? installCopilotMcpServer() : false;
   if (!scopeDirExisted && fs7.existsSync(scopeDir)) recordCreatedConfig(scopeDir);
-  const hooks = installCopilotHooksFile(copilotCliHooksDir(opts), "copilot");
-  const instructionsExisted = fs7.existsSync(instructionsPath);
-  let instructionsChanged = writeCopilotInstructionsBlock(instructionsPath);
-  if (!instructionsExisted) recordCreatedConfig(instructionsPath);
+  const { hooks, instructionsChanged: scopeInstructionsChanged } = syncCopilotHooksAndInstructions(opts);
+  let instructionsChanged = scopeInstructionsChanged;
   if (userScope) {
     const projectRoot = path7.resolve(opts.projectRoot ?? process.cwd());
     const projectInstructions = copilotCliInstructionsPath({ local: true, projectRoot });
@@ -3001,6 +3560,7 @@ export {
   SHIM_VALID_HOOK_EVENTS,
   SHIM_TRY_IN_PROCESS,
   SHIM_SPAWN_LADDER,
+  shimFallbackTimeoutConst,
   SHIM_MAX_BUFFER_CONST,
   CLAUDECODE_HOOK_SCRIPT,
   buildGuidanceBody,
@@ -3024,6 +3584,7 @@ export {
   uninstallHooks,
   finishHookUninstall,
   isInstalled,
+  claudeHooksInstalledAnyScope,
   hookEventGaps,
   claudeMdPath,
   installedClaudeMdBlock,
@@ -3070,11 +3631,9 @@ export {
   installVisualStudio,
   uninstallVisualStudio,
   canonicalProjectRoot,
-  copilotCliHooksDir,
   copilotCliConfigPath,
   copilotCliScriptPath,
   copilotCliInstructionsPath,
-  writeCopilotInstructionsBlock,
   wiredCopilotHookWords,
   HOOKS_SCRIPT_FILE,
   LEGACY_HOOKS_SCRIPT_FILE,
@@ -3082,6 +3641,7 @@ export {
   installCopilotHooksFile,
   releaseCopilotHooksFile,
   installCopilotCli,
+  repairCopilotCliHooks,
   uninstallCopilotCli,
   isCopilotCliInstalled
 };