codiedev 0.9.80 → 0.10.0-beta.10

package/dist/hook.js

@@ -51,9 +51,7 @@ const codexLimitScan_1 = require("./codexLimitScan");
 const launchContext_1 = require("./launchContext");
 const selfUpdate_1 = require("./selfUpdate");
 const version_1 = require("./version");
-// --- starter packs (SIG-113 phase 2): autosync, nudge ---
 const sync_1 = require("./packs/sync");
-// --- end starter packs ---
 const captureLog_1 = require("./captureLog");
 const subagents_1 = require("./subagents");
 const captureExclusions_1 = require("./captureExclusions");
@@ -62,15 +60,9 @@ const copilotHooks_1 = require("./copilotHooks");
 const piHooks_1 = require("./piHooks");
 const cliSession_1 = require("./cliSession");
 const utils_2 = require("./utils");
-// Pure builder for the discovery additionalContext. Returns null when there are
-// no matches. The suggested `codiedev pull` command carries the EXACT top key
-// (e.g. "pr-push.md") rather than a "<key>" placeholder — otherwise agents
-// paraphrase the key (pr-push) and the extension-sensitive `pull` 404s.
 function buildDiscoveryContext(skills) {
     if (skills.length === 0)
         return null;
-    // Don't trust the API's ordering — rank by score so the suggested pull key is
-    // always the highest-confidence match.
     const top = [...skills].sort((a, b) => b.score - a.score).slice(0, 3);
     const lines = top
         .map((s) => `- ${s.key} — ${(s.score * 100).toFixed(0)}% match`)
@@ -82,9 +74,6 @@ function buildDiscoveryContext(skills) {
         "`. It encodes the team's vetted " +
         "approach. Skip it only if it clearly doesn't apply.");
 }
-// UserPromptSubmit: query skill discovery for the prompt and, if a team skill
-// clears the confidence threshold, inject it as additionalContext so the agent
-// can offer to pull+run it. Fully silent on miss/error — never blocks input.
 async function discoverContext(prompt) {
     if (!prompt || !prompt.trim())
         return null;
@@ -92,15 +81,11 @@ async function discoverContext(prompt) {
     if (!config)
         return null;
     try {
-        // POST body, never a query param: raw prompts in GET query strings land
-        // in server/proxy access logs (SIG-16). The server keeps accepting legacy
-        // GETs from older CLIs during the transition.
         const res = await postJsonForResponse(`${config.backendUrl}/api/cli/skill-discovery`, { q: prompt }, config.token);
         const skills = res?.skills ?? [];
         return buildDiscoveryContext(skills);
     }
     catch {
-        // silent — discovery is best-effort
     }
     return null;
 }
@@ -126,9 +111,6 @@ function readTranscriptTailFile(transcriptPath, maxBytes = 512 * 1024) {
         fs.closeSync(handle);
     }
 }
-// StopFailure (matcher rate_limit): the dev just got blocked. Read the local
-// transcript tail for the ground-truth rate_limit line and POST a tiny event.
-// Best-effort + silent — StopFailure output is ignored by Claude Code anyway.
 async function readAndPostLimitEvent(hookInput, source, emitMinimalOnMiss) {
     const config = (0, utils_1.readConfig)();
     if (!config)
@@ -140,7 +122,6 @@ async function readAndPostLimitEvent(hookInput, source, emitMinimalOnMiss) {
             transcript = readTranscriptTailFile(tp);
         }
         catch {
-            /* unreadable transcript — fall through to minimal event */
         }
     }
     try {
@@ -153,23 +134,12 @@ async function readAndPostLimitEvent(hookInput, source, emitMinimalOnMiss) {
         });
     }
     catch {
-        /* best-effort */
     }
 }
 async function runStopFailure(hookInput) {
     await readAndPostLimitEvent(hookInput, "claude-code", true);
     process.exit(0);
 }
-// Codex path. Two things differ from Claude Code:
-//
-// 1. There is no event that fires when a credit/rate-limit block kills a turn.
-//    Codex skips its Stop hook for exactly that turn (measured: every normal
-//    task_complete pairs with a Stop-hook run, the blocked one never does),
-//    and its HookEventName enum has no StopFailure equivalent. So the block is
-//    reported from the developer's NEXT prompt instead — see runCodexLimitSweep.
-// 2. Rollouts run to tens of megabytes and keep growing after the block, so a
-//    fixed tail read loses the marker (in one real 44 MB rollout it sat 1.13 MB
-//    from the end). Scan backwards for it instead.
 async function reportCodexLimitFromFile(config, transcriptPath, sessionId) {
     const hit = (0, codexLimitScan_1.scanCodexRolloutForLimit)(transcriptPath);
     if (!hit)
@@ -180,8 +150,6 @@ async function reportCodexLimitFromFile(config, transcriptPath, sessionId) {
         sessionId: sessionId ?? (0, codexLimitScan_1.sessionIdFromRolloutPath)(transcriptPath),
         transcriptTail: (0, codexLimitScan_1.readTailEndingAt)(transcriptPath, hit.lineEnd),
     });
-    // Tell the prompt sweep this one is done, so it neither re-scans the
-    // rollout nor re-posts an event the server would only deduplicate.
     (0, codexLimitScan_1.recordCodexLimitReported)(transcriptPath, hit.event.at);
     return true;
 }
@@ -212,10 +180,6 @@ async function runCodexLimit(hookInput) {
     process.exit(0);
 }
 const PROMPT_LIMIT_POST_TIMEOUT_MS = 2_500;
-// UserPromptSubmit: the first Codiedev hook that runs after a block, because
-// Codex runs no hook at the block itself. Scans the recent rollouts for any
-// block not yet reported. Cheap in the normal case — a per-file size cache
-// means an unchanged, unblocked rollout costs one statSync.
 async function runCodexLimitSweep(sessionId) {
     const config = (0, utils_1.readConfig)();
     if (!config)
@@ -223,12 +187,7 @@ async function runCodexLimitSweep(sessionId) {
     try {
         const posted = await (0, codexLimitScan_1.sweepCodexLimits)({
             sessionsDir: (0, codexLimitScan_1.codexSessionsDir)(),
-            // A shorter timeout than the default: this is on the user's prompt
-            // clock, and the next prompt retries anything that does not land.
             post: (payload) => (0, limitEventReporter_1.postLimitEvent)(config, payload, PROMPT_LIMIT_POST_TIMEOUT_MS),
-            // Unchanged rollouts cost one statSync and do not spend the read
-            // budget, so in steady state this is nearly free. The module default
-            // covers a cold start; see DEFAULT_MAX_SCANS for why it is not small.
             findOptions: { withinMs: 24 * 3600_000 },
             scanOptions: { maxScanBytes: 4 * 1024 * 1024 },
         });
@@ -250,10 +209,6 @@ async function runCodexLimitSweep(sessionId) {
         });
     }
 }
-// Skip-reason ping: this session is ending WITHOUT a capture, and here's why.
-// Turns silent coverage loss into per-reason buckets on the admin Capture
-// Health panel (patches the session's aiSessionStarts row server-side). Tiny
-// like the sessionStart ping. Best-effort, never throws.
 async function postSessionSkip(config, sessionId, reason) {
     if (!sessionId)
         return;
@@ -261,13 +216,8 @@ async function postSessionSkip(config, sessionId, reason) {
         await postJson(`${config.backendUrl}/api/cli/sessionSkip`, { sessionId, reason, at: Date.now() }, config.token, PING_TIMEOUT_MS);
     }
     catch {
-        /* best-effort */
     }
 }
-// SessionStart: the capture-coverage denominator. Record that a session opened
-// so the backend can later compute captured ÷ started. Deliberately tiny — no
-// transcript read, no git — so it never slows session startup. Best-effort +
-// silent (SessionStart hook output is ignored by Claude Code).
 async function runSessionStart(hookInput, source = "claude-code") {
     const config = (0, utils_1.readConfig)();
     if (!config)
@@ -281,18 +231,11 @@ async function runSessionStart(hookInput, source = "claude-code") {
             }, config.token, PING_TIMEOUT_MS);
         }
         catch {
-            /* best-effort — never block session startup */
         }
     }
     return;
 }
-function postJson(url, body, bearerToken, 
-// Socket timeout. Pass a SMALL value for tiny pings that run on (or near)
-// Claude Code's shutdown clock — a black-holed connection (proxy dropping
-// packets without RST) otherwise hangs the hook until CC kills it. Leave
-// unset for transcript uploads, which legitimately take a while on slow
-// corporate links and already run in detached children with retry.
-timeoutMs) {
+function postJson(url, body, bearerToken, timeoutMs) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
         const data = JSON.stringify(body);
@@ -333,10 +276,7 @@ timeoutMs) {
         req.end();
     });
 }
-// postJson variant that returns the parsed response body — the upload-URL
-// handshake needs the { uploadUrl } the server hands back. No timeout: runs
-// only in detached uploader children, never on the shutdown clock.
-function postJsonForResponse(url, body, bearerToken) {
+function postJsonForResponse(url, body, bearerToken, timeoutMs) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
         const data = JSON.stringify(body);
@@ -370,12 +310,15 @@ function postJsonForResponse(url, body, bearerToken) {
             });
         });
         req.on("error", reject);
+        if (timeoutMs) {
+            req.setTimeout(timeoutMs, () => {
+                req.destroy(new Error(`timeout after ${timeoutMs}ms`));
+            });
+        }
         req.write(data);
         req.end();
     });
 }
-// Raw-bytes POST to a Convex storage upload URL (no auth header — the URL
-// itself is the one-time credential). Returns the parsed { storageId }.
 function postBytes(url, bytes, contentType) {
     return new Promise((resolve, reject) => {
         const parsed = new URL(url);
@@ -411,9 +354,6 @@ function postBytes(url, bytes, contentType) {
         req.end();
     });
 }
-// Short leash for the tiny coverage pings (sessionStart / sessionSkip): they
-// carry a few bytes and must never stall a hook. 3s is generous for a ping
-// and a hard bound for the shutdown clock.
 const PING_TIMEOUT_MS = 3000;
 async function readStdin() {
     return new Promise((resolve, reject) => {
@@ -442,48 +382,24 @@ function resolveMode(arg) {
     return "claude-code";
 }
 async function main() {
-    // Browser sign-in: refresh the access token under the shared lock before
-    // anything reads config (cliSession.ts). A no-op for pasted API tokens and
-    // for tokens with time left; never throws, never prints (hook stdout is
-    // the agent's).
     await (0, cliSession_1.ensureFreshToken)({ configPath: utils_2.CONFIG_PATH }).catch(() => undefined);
-    // Shared upload deps used by both "upload" and "upload-deferred" branches.
-    // Extracted to keep both branches in lockstep — any new dep added here
-    // automatically applies to the deferred path too.
     function makeUploadDeps() {
         return {
             post: postJson,
-            // Direct-to-storage flow for big transcripts (see utils.ts
-            // DIRECT_UPLOAD_THRESHOLD_CHARS): fetch a one-time upload URL, then
-            // POST the raw bytes to it. Keeps ~7MB+ transcripts out of the
-            // backend's 64MB captureSession isolate.
             requestJson: postJsonForResponse,
             uploadBytes: postBytes,
             readFileSync: fs.readFileSync,
             unlinkSync: fs.unlinkSync,
-            // Persist a bumped attempt count on failure so a later sweep retries
-            // (instead of dropping a session on a transient network blip).
             writeFileSync: fs.writeFileSync,
-            // On a successful upload, drop the "last session captured" breadcrumb
-            // that `codiedev doctor` reads to confirm the session landed.
             recordSuccess: (job) => (0, utils_1.writeLastCapture)((0, utils_1.buildLastCaptureRecord)(job, Date.now())),
-            // Write structured outcome lines (ok / ERROR / gave-up) to the
-            // rotating capture log so users and doctor can see why captures fail.
             log: (e) => (0, captureLog_1.appendCaptureLog)(e),
-            // Write per-session upload state so the throttle can defer later
-            // non-final uploads within the same window.
             writeSessionState: utils_1.writeSessionUploadState,
-            // Re-read local config in the uploader so adding an exclusion after a
-            // job was queued still prevents its transcript from leaving the device.
             shouldSkipJob: (job) => {
                 const config = (0, utils_1.readConfig)();
                 return (0, captureExclusions_1.shouldSkipCaptureUploadJob)(job, config);
             },
         };
     }
-    // Detached uploader child (spawned by the capture path below). The job —
-    // including transcript and token — is on disk; no stdin is needed, so handle
-    // this before readStdin() to avoid blocking on the ignored stdin pipe.
     if (process.argv[2] === "upload") {
         const jobFile = process.argv[3];
         if (jobFile) {
@@ -491,10 +407,6 @@ async function main() {
         }
         process.exit(0);
     }
-    // Deferred uploader child (spawned by runCaptureFinish when the per-turn
-    // Stop capture is inside the throttle window). Sleeps for the remaining
-    // delay, then claims the job file (if it hasn't been superseded by a newer
-    // turn) and uploads. No stdin needed — handle before readStdin().
     if (process.argv[2] === "upload-deferred") {
         const jobFile = process.argv[3];
         const delayMs = Math.max(0, Number(process.argv[4]) || 0);
@@ -506,21 +418,11 @@ async function main() {
         }
         process.exit(0);
     }
-    // Detached backup uploader child (spawned by runBackup below). The job file
-    // carries only { root, files }; the child re-reads config from disk. No stdin
-    // needed, so handle it before readStdin() like the capture uploader above.
     if (process.argv[2] === "backup-upload") {
         const { runBackupUpload } = await Promise.resolve().then(() => __importStar(require("./backup/run")));
         await runBackupUpload(process.argv[3]);
         process.exit(0);
     }
-    // Detached capture-finish child (spawned by the SessionEnd capture path
-    // below). The job carries only the raw hook inputs; this child does ALL the
-    // heavy work — read the transcript, parse it, resolve git branch/SHAs (the
-    // per-SHA `git rev-parse` calls that were overrunning CC's shutdown window
-    // on Windows), build the payload, and dispatch the upload. Running here means
-    // none of it is on the SessionEnd shutdown clock, so it can never be
-    // "Hook cancelled". No stdin needed — handle it before readStdin().
     if (process.argv[2] === "capture-finish") {
         const jobFile = process.argv[3];
         if (jobFile) {
@@ -529,31 +431,22 @@ async function main() {
                 await runCaptureFinish(job);
             }
             catch {
-                // best-effort — never throw out of the detached child
             }
             finally {
                 try {
                     fs.unlinkSync(jobFile);
                 }
                 catch {
-                    /* ignore */
                 }
             }
         }
         process.exit(0);
     }
-    // Detached daily self-upgrade of this install (see selfUpdate.ts).
     if (process.argv[2] === "self-update") {
         await (0, selfUpdate_1.runSelfUpdate)(process.argv[1]);
         process.exit(0);
     }
-    // A hook reached directly (not via the stable launcher) means some harness
-    // config predates the launcher: move them all onto it once. Steady state is
-    // every call arriving via the launcher, which skips this entirely.
     const migrated = process.env.CODIEDEV_VIA_LAUNCHER ? [] : (0, utils_1.migrateHooksToLauncher)();
-    // Every harness reaches this point, so one check covers all of them. Right
-    // after a migration, wait for the next call: it arrives via the launcher,
-    // which is what makes a pnpm install safe to upgrade.
     if (migrated.length === 0)
         (0, selfUpdate_1.maybeSpawnSelfUpdate)(process.argv[1]);
     (0, selfUpdate_1.maybeRefreshInstructions)();
@@ -572,22 +465,45 @@ async function main() {
     catch {
         process.exit(0);
     }
-    // Local privacy boundary: every stdin-driven hook mode passes through this
-    // check BEFORE prompt discovery, limit-event tails, SessionStart pings,
-    // backup, self-heal, transcript reads, or detached dispatch. Ignored means
-    // no Codiedev request at all for this session.
-    if ((0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput)) {
+    if (process.argv[2]?.startsWith("security-"))
         process.exit(0);
+    const captureIgnored = (0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput);
+    const promptCommand = process.argv[2] ?? "";
+    if (process.argv[2] === "discover" ||
+        process.argv[2] === "discover-codex" ||
+        process.argv[2] === "discover-codie" ||
+        process.argv[2] === "discover-copilot" ||
+        process.argv[2] === "discover-pi") {
+        const source = promptCommand === "discover-codex"
+            ? "codex"
+            : promptCommand === "discover-codie"
+                ? "codie-harness"
+                : promptCommand === "discover-copilot"
+                    ? "copilot"
+                    : promptCommand === "discover-pi"
+                        ? "pi"
+                        : "claude-code";
+        if (captureIgnored)
+            return;
+        if (source === "codex")
+            await runCodexLimitSweep(hookInput.session_id);
+        if (source === "codex")
+            (0, sync_1.maybeSpawnPackSync)({ connected: Boolean((0, utils_1.readConfig)()), cli: path.join(__dirname, "cli.js") });
+        if (source !== "copilot")
+            await runDiscover(hookInput.prompt);
+        return;
     }
+    if (captureIgnored)
+        process.exit(0);
     if (["session-start-cursor", "backup-cursor", "capture-cursor", "observe-cursor"].includes(process.argv[2])) {
         try {
             (0, cursorLifecycle_1.recordCursorLifecycle)(hookInput, process.argv[2] === "capture-cursor");
         }
-        catch { /* best-effort local evidence */ }
+        catch { }
     }
     if (process.argv[2] === "observe-cursor") {
         process.stdout.write("{}");
-        return; // local evidence only
+        return;
     }
     if (process.argv[2] === "limit-copilot") {
         const config = (0, utils_1.readConfig)();
@@ -596,29 +512,10 @@ async function main() {
             try {
                 await (0, limitEventReporter_1.postLimitEvent)(config, { ...event, source: "copilot", sessionId: hookInput.session_id });
             }
-            catch { /* best-effort */ }
-        }
-        return;
-    }
-    // UserPromptSubmit discovery path — separate from session capture.
-    if (process.argv[2] === "discover" ||
-        process.argv[2] === "discover-codex" ||
-        process.argv[2] === "discover-codie" ||
-        process.argv[2] === "discover-copilot" ||
-        process.argv[2] === "discover-pi") {
-        // A Codex block leaves no hook of its own, so this prompt is the first
-        // chance to report it. Runs before runDiscover, which exits the process.
-        if (process.argv[2] === "discover-codex") {
-            await runCodexLimitSweep(hookInput.session_id);
-            // --- starter packs: Codex has no SessionStart hook; same hourly throttle ---
-            (0, sync_1.maybeSpawnPackSync)({ connected: Boolean((0, utils_1.readConfig)()), cli: path.join(__dirname, "cli.js") });
-            // --- end starter packs ---
+            catch { }
         }
-        if (process.argv[2] !== "discover-copilot")
-            await runDiscover(hookInput.prompt);
         return;
     }
-    // StopFailure (matcher rate_limit): post the rate-limit event.
     if (process.argv[2] === "limit") {
         await runStopFailure(hookInput);
         return;
@@ -627,19 +524,15 @@ async function main() {
         await runCodexLimit(hookInput);
         return;
     }
-    // SessionStart: post the capture-coverage denominator ping. Tiny + fast.
     if (process.argv[2] === "session-start" ||
         process.argv[2] === "session-start-cursor" ||
         process.argv[2] === "session-start-copilot" ||
         process.argv[2] === "session-start-opencode" ||
         process.argv[2] === "session-start-pi") {
-        // --- starter packs: hourly detached `pack install --quiet` + daily nudge ---
         (0, sync_1.maybeSpawnPackSync)({ connected: Boolean((0, utils_1.readConfig)()), cli: path.join(__dirname, "cli.js") });
         const packNag = process.argv[2] === "session-start-opencode" || process.argv[2] === "session-start-pi" ? null : (0, sync_1.packNagLine)();
-        // Claude Code adds SessionStart stdout to the session context.
         if (packNag && process.argv[2] === "session-start")
             process.stdout.write(`${packNag}\n`);
-        // --- end starter packs ---
         await runSessionStart(hookInput, process.argv[2] === "session-start-opencode"
             ? "opencode"
             : process.argv[2] === "session-start-cursor"
@@ -659,11 +552,6 @@ async function main() {
         }
         return;
     }
-    // Self-heal: a user who upgraded the CLI but hasn't re-run `connect` gets
-    // every codiedev hook — INCLUDING SessionEnd→capture, which previously had
-    // no self-heal and could stay stripped forever while SessionStart kept
-    // pinging (the Sonifi "starts arrive, captures never" loss) — re-wired on
-    // their next Stop/SessionEnd. One read + one write, only when missing.
     if ((process.argv[2] ?? "").endsWith("-cursor")) {
         (0, utils_1.ensureCursorCodiedevHooksInstalled)();
     }
@@ -678,9 +566,9 @@ async function main() {
     }
     if (process.argv[2] === "capture-codex")
         (0, utils_1.ensureCodexLimitHookInstalled)();
+    if (/-opencode(?:-final)?$/.test(process.argv[2] ?? ""))
+        (0, utils_1.ensureOpenCodePluginCurrent)();
     const { session_id, transcript_path, cwd, workspace_roots } = hookInput;
-    // Read here, in the process the harness spawned: the detached capture child
-    // is reparented once this exits and can no longer see who launched it.
     const launch = (0, launchContext_1.hookLaunch)(process.argv[2], hookInput, {
         copilotClientName: process.argv[2]?.endsWith("-copilot")
             ? (0, copilotHooks_1.readCopilotWorkspace)(transcript_path).clientName
@@ -689,14 +577,6 @@ async function main() {
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]
         : cwd || process.cwd();
-    // Stop/sessionEnd backup path — separate from session capture and needs no
-    // transcript. Lists changed artifact files in the workspace and dispatches a
-    // detached child that backs them up privately. Best-effort, never blocks.
-    //
-    // Per-turn capture: Stop fires reliably in editor-embedded clients (VS Code
-    // extension) where SessionEnd may never come — the silent zero-capture bug.
-    // Same detached capture-finish child as SessionEnd, marked non-final so the
-    // server renews the session lease instead of summarizing immediately.
     if (process.argv[2] === "backup" || process.argv[2] === "backup-cursor" || process.argv[2] === "backup-copilot" || process.argv[2] === "backup-pi") {
         if (transcript_path && !(0, utils_1.isCodexRolloutPath)(transcript_path)) {
             try {
@@ -713,54 +593,31 @@ async function main() {
                     cwd,
                     workspace_roots,
                     ...(launch ? { launch } : {}),
-                    // non-final: server should renew the lease, not close it yet.
                     final: false,
                 }, process.argv[1], {
                     spawn: child_process_1.spawn,
                     writeFileSync: fs.writeFileSync,
                     openSync: fs.openSync,
                     closeSync: fs.closeSync,
-                    // UNIQUE per dispatch (sid+pid+ts): Stop and SessionEnd children
-                    // each own their input file exclusively — a shared per-session
-                    // name let one child's `finally` unlink eat the other's input
-                    // (lost final:true) or double-dispatch. See finishInputTmpFile.
                     tmpFile: (0, utils_1.finishInputTmpFile)(session_id),
                 });
             }
             catch {
-                // capture is best-effort; never break backup
             }
         }
         const { runBackup } = await Promise.resolve().then(() => __importStar(require("./backup/run")));
         runBackup(workspaceRoot, process.argv[1]);
         process.exit(0);
     }
-    // Capture path (SessionEnd). Do the ABSOLUTE MINIMUM inline so this hook
-    // exits 0 within Claude Code's SessionEnd shutdown window: a cheap config /
-    // transcript guard, then hand ALL the heavy work (transcript read + parse +
-    // per-SHA `git rev-parse` + upload) to a detached `capture-finish` child.
-    // Detaching only the upload (the old #240 fix) left the synchronous parse and
-    // git work on the shutdown clock, which still overran on Windows — where each
-    // subprocess spawn costs ~50-150ms — producing "Hook cancelled" even though
-    // the data still landed. JS can't be interrupted mid-sync-chain, so the work
-    // finished and the upload went through, but CC had already given up waiting.
     const config = (0, utils_1.readConfig)();
     if (!config) {
-        // No config = no token; nothing can be sent, not even a skip ping.
         process.exit(0);
     }
     if (!transcript_path) {
-        // Nothing to capture — but say so, instead of leaving a start ping with
-        // no matching capture (silent coverage loss). One tiny POST; the rare
-        // no-transcript case has no other work on the shutdown clock.
         await postSessionSkip(config, session_id, "no-transcript-path");
         process.exit(0);
     }
     try {
-        // "codiedev-finish-" prefix (NOT "codiedev-capture-") so the sweep regex
-        // /^codiedev-capture-.*\.json$/ never mistakes a finish-input file for an
-        // upload job. UNIQUE per dispatch (sid+pid+ts) so a concurrent Stop-hook
-        // child's `finally` unlink can never eat this input (lost final:true).
         const jobFile = (0, utils_1.finishInputTmpFile)(session_id);
         (0, utils_1.dispatchCaptureFinish)({
             mode: process.argv[2] ?? "capture",
@@ -769,9 +626,6 @@ async function main() {
             cwd,
             workspace_roots,
             ...(launch ? { launch } : {}),
-            // final:true for real SessionEnd signals (Claude Code, Cursor, Copilot).
-            // Codex routes its per-turn Stop hook through "capture-codex" —
-            // final:true there would close the server lease every turn.
             final: (0, utils_1.resolveCaptureFinal)(process.argv[2]),
         }, process.argv[1], { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile: jobFile, openSync: fs.openSync, closeSync: fs.closeSync });
     }
@@ -780,19 +634,10 @@ async function main() {
     }
     process.exit(0);
 }
-// Runs inside the detached `capture-finish` child spawned by the SessionEnd
-// hook above. This is everything that used to run inline in main(): read the
-// transcript, resolve the repo, parse stats/usage/steering, resolve the git
-// branch + authored SHAs (the per-SHA `git rev-parse` calls that overran the
-// shutdown window on Windows), build the payload, and fire the upload from a
-// further-detached uploader. Running here means none of it is on the SessionEnd
-// shutdown clock, so it can never be "Hook cancelled". Best-effort throughout.
 async function runCaptureFinish(input) {
     const config = (0, utils_1.readConfig)();
     if (!config)
         return;
-    // Re-check in the detached child: the user may have added an exclusion
-    // after the parent hook dispatched this job but before it started.
     if ((0, captureExclusions_1.shouldIgnoreCaptureInput)(config, input)) {
         (0, captureLog_1.appendCaptureLog)({
             stage: "capture-finish",
@@ -807,8 +652,6 @@ async function runCaptureFinish(input) {
         await postSessionSkip(config, session_id, "no-transcript-path");
         return;
     }
-    // Log that this child has started processing — the first diagnostic proof
-    // that the detached capture-finish child actually ran (visible in doctor).
     (0, captureLog_1.appendCaptureLog)({ stage: "capture-finish", sessionId: session_id, outcome: "start" });
     try {
         await runCaptureFinishInner(input, config, session_id, transcript_path, cwd, workspace_roots);
@@ -824,10 +667,6 @@ async function runCaptureFinish(input) {
 }
 async function runCaptureFinishInner(input, config, session_id, transcript_path, cwd, workspace_roots) {
     const mode = resolveMode(input.mode);
-    // Desktop transcripts (opencode SDK {info,parts}[] dumps) are byte-identical
-    // to opencode's, so every parser below EXCEPT parseUsage treats desktop
-    // exactly as opencode via this mapping. parseUsage is the one exception —
-    // see the rawTranscriptContent note below.
     const parserMode = mode === "desktop" ? "opencode" : mode;
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]
@@ -836,9 +675,6 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     let transcriptContent;
     try {
         transcriptContent = fs.readFileSync(transcript_path, "utf8");
-        // Copilot writes session.shutdown (the token totals) just AFTER sessionEnd
-        // fires. This child is detached, so wait briefly for it on the final
-        // capture. VS Code may never write one; then tokens stay unreported.
         if (mode === "copilot" && input.final === true && !(0, copilotHooks_1.hasCopilotShutdown)(transcriptContent)) {
             for (let waited = 0; waited < COPILOT_SHUTDOWN_WAIT_MS && !(0, copilotHooks_1.hasCopilotShutdown)(transcriptContent); waited += 250) {
                 await new Promise((resolve) => setTimeout(resolve, 250));
@@ -847,9 +683,6 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         }
     }
     catch (err) {
-        // ENOENT → "no-transcript" (phantom desktop-app helper session, excluded
-        // from coverage server-side); anything else → "transcript-unreadable:<code>"
-        // (real transcript, read failed — a genuine, diagnosable loss).
         const reason = (0, utils_1.transcriptReadSkipReason)(err);
         (0, captureLog_1.appendCaptureLog)({
             stage: "capture-finish",
@@ -862,11 +695,6 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         }
         return;
     }
-    // Snapshot the RAW transcript before normalization below flattens it to
-    // Claude Code's newline-JSONL shape — that flattening drops info.cost /
-    // info.providerID, which desktop's parseUsage (below) needs and opencode's
-    // doesn't. Every other mode leaves transcriptContent untouched here, so this
-    // is a no-op for them.
     const rawTranscriptContent = transcriptContent;
     let copilotSubagents;
     const copilotWorkspace = mode === "copilot" ? (0, copilotHooks_1.readCopilotWorkspace)(transcript_path) : {};
@@ -891,39 +719,22 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         try {
             await (0, limitEventReporter_1.reportTranscriptLimitEvent)({ config, source: mode, sessionId: session_id, transcript: transcriptContent });
         }
-        catch { /* capture proceeds if limit reporting fails */ }
+        catch { }
     }
-    // Resolve repo URL. Codex embeds it in session_meta; CC and Cursor both
-    // need the git remote of the workspace.
     let remoteUrl = null;
     if (parserMode === "codex") {
         remoteUrl = (0, utils_1.extractCodexRepoUrl)(transcriptContent);
     }
-    // The worktrees the session actually wrote to — resolved up front because
-    // they both anchor the branch/sha join keys below AND back-fill the repo tag
-    // when the launch dir is a multi-repo WORKSPACE root (a parent folder of
-    // several cloned repos) that has no remote of its own.
     const captureDirs = (0, utils_1.resolveCaptureDirs)(transcriptContent, workspaceRoot);
     if (!remoteUrl) {
         remoteUrl = (0, utils_1.resolveCaptureRemoteUrl)(workspaceRoot, captureDirs);
     }
-    // Capture-first: the transcript is the asset; the repo is just a tag. We do
-    // NOT bail when `remoteUrl` is null — that previously dropped EVERY session
-    // for users whose workspace couldn't resolve a remote (no git binary on lean
-    // Alpine images, no `origin`, or a submodule whose parent .git isn't mounted),
-    // with no error and a green `doctor`. Upload regardless; the backend accepts
-    // an unmatched capture (repoId null) and surfaces it for triage.
-    //
-    // Best-effort local match — backend re-resolves from `remoteUrl` against the
-    // company's current repo list, so a stale/empty local cache doesn't matter.
+    if (remoteUrl)
+        remoteUrl = (0, utils_1.stripRepoUrlCredentials)(remoteUrl);
     const matchedRepo = remoteUrl ? (0, utils_1.matchRepo)(remoteUrl, config.repos) : null;
     const stats = parserMode === "codex"
         ? (0, utils_1.parseCodexStats)(transcriptContent)
         : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
-    // Cursor can emit duplicate lifecycle notifications while one transcript
-    // path is still byte-empty. Never use parsed message count here: Cursor's
-    // private JSONL shape can evolve independently, and parser drift must not
-    // silently discard a real non-empty session.
     const emptyReason = parserMode === "cursor" && (0, cursorHooks_1.isCursorTranscriptEmpty)(rawTranscriptContent)
         ? "empty-cursor-transcript"
         : parserMode === "copilot" && (0, copilotHooks_1.isCopilotTranscriptEmpty)(rawTranscriptContent)
@@ -938,52 +749,23 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
             outcome: "skip",
             detail: emptyReason,
         });
-        // A non-final stop snapshot is only a backup; reporting it as a skipped
-        // session would close server-side coverage while the session is alive.
         if ((0, utils_1.shouldReportCaptureSkip)(input.final)) {
             await postSessionSkip(config, session_id, emptyReason);
         }
         return;
     }
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
-    // Session→merge join keys: the branch + HEAD sha the work happened on. Matched
-    // server-side against a merged MR/PR's source_branch / commits for AI attribution.
-    // Capture from the worktree the agent actually worked in (the launch dir stays
-    // on main/detached when work happens in a `git worktree`), not workspaceRoot.
-    // One session can touch several worktrees (→ several PRs); capture EVERY
-    // worktree's branch+sha so all the resulting PRs attribute. branch/headSha
-    // remain the primary (most-recent) values for back-compat.
     const keys = (0, utils_1.collectCaptureKeys)(captureDirs);
     const gitRefs = (0, utils_1.collectCaptureGitRefs)(captureDirs);
-    // Union the worktree-dir branches with the branches the agent actually
-    // committed/pushed to (parsed from the transcript's git output). Like the
-    // SHAs below, these are independent of end-of-session filesystem state, so
-    // they rescue branch-join when the worktree was REMOVED before SessionEnd
-    // (the dominant miss: dir-resolution falls back to the parent's branch, never
-    // the `worktree-<name>` one the PR was opened from). Indexed server-side under
-    // every branch in the array, so the worktree's PR attributes regardless.
     const authoredBranches = (0, utils_1.parseAuthoredBranches)(transcriptContent);
-    // Copilot records the branch it started on in workspace.yaml.
     const recordedBranches = copilotWorkspace.branch ? [copilotWorkspace.branch] : [];
     const branches = [...new Set([...keys.branches, ...authoredBranches, ...recordedBranches])];
     const branch = keys.branch ?? branches[0] ?? null;
-    // Union the worktree HEAD shas with the SHAs the agent actually committed/
-    // pushed (parsed from the transcript's git output, resolved via the shared
-    // object store). The authored shas are independent of end-of-session
-    // filesystem state, so they rescue attribution when a worktree is stale/gone.
     const authoredShas = (0, utils_1.parseAuthoredShas)(transcriptContent, workspaceRoot);
     const headShas = [...new Set([...keys.headShas, ...authoredShas])];
     const headSha = keys.headSha ?? headShas[0] ?? null;
     const pullRequestUrls = (0, utils_1.parsePullRequestUrls)(transcriptContent);
-    // Cost/velocity/steering signals parsed straight from the transcript we're
-    // already holding — no extra hooks, no extra git/process calls. parseUsage
-    // keeps the literal mode (it has its own desktop parser) and reads the RAW
-    // pre-normalization content for desktop; parseSteering routes through
-    // parserMode like the parsers above.
     const usage = (0, utils_1.parseUsage)(mode === "desktop" ? rawTranscriptContent : transcriptContent, mode);
-    // Claude Code subagents: their transcripts sit beside this one and are part
-    // of this session's work (skill runs, tool calls, tokens). Folded in here,
-    // never uploaded as sessions of their own.
     const subagents = mode === "claude-code"
         ? (0, subagents_1.readSubagentTranscripts)(transcript_path, session_id)
         : { contents: [], count: 0, truncated: false };
@@ -1029,22 +811,15 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         sessionStartedAt,
         interruptCount: steering.interrupts,
         rejectionCount: steering.rejections,
-        // Carry the final flag into the HTTP body — the server uses it to decide
-        // whether to close the session lease (true) or renew it (false/absent).
         final: input.final,
-        // Desktop-only measured spend (undefined for every other source).
         costUsd: usage.costUsd,
     });
-    // Throttle decision: final captures go immediately; non-final (per-turn Stop)
-    // are deferred if we uploaded this session recently, to avoid per-turn churn.
     const uploadState = (0, utils_1.readSessionUploadState)(session_id ?? "");
     const decision = (0, utils_1.decideDispatch)({
         final: input.final === true,
         lastUploadAt: uploadState?.lastUploadAt ?? null,
         now: Date.now(),
     });
-    // Log capture-finish outcome with dispatch context so doctor can see whether
-    // the upload went immediately or was deferred (and by how much).
     (0, captureLog_1.appendCaptureLog)({
         stage: "capture-finish",
         sessionId: session_id,
@@ -1053,11 +828,6 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
             ? `dispatch=deferred delayMs=${decision.delayMs} final=${input.final === true} repo=${remoteUrl ?? "-"} branch=${branch ?? "-"} msgs=${stats.messageCount}`
             : `dispatch=immediate final=${input.final === true} repo=${remoteUrl ?? "-"} branch=${branch ?? "-"} msgs=${stats.messageCount}`,
     });
-    // Fire the upload from a further-detached child. We're already off the
-    // shutdown clock here, but reusing dispatchCaptureDetached keeps the upload
-    // retry + last-capture breadcrumb logic (runCaptureUpload) intact verbatim.
-    // Per-session job file: one file per session; newer turns overwrite it,
-    // which is the "supersede" mechanism for the deferred path.
     try {
         const hookScriptPath = process.argv[1];
         const tmpFile = (0, utils_1.captureUploadTmpFile)(session_id, decision.mode);
@@ -1068,20 +838,8 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
                 body: payload,
                 scopePaths,
             }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync });
-            // Persist the immediate payload before removing the older scheduled
-            // snapshot. Every immediate dispatch supersedes a sleeping deferred job.
             if (session_id)
                 (0, utils_1.cancelDeferredCaptureUpload)(session_id);
-            // Retry any earlier capture jobs that failed to upload (transient network
-            // blips), excluding the one we just dispatched. Best-effort, detached.
-            // Skip the sweep on deferred path — the deferred child will handle uploading.
-            //
-            // Orphan pings are COLLECTED and awaited below: this child process calls
-            // process.exit(0) as soon as runCaptureFinish resolves, so a
-            // fire-and-forget POST here would be killed mid-flight — after the
-            // orphan file was already unlinked, i.e. the loss would stay invisible
-            // forever. The await is off the shutdown clock (detached child) and
-            // bounded by PING_TIMEOUT_MS.
             const orphanPings = [];
             (0, utils_1.sweepPendingCaptures)({
                 dir: os.tmpdir(),
@@ -1093,9 +851,6 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
                 exclude: tmpFile,
                 openSync: fs.openSync,
                 closeSync: fs.closeSync,
-                // Orphaned finish-inputs (capture-finish child died before writing an
-                // upload job): unrecoverable payload, but report the loss so it lands
-                // as a skip-reason instead of a silent coverage hole.
                 unlinkSync: fs.unlinkSync,
                 reportOrphan: (sid) => {
                     orphanPings.push(postSessionSkip(config, sid, "finish-orphaned"));
@@ -1104,9 +859,6 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
             await Promise.all(orphanPings);
         }
         else {
-            // Deferred: write the job file (newer turns overwrite = supersede), then
-            // spawn the deferred-upload child which will sleep, claim, and upload.
-            // Same stdio/fd-hygiene contract as dispatchCaptureDetached.
             (0, utils_1.dispatchDeferredUpload)({
                 url: `${config.backendUrl}/api/captureSession`,
                 token: config.token,
@@ -1119,9 +871,7 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         process.stderr.write(`[codiedev-hook] Warning: Failed to dispatch session capture — ${err.message}\n`);
     }
 }
-// How long the final Copilot capture waits for session.shutdown.
 const COPILOT_SHUTDOWN_WAIT_MS = 5000;
-/** Copilot fleet sub-agents run inside the one events.jsonl. */
 function withCopilotSubagents(signals, subagents) {
     return subagents ? { ...signals, subagents } : signals;
 }