codiedev 0.10.0-beta.4 → 0.10.0-beta.5

package/dist/utils.js

@@ -53,6 +53,7 @@ exports.parseAuthoredBranches = parseAuthoredBranches;
 exports.parseAuthoredShas = parseAuthoredShas;
 exports.getGitBranch = getGitBranch;
 exports.getGitHeadSha = getGitHeadSha;
+exports.stripRepoUrlCredentials = stripRepoUrlCredentials;
 exports.buildCapturePayload = buildCapturePayload;
 exports.hashToken = hashToken;
 exports.extractHookNodePath = extractHookNodePath;
@@ -60,6 +61,7 @@ exports.resetStableNodeCacheForTests = resetStableNodeCacheForTests;
 exports.claudeCodeInstalled = claudeCodeInstalled;
 exports.codexInstalled = codexInstalled;
 exports.cursorInstalled = cursorInstalled;
+exports.copilotInstalled = copilotInstalled;
 exports.openCodeInstalled = openCodeInstalled;
 exports.installOpenCodeCapturePlugin = installOpenCodeCapturePlugin;
 exports.vscodeCopilotInstalled = vscodeCopilotInstalled;
@@ -70,9 +72,13 @@ exports.ensureDiscoveryHookInstalled = ensureDiscoveryHookInstalled;
 exports.ensureBackupHookInstalled = ensureBackupHookInstalled;
 exports.ensureLimitHookInstalled = ensureLimitHookInstalled;
 exports.ensureAllCodiedevHooksInstalled = ensureAllCodiedevHooksInstalled;
+exports.hasDirectHookPath = hasDirectHookPath;
+exports.migrateHooksToLauncher = migrateHooksToLauncher;
 exports.ensureSessionStartHookInstalled = ensureSessionStartHookInstalled;
 exports.installClaudeCodeInstructions = installClaudeCodeInstructions;
 exports.installCodexInstructions = installCodexInstructions;
+exports.copilotInstructionsPath = copilotInstructionsPath;
+exports.installCopilotInstructions = installCopilotInstructions;
 exports.installCursorInstructions = installCursorInstructions;
 exports.installClaudeCodeMcp = installClaudeCodeMcp;
 exports.installCursorMcp = installCursorMcp;
@@ -85,6 +91,9 @@ exports.installCodexMcp = installCodexMcp;
 exports.installCodexHook = installCodexHook;
 exports.ensureCodexLimitHookInstalled = ensureCodexLimitHookInstalled;
 exports.installCursorHook = installCursorHook;
+exports.copilotHooksPath = copilotHooksPath;
+exports.installCopilotHook = installCopilotHook;
+exports.ensureCopilotCodiedevHooksInstalled = ensureCopilotCodiedevHooksInstalled;
 exports.ensureCursorCodiedevHooksInstalled = ensureCursorCodiedevHooksInstalled;
 exports.parseClaudeSteering = parseClaudeSteering;
 exports.parseCodexSteering = parseCodexSteering;
@@ -113,8 +122,10 @@ exports.readLastCapture = readLastCapture;
 exports.runCaptureUpload = runCaptureUpload;
 exports.runDeferredUpload = runDeferredUpload;
 exports.transcriptReadSkipReason = transcriptReadSkipReason;
+exports.isCodexRolloutPath = isCodexRolloutPath;
 exports.shouldReportCaptureSkip = shouldReportCaptureSkip;
 const fs = __importStar(require("fs"));
+const transcriptModels_1 = require("./transcriptModels");
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
@@ -123,6 +134,11 @@ const captureLog_1 = require("./captureLog");
 const configDir_1 = require("./configDir");
 Object.defineProperty(exports, "codiedevStateDir", { enumerable: true, get: function () { return configDir_1.codiedevStateDir; } });
 const codexHookTrust_1 = require("./codexHookTrust");
+const launcher_1 = require("./launcher");
+const teamSkillContext_1 = require("./teamSkillContext");
+const nativeSteering_1 = require("./nativeSteering");
+const copilotHooks_1 = require("./copilotHooks");
+const harnessDirs_1 = require("./harnessDirs");
 const CONFIG_DIR = (0, configDir_1.codiedevStateDir)();
 exports.CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
 function readConfig() {
@@ -139,7 +155,6 @@ function readConfig() {
 function writeConfig(config) {
     writeConfigAtPath(config, CONFIG_DIR, exports.CONFIG_PATH);
 }
-/** Exported for permission-focused tests; normal callers use writeConfig. */
 function writeConfigAtPath(config, configDir, configPath) {
     if (!fs.existsSync(configDir)) {
         fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
@@ -148,12 +163,8 @@ function writeConfigAtPath(config, configDir, configPath) {
         encoding: "utf8",
         mode: 0o600,
     });
-    // writeFile's mode does not replace permissions on a pre-existing file.
     fs.chmodSync(configPath, 0o600);
 }
-// Parse a remote URL out of git-config INI text WITHOUT invoking git. Prefers
-// the "origin" remote; falls back to the first remote found. Returns null if
-// there are no remote sections.
 function parseGitRemoteFromConfig(configText) {
     const remotes = {};
     let current = null;
@@ -165,8 +176,6 @@ function parseGitRemoteFromConfig(configText) {
             continue;
         }
         if (line.startsWith("[")) {
-            // Any other section header ends the current remote context, so a
-            // `url =` under e.g. [core] or [some-section] is never mistaken for one.
             current = null;
             continue;
         }
@@ -182,13 +191,8 @@ function parseGitRemoteFromConfig(configText) {
     const first = Object.values(remotes)[0];
     return first ?? null;
 }
-// Locate the git directory for `startDir`, walking up parent directories.
-// Handles a `.git` directory (normal repo), a `.git` FILE containing
-// `gitdir: <path>` (submodules, some devcontainer/worktree layouts), and stops
-// at the filesystem root. Returns the resolved git dir path, or null.
 function resolveGitDir(startDir) {
     let dir = path.resolve(startDir);
-    // eslint-disable-next-line no-constant-condition
     while (true) {
         const dotGit = path.join(dir, ".git");
         try {
@@ -204,7 +208,6 @@ function resolveGitDir(startDir) {
             }
         }
         catch {
-            // No .git here — keep walking up.
         }
         const parent = path.dirname(dir);
         if (parent === dir)
@@ -212,9 +215,6 @@ function resolveGitDir(startDir) {
         dir = parent;
     }
 }
-// Ordered list of config files that may hold the remotes for a git dir. Linked
-// worktrees keep their remotes in the COMMON (main) git dir, pointed at by a
-// `commondir` file, so we check that first, then the git dir's own config.
 function gitConfigCandidates(gitDir) {
     const candidates = [];
     try {
@@ -226,15 +226,10 @@ function gitConfigCandidates(gitDir) {
         }
     }
     catch {
-        // ignore — fall through to the plain config below
     }
     candidates.push(path.join(gitDir, "config"));
     return candidates;
 }
-// Resolve a repo's remote URL by reading .git/config directly — no `git`
-// binary required. This is the primary path so lean container images (Alpine
-// devcontainers without git) still capture sessions instead of silently
-// dropping them.
 function readGitRemoteFromConfig(startDir) {
     const gitDir = resolveGitDir(startDir);
     if (!gitDir)
@@ -246,20 +241,14 @@ function readGitRemoteFromConfig(startDir) {
                 return url;
         }
         catch {
-            // try the next candidate
         }
     }
     return null;
 }
 function getGitRemoteUrl(cwd) {
-    // Primary: read .git/config directly. Works even when the `git` binary is
-    // absent (lean Alpine/devcontainer images), which previously made the
-    // SessionEnd hook silently drop every session.
     const fromConfig = readGitRemoteFromConfig(cwd);
     if (fromConfig)
         return fromConfig;
-    // Fallback: ask git itself, for setups the direct read doesn't cover
-    // (insteadOf rewrites, includeIf'd remotes, unusual gitdir indirection).
     try {
         const url = (0, child_process_1.execSync)("git remote get-url origin", {
             cwd,
@@ -273,13 +262,6 @@ function getGitRemoteUrl(cwd) {
         return null;
     }
 }
-// Resolve the remote that tags the session's repo. The workspace root is the
-// primary source, but when the session was launched at a multi-repo WORKSPACE
-// root — a parent folder holding several cloned repos with `.devcontainer/` at
-// the top, which is not itself a git repo — the root has no remote, and tagging
-// used to silently produce repo-UNMATCHED sessions. Fall back to the worktrees
-// the session actually wrote to (resolveCaptureDirs order: most-recent first),
-// so the session tags the repo the work happened in.
 function resolveCaptureRemoteUrl(workspaceRoot, captureDirs, getRemote = getGitRemoteUrl) {
     const fromRoot = getRemote(workspaceRoot);
     if (fromRoot)
@@ -292,19 +274,14 @@ function resolveCaptureRemoteUrl(workspaceRoot, captureDirs, getRemote = getGitR
     return null;
 }
 function normalizeRepoUrl(url) {
-    // Normalize SSH (git@github.com:org/repo.git) and HTTPS (https://github.com/org/repo.git)
-    // to a comparable form: github.com/org/repo
     let normalized = url.trim();
-    // Strip trailing .git
     if (normalized.endsWith(".git")) {
         normalized = normalized.slice(0, -4);
     }
-    // Handle SSH format: git@github.com:org/repo → github.com/org/repo
     const sshMatch = normalized.match(/^git@([^:]+):(.+)$/);
     if (sshMatch) {
         return `${sshMatch[1]}/${sshMatch[2]}`;
     }
-    // Handle HTTPS format: https://github.com/org/repo → github.com/org/repo
     const httpsMatch = normalized.match(/^https?:\/\/(.+)$/);
     if (httpsMatch) {
         return httpsMatch[1];
@@ -316,11 +293,6 @@ function matchRepo(remoteUrl, repos) {
     for (const repo of repos) {
         const normalizedUrl = normalizeRepoUrl(repo.url);
         const normalizedName = repo.fullName.toLowerCase();
-        // Match the REMOTE against this repo: exact normalized URL, or the remote
-        // ending with this repo's full path (`owner/.../name`). Both are anchored to
-        // `normalizedRemote` — never compare a repo to ITSELF (the old third clause
-        // `normalizedUrl.endsWith('/'+name)` was remote-independent and returned the
-        // first repo for every session, collapsing all repos for multi-repo orgs).
         if (normalizedRemote === normalizedUrl ||
             normalizedRemote.endsWith(`/${normalizedName}`)) {
             return repo;
@@ -328,38 +300,11 @@ function matchRepo(remoteUrl, repos) {
     }
     return null;
 }
-// Resolve the directory to capture git branch/headSha from.
-//
-// The session→merge join keys must describe the work that becomes the PR. But
-// agents do that work in a `git worktree` (.claude/worktrees/<name> or a
-// sibling dir) on a feature branch, while the session's LAUNCH dir
-// (workspaceRoot) stays on main/detached — a feature branch checked out in a
-// worktree cannot also be checked out in the launch dir. Capturing from the
-// launch dir therefore recorded main/null, matching no PR (velocity starved).
-//
-// Fix: scan the transcript for the cwd the agent actually worked in — the
-// most-recent one that is a SEPARATE worktree (its resolved gitdir differs from
-// the launch root's; a worktree's gitdir is .git/worktrees/<name>, while the
-// root and its subdirs share .git). Fall back to the launch root when no
-// separate worktree was used (work done directly in the repo).
 function resolveCaptureDir(transcriptContent, workspaceRoot) {
     return resolveCaptureDirs(transcriptContent, workspaceRoot)[0] ?? workspaceRoot;
 }
-// Plural: EVERY separate worktree the session touched, most-recent first. One
-// session can produce multiple PRs (work across several worktrees, each on its
-// own feature branch); capturing every worktree's branch+sha lets all of those
-// PRs attribute. Falls back to [workspaceRoot] when no separate worktree was
-// used (work done directly in the repo).
 function resolveCaptureDirs(transcriptContent, workspaceRoot) {
     const rootGitDir = resolveGitDir(workspaceRoot);
-    // Collect the folders the session WROTE to (not merely referenced), in order:
-    //   - the session cwd
-    //   - `git -C <path>` of MUTATING git commands (commit/push/add/...) — NOT
-    //     read-only ones (log/status/diff), which would falsely credit a worktree
-    //     the session only inspected
-    //   - the dir of files edited via Edit/Write/NotebookEdit — NOT Read/Grep/Glob
-    // Reading/inspecting another worktree must not attribute its PRs to this
-    // session (that also corrupts the even cost-split).
     const candidates = [];
     const add = (p) => {
         if (!p)
@@ -374,7 +319,6 @@ function resolveCaptureDirs(transcriptContent, workspaceRoot) {
             entry = JSON.parse(line);
         }
         catch {
-            // partial/non-JSON line — best-effort: only mutating git -C, never files.
             for (const d of mutatingGitCDirs(line))
                 add(d);
             continue;
@@ -397,10 +341,6 @@ function resolveCaptureDirs(transcriptContent, workspaceRoot) {
             }
         }
     }
-    // Walk most-recent first; one entry per distinct worktree gitdir (a worktree's
-    // gitdir is .git/worktrees/<name>; the root and its subdirs share .git, so
-    // they're excluded as not-separate). Normalize each to its canonical worktree
-    // root so a file path / subdir resolves to the worktree dir itself.
     const out = [];
     const seenGitDirs = new Set();
     for (let i = candidates.length - 1; i >= 0; i--) {
@@ -414,10 +354,6 @@ function resolveCaptureDirs(transcriptContent, workspaceRoot) {
     }
     return out.length > 0 ? out : [workspaceRoot];
 }
-// Extract the `-C <path>` targets of MUTATING git commands in a shell string.
-// Splits on command separators and only takes a sub-command's -C path when that
-// sub-command runs a state-changing git verb — so `git -C x log` is ignored but
-// `git -C x commit`/`push`/`add` count.
 const MUTATING_GIT = /\b(?:commit|push|add|checkout|switch|merge|rebase|reset|restore|rm|mv|stash|apply|cherry-pick|am|tag|worktree)\b/;
 function mutatingGitCDirs(command) {
     const out = [];
@@ -431,8 +367,6 @@ function mutatingGitCDirs(command) {
     }
     return out;
 }
-// A linked worktree's gitdir (`.git/worktrees/<name>`) holds a `gitdir` file
-// pointing at the worktree's own `.git` file; its parent is the worktree root.
 function worktreeRootFromGitDir(gitDir) {
     try {
         const p = fs.readFileSync(path.join(gitDir, "gitdir"), "utf8").trim();
@@ -442,10 +376,6 @@ function worktreeRootFromGitDir(gitDir) {
         return null;
     }
 }
-// Turn the worktrees a session touched into the upload join keys: dedup'd
-// branch + headSha arrays (so one session → many PRs all attribute), plus the
-// primary single values (first entry) for back-compat with servers that read
-// only branch/headSha. getBranch/getSha are injectable for testing.
 function collectCaptureKeys(dirs, getBranch = getGitBranch, getSha = getGitHeadSha) {
     const branches = [];
     const headShas = [];
@@ -478,19 +408,12 @@ function collectCaptureGitRefs(dirs, getRemote = getGitRemoteUrl, getBranch = ge
     }
     return out;
 }
-// Exact PR/MR URLs are the strongest provenance the transcript can provide.
-// Both `gh pr create` and `glab mr create` print one, and the OpenCode capture
-// is normalized through the same parser as Claude Code. A direct URL survives
-// branch deletion, squash/rebase, cherry-picks, and SessionEnd happening after
-// the PR was opened.
 function parsePullRequestUrls(transcriptContent) {
     const out = [];
     const createToolIds = new Set();
     const isCreateCommand = (command) => {
         if (typeof command !== "string")
             return false;
-        // A combined `gh pr view || gh pr create` result is ambiguous: when the PR
-        // already exists, the VIEW half prints its URL and CREATE never runs.
         if (/\b(?:gh\s+pr\s+(?:view|list|status)|glab\s+mr\s+(?:view|list))\b/i.test(command)) {
             return false;
         }
@@ -514,7 +437,6 @@ function parsePullRequestUrls(transcriptContent) {
                     out.push(canonical);
             }
             catch {
-                // Malformed tool output is ignored; capture remains best-effort.
             }
         }
     };
@@ -552,7 +474,6 @@ function parsePullRequestUrls(transcriptContent) {
                     }
                 }
             }
-            // Codex function calls carry arguments as serialized JSON.
             if (entry?.type === "response_item"
                 && entry?.payload?.type === "function_call"
                 && typeof entry.payload.call_id === "string") {
@@ -561,7 +482,7 @@ function parsePullRequestUrls(transcriptContent) {
                     try {
                         args = JSON.parse(args);
                     }
-                    catch { /* leave as string */ }
+                    catch { }
                 }
                 if (isCreateCommand(args?.cmd ?? args?.command ?? args)) {
                     createToolIds.add(entry.payload.call_id);
@@ -569,13 +490,8 @@ function parsePullRequestUrls(transcriptContent) {
             }
         }
         catch {
-            // Never regex the raw line: prompts and assistant prose can contain a PR
-            // URL, but only actual tool output is provenance.
         }
     }
-    // Second pass: a URL is proof only when it came from the result of the
-    // specific gh/glab CREATE call above. `gh pr view/list` also prints URLs and
-    // must never claim somebody else's already-existing PR for this session.
     for (const entry of entries) {
         const content = entry?.message?.content;
         if (Array.isArray(content)) {
@@ -597,17 +513,11 @@ function parsePullRequestUrls(transcriptContent) {
     }
     return out;
 }
-// Pull the commit SHAs the agent actually authored/pushed straight out of the
-// transcript's git command OUTPUT — independent of end-of-session filesystem
-// state. Catches: commit output "[branch 4c4e790]", push ranges
-// "abc1234..def5678", and bare 40-hex (rev-parse). This is the signal that
-// rescues attribution when the worktree's HEAD is stale or the worktree is gone
-// at SessionEnd (pruned worktree, submodule pointer bump).
 function extractShaTokens(transcriptContent) {
     const out = new Set();
-    const commitRe = /\[[^\]\n]*?\b([0-9a-f]{7,40})\]/g; // [branch <sha>]
-    const rangeRe = /\b([0-9a-f]{7,40})\.\.([0-9a-f]{7,40})\b/g; // <sha>..<sha>
-    const fullRe = /\b([0-9a-f]{40})\b/g; // bare full sha (rev-parse)
+    const commitRe = /\[[^\]\n]*?\b([0-9a-f]{7,40})\]/g;
+    const rangeRe = /\b([0-9a-f]{7,40})\.\.([0-9a-f]{7,40})\b/g;
+    const fullRe = /\b([0-9a-f]{40})\b/g;
     let m;
     while ((m = commitRe.exec(transcriptContent)))
         out.add(m[1].toLowerCase());
@@ -619,17 +529,6 @@ function extractShaTokens(transcriptContent) {
         out.add(m[1].toLowerCase());
     return [...out];
 }
-// Pull the branch NAMES the agent actually committed/pushed to, straight out of
-// the transcript's git OUTPUT — the branch companion to extractShaTokens. This
-// is the rescue for the dominant capture miss: the agent works in a
-// `.claude/worktrees/<name>` worktree on branch `worktree-<name>`, commits/pushes
-// /PRs, then the worktree is REMOVED before SessionEnd. resolveCaptureDirs then
-// can't resolve the (deleted) worktree's git dir and falls back to the parent
-// dir, capturing the PARENT's branch — so the PR's sourceBranch matches no
-// captured session. The branch name survives in the commit line `[branch sha]`
-// and the push ref `<local> -> <remote>`, both of which prove authorship (a
-// read-only `git log` emits neither), so this stays mutation-scoped like the
-// SHA parse. Pure string parse — no filesystem, no server change.
 function parseAuthoredBranches(transcriptContent) {
     const out = [];
     const add = (b) => {
@@ -642,25 +541,12 @@ function parseAuthoredBranches(transcriptContent) {
         while ((m = re.exec(text)))
             add(m[1]);
     };
-    // From git OUTPUT (proof the work shipped on that branch):
-    //   commit: `[<branch> [(root-commit) ]<sha>]`. `[^\]\s]+` rejects "detached
-    //     HEAD" (the space breaks the token before the sha can match).
-    //   push:   `<sha>..<sha>  <local> -> <remote>` (updated) / `[new branch]
-    //     <local> -> <remote>` (created). Anchor on the push-ref shape so prose
-    //     arrows ("a -> b") don't match; capture the remote (= the PR
-    //     sourceBranch). `[^\s"]+` stops at the JSON string boundary.
     const commitRe = /\[([^\]\s]+)(?:\s+\(root-commit\))?\s+[0-9a-f]{7,40}\]/g;
     const pushRe = /(?:[0-9a-f]{7,40}\.\.[0-9a-f]{7,40}|\[new branch\])\s+\S+\s+->\s+([^\s"]+)/g;
-    // From CREATE commands (rescues work committed/pushed entirely OUTSIDE the
-    // session): only `checkout -b`/`switch -c` (branch CREATION — not plain
-    // checkout/switch navigation), and only from real Bash tool_use inputs, never
-    // prose/output, so a suggested command in assistant text can't false-match.
     const createRe = /\bgit\s+(?:checkout\s+-b|switch\s+-c)\s+([^\s"'&;|]+)/g;
     for (const line of transcriptContent.split("\n")) {
         if (!line.trim())
             continue;
-        // commit/push output: scan the raw serialized line (output lives in string
-        // fields); robust to non-JSON / partial lines.
         scan(line, commitRe);
         scan(line, pushRe);
         let entry;
@@ -681,11 +567,6 @@ function parseAuthoredBranches(transcriptContent) {
     }
     return out;
 }
-// Resolve the extracted tokens to FULL 40-char SHAs via the repo's shared object
-// store (a worktree's commits live in the main repo's .git/objects, so they
-// resolve even after the worktree dir is removed). Full SHAs pass through; short
-// ones are resolved; unresolvable ones are dropped (a short sha can't exact-
-// match the worker's full commitShas). Keeps the server-side match exact.
 function parseAuthoredShas(transcriptContent, repoRoot, resolveFullBatch = (shas) => defaultResolveFullShaBatch(shas, repoRoot)) {
     const out = new Set();
     const shorts = new Set();
@@ -704,14 +585,6 @@ function parseAuthoredShas(transcriptContent, repoRoot, resolveFullBatch = (shas
     }
     return [...out];
 }
-// Resolve many short SHAs to full in ONE git spawn via `git cat-file
-// --batch-check` (reads requests on stdin, emits one result line per request,
-// in order). The previous one-`git rev-parse`-per-sha approach cost N spawns;
-// on Windows (~50-150ms/spawn) a long session's transcript made the detached
-// capture child run for tens of seconds (measured 28s for 40 shas on a real
-// windows-latest runner) — fragile if the child is torn down before it
-// finishes. This is ~constant-time regardless of sha count. Missing objects
-// yield a "<req> missing" line and are skipped. Never throws.
 function defaultResolveFullShaBatch(shas, repoRoot) {
     const out = new Map();
     if (shas.length === 0)
@@ -724,8 +597,6 @@ function defaultResolveFullShaBatch(shas, repoRoot) {
             stdio: ["pipe", "pipe", "pipe"],
         }).toString();
         const lines = res.split("\n");
-        // One output line per input line, in order: "<full-sha> commit <size>" when
-        // resolved; "<request> missing" / "<request> ambiguous" otherwise.
         shas.forEach((sha, i) => {
             const parts = (lines[i] ?? "").trim().split(/\s+/);
             if (parts.length >= 2 && parts[1] === "commit" && /^[0-9a-f]{40}$/.test(parts[0])) {
@@ -734,14 +605,9 @@ function defaultResolveFullShaBatch(shas, repoRoot) {
         });
     }
     catch {
-        // best-effort — a git failure just means no shas resolve
     }
     return out;
 }
-// Current branch via direct .git/HEAD read (no git binary required, same
-// robustness as getGitRemoteUrl). Returns null on detached HEAD or when
-// unresolvable. This is the session→merge join key: a captured session's
-// branch is matched against a merged MR/PR's source_branch.
 function getGitBranch(cwd) {
     const gitDir = resolveGitDir(cwd);
     if (gitDir) {
@@ -750,10 +616,8 @@ function getGitBranch(cwd) {
             const m = head.match(/^ref:\s*refs\/heads\/(.+)$/);
             if (m)
                 return m[1].trim();
-            // raw sha => detached HEAD, no branch
         }
         catch {
-            // fall through to git
         }
     }
     try {
@@ -769,8 +633,6 @@ function getGitBranch(cwd) {
         return null;
     }
 }
-// Current commit SHA (HEAD), direct-read first then git fallback. Exact join
-// key — survives branch renames that branch-matching would miss.
 function getGitHeadSha(cwd) {
     const gitDir = resolveGitDir(cwd);
     if (gitDir) {
@@ -789,7 +651,6 @@ function getGitHeadSha(cwd) {
                             return sha.toLowerCase();
                     }
                     catch {
-                        /* try packed-refs */
                     }
                     try {
                         const packed = fs.readFileSync(path.join(baseDir, "packed-refs"), "utf8");
@@ -803,13 +664,11 @@ function getGitHeadSha(cwd) {
                         }
                     }
                     catch {
-                        /* ignore */
                     }
                 }
             }
         }
         catch {
-            // fall through to git
         }
     }
     try {
@@ -825,19 +684,22 @@ function getGitHeadSha(cwd) {
         return null;
     }
 }
+function stripRepoUrlCredentials(url) {
+    return url.replace(/^(\s*[a-zA-Z][a-zA-Z0-9+.-]*:\/\/)[^/?#]*@/, "$1");
+}
 function buildCapturePayload(input) {
     return {
         sessionId: input.sessionId,
-        repoUrl: input.remoteUrl ?? "",
+        repoUrl: stripRepoUrlCredentials(input.remoteUrl ?? ""),
         repoId: input.matchedRepoId,
         companyId: input.companyId,
         branch: input.branch ?? "",
         headSha: input.headSha ?? "",
-        // Arrays omitted when empty so older servers (which ignore unknown keys)
-        // see no change; newer servers index the session under every key.
         branches: input.branches && input.branches.length ? input.branches : undefined,
         headShas: input.headShas && input.headShas.length ? input.headShas : undefined,
-        gitRefs: input.gitRefs && input.gitRefs.length ? input.gitRefs : undefined,
+        gitRefs: input.gitRefs && input.gitRefs.length
+            ? input.gitRefs.map((ref) => ({ ...ref, repoUrl: stripRepoUrlCredentials(ref.repoUrl) }))
+            : undefined,
         pullRequestUrls: input.pullRequestUrls && input.pullRequestUrls.length
             ? input.pullRequestUrls
             : undefined,
@@ -846,8 +708,6 @@ function buildCapturePayload(input) {
         toolCallCount: input.toolCallCount,
         capturedAt: input.capturedAt,
         source: input.source,
-        // New capture signals (cost / velocity / steering). Optional — omitted
-        // (undefined) keys drop out of the JSON body, so older servers ignore them.
         inputTokens: input.inputTokens,
         outputTokens: input.outputTokens,
         cacheTokens: input.cacheTokens,
@@ -859,7 +719,6 @@ function buildCapturePayload(input) {
         sessionStartedAt: input.sessionStartedAt ?? undefined,
         interruptCount: input.interruptCount,
         rejectionCount: input.rejectionCount,
-        // final is only emitted when explicitly set (omitted for Codex Stop).
         final: input.final,
         costUsd: input.costUsd,
     };
@@ -873,21 +732,18 @@ function hashToken(token) {
     }
     return hash.toString(36);
 }
-const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
-const CLAUDE_DIR = path.join(os.homedir(), ".claude");
-const CODEX_HOOKS_PATH = path.join(os.homedir(), ".codex", "hooks.json");
-const CODEX_DIR = path.join(os.homedir(), ".codex");
+const CLAUDE_SETTINGS_PATH = path.join((0, harnessDirs_1.claudeConfigDir)(), "settings.json");
+const CLAUDE_DIR = (0, harnessDirs_1.claudeConfigDir)();
+const CODEX_HOOKS_PATH = path.join((0, harnessDirs_1.codexHome)(), "hooks.json");
+const CODEX_DIR = (0, harnessDirs_1.codexHome)();
 const CURSOR_DIR = path.join(os.homedir(), ".cursor");
-const OPENCODE_DIR = path.join(os.homedir(), ".config", "opencode");
+const OPENCODE_DIR = (0, harnessDirs_1.openCodeConfigDir)();
 const OPENCODE_PLUGIN_DIR = path.join(OPENCODE_DIR, "plugins");
 const OPENCODE_PLUGIN_PATH = path.join(OPENCODE_PLUGIN_DIR, "codiedev.js");
 const CURSOR_HOOKS_PATH = path.join(CURSOR_DIR, "hooks.json");
 const CURSOR_MCP_PATH = path.join(CURSOR_DIR, "mcp.json");
 const CURSOR_RULES_DIR = path.join(CURSOR_DIR, "rules");
 const CURSOR_RULES_PATH = path.join(CURSOR_RULES_DIR, "codiedev.mdc");
-// VS Code Copilot Chat: detected by the github.copilot* extension dir, then
-// MCP wired via VS Code's user-scope mcp.json (top-level key is "servers",
-// not "mcpServers" like Claude/Cursor).
 const VSCODE_EXTENSIONS_DIR = path.join(os.homedir(), ".vscode", "extensions");
 const VSCODE_USER_DIR = (() => {
     const home = os.homedir();
@@ -901,40 +757,17 @@ const VSCODE_USER_DIR = (() => {
     return path.join(home, ".config", "Code", "User");
 })();
 const VSCODE_USER_MCP_PATH = path.join(VSCODE_USER_DIR, "mcp.json");
-// GUI-launched agents (Cursor.app, future JetBrains plugins) don't source the
-// user's shell rc, so nvm-managed `npx` and `node` aren't on PATH. Resolve the
-// absolute path to the current node binary and our hook.js at install time and
-// write that into hook configs so execution doesn't depend on the spawned
-// shell's PATH. Falls back to `npx` if we can't resolve dist/hook.js.
 function shellQuote(s) {
     return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-// Pull the `<node>` prefix out of a codiedev hook command we previously wrote.
-// Commands take the form `'<node>' '<hookScript>' <subcommand>` (each path
-// single-quoted by shellQuote). Returns undefined for the legacy
-// `npx codiedev-hook <subcommand>` form (no explicit node path) or if the
-// command doesn't start with a quoted token. Exported for unit testing.
 function extractHookNodePath(cmd) {
     if (!cmd)
         return undefined;
-    // Match the first single-quoted token, honoring shellQuote's `'\''` escape.
     const m = cmd.match(/^'((?:[^']|'\\'')*)'/);
     if (!m)
         return undefined;
     return m[1].replace(/'\\''/g, "'");
 }
-// `process.execPath` is the *resolved* path to the running node binary, so under
-// Homebrew it's the version-specific Cellar path (e.g.
-// /opt/homebrew/Cellar/node/26.4.0/bin/node). Baking that into the hook means a
-// later `brew upgrade node` moves the Cellar dir and the hook path 404s. Prefer
-// a stable alias for the *same* binary:
-//   1. A node path from a hook we previously wrote that still resolves — usually
-//      a symlink the user deliberately pinned (e.g. /opt/homebrew/bin/node). A
-//      re-`connect`/self-heal then honors it instead of clobbering it.
-//   2. Otherwise, `node` as found on PATH when it points at the binary we're
-//      running (the Homebrew symlink, an nvm `current` alias, etc.).
-//   3. Last resort: the resolved `process.execPath`. Always valid right now, and
-//      still an absolute path a GUI-launched agent can execute without PATH.
 function realpathOrSelf(p) {
     try {
         return fs.realpathSync(p);
@@ -943,13 +776,7 @@ function realpathOrSelf(p) {
         return p;
     }
 }
-// A stable `node` alias on PATH (Homebrew symlink, nvm `current`, …) that points
-// at the very binary we're running, or undefined if none. `installHook` writes
-// five hooks per run, so memoize: `command -v node` is a synchronous subprocess
-// spawn and its result can't change within a process. `null` = "looked, none".
 let cachedStableNodeOnPath;
-// Test-only: the memo lives for the process lifetime, so suites that stage
-// their own PATH/symlink fixtures must clear it between tests.
 function resetStableNodeCacheForTests() {
     cachedStableNodeOnPath = undefined;
 }
@@ -970,30 +797,21 @@ function stableNodeOnPath() {
         }
     }
     catch {
-        // No node on PATH (e.g. GUI-launched agent) — fall through.
     }
     cachedStableNodeOnPath = null;
     return undefined;
 }
 function resolveHookNodePath(preferredNodePath) {
     const execReal = realpathOrSelf(process.execPath);
-    // 1. Honor a still-working node path from the existing hook — but only when
-    //    it's a *different* string than the resolved realpath. If the existing
-    //    path already IS `process.execPath` it's the version-specific realpath we
-    //    want to upgrade away from (that's the Homebrew bug), so fall through to
-    //    hunt for a stable alias in step 2.
     if (preferredNodePath &&
         preferredNodePath !== process.execPath &&
         fs.existsSync(preferredNodePath) &&
         realpathOrSelf(preferredNodePath) === execReal) {
         return preferredNodePath;
     }
-    // 2. Prefer a stable `node` on PATH over the version-specific realpath.
     const onPath = stableNodeOnPath();
     if (onPath)
         return onPath;
-    // 3. Last resort: the resolved absolute path. Always valid right now, and
-    //    still an absolute path a GUI-launched agent can execute without PATH.
     return process.execPath;
 }
 function resolveHookInvocation(subcommand, preferredNodePath) {
@@ -1005,12 +823,12 @@ function resolveHookInvocation(subcommand, preferredNodePath) {
             const hookScript = path.join(distDir, "hook.js");
             if (fs.existsSync(hookScript)) {
                 const nodePath = resolveHookNodePath(preferredNodePath);
-                return { command: nodePath, args: [hookScript, subcommand] };
+                const launcher = (0, launcher_1.ensureLauncher)(hookScript);
+                return { command: nodePath, args: [launcher ?? hookScript, subcommand] };
             }
         }
     }
     catch {
-        // Fall through to npx fallback.
     }
     return {
         command: process.platform === "win32" ? "npx.cmd" : "npx",
@@ -1022,8 +840,6 @@ function resolveHookCommand(subcommand, preferredNodePath) {
     const argsBeforeSubcommand = invocation.args.slice(0, -1).map(shellQuote);
     return [shellQuote(invocation.command), ...argsBeforeSubcommand, subcommand].join(" ");
 }
-// `isCodiedevHookCommand` is defined in `./detection` so it's testable
-// without mocking fs/path. Re-imported below; do not re-define here.
 function claudeBinOnPath() {
     try {
         (0, child_process_1.execSync)("command -v claude", { stdio: ["pipe", "pipe", "pipe"] });
@@ -1045,6 +861,19 @@ function codexInstalled() {
 function cursorInstalled() {
     return fs.existsSync(CURSOR_DIR);
 }
+function copilotInstalled() {
+    if (fs.existsSync((0, copilotHooks_1.copilotHome)()))
+        return true;
+    if (vscodeCopilotInstalled())
+        return true;
+    try {
+        (0, child_process_1.execSync)(process.platform === "win32" ? "where copilot" : "command -v copilot", { stdio: ["pipe", "pipe", "pipe"] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function openCodeInstalled() {
     if (fs.existsSync(OPENCODE_DIR))
         return true;
@@ -1056,9 +885,6 @@ function openCodeInstalled() {
         return false;
     }
 }
-/** Install a dormant global OpenCode adapter. Installing it unconditionally
- * keeps `codiedev connect` as the only setup step even when Codie/OpenCode is
- * installed later. OpenCode loads this file from its documented plugin dir. */
 function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
     const start = resolveHookInvocation("session-start-opencode");
     const capture = resolveHookInvocation("capture-opencode");
@@ -1070,7 +896,7 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
     const securityFailure = resolveHookInvocation("security-failure-codie");
     const source = `// Managed by codiedev connect. Safe to remove and reinstall.\n` +
         `import { spawn, spawnSync } from "node:child_process";\n` +
-        `import { mkdir, writeFile } from "node:fs/promises";\n` +
+        `import { mkdirSync, writeFileSync, renameSync } from "node:fs";\n` +
         `import os from "node:os";\n` +
         `import path from "node:path";\n\n` +
         `const START = ${JSON.stringify(start)};\n` +
@@ -1082,6 +908,9 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
         `const SECURITY_POST = ${JSON.stringify(securityPost)};\n` +
         `const SECURITY_FAILURE = ${JSON.stringify(securityFailure)};\n` +
         `const AGENT_SECURITY_ENABLED = ${JSON.stringify(agentSecurityEnabled)};\n` +
+        `// How this Codie process was started (run / serve / tui). OpenCode records\n` +
+        `// nothing about it, so the plugin reads its own argv; see launchContext.ts.\n` +
+        `const LAUNCH = (() => { const sub = process.argv.slice(2).find((a) => ["run", "serve", "acp", "web", "attach"].includes(a)); return sub ? "codie:" + sub : "codie:tui"; })();\n` +
         `const fingerprints = new Map();\n\n` +
         `const transcriptPaths = new Map();\n\n` +
         `const sessionDirectories = new Map();\n\n` +
@@ -1136,7 +965,7 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
         `  const finalizeAll = () => {\n` +
         `    for (const [id, transcriptPath] of transcriptPaths) {\n` +
         `      const cwd = sessionDirectories.get(id) || worktree || directory || process.cwd();\n` +
-        `      dispatchSync(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
+        `      dispatchSync(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd], launch: LAUNCH });\n` +
         `    }\n` +
         `  };\n` +
         `  process.once("exit", finalizeAll);\n` +
@@ -1147,7 +976,11 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
         `    const prompt = Array.isArray(output?.parts) ? output.parts.filter((part) => part?.type === "text").map((part) => part.text || "").join("\\n") : "";\n` +
         `    const decision = await enforce(PROMPT, { session_id: id, cwd, prompt });\n` +
         `    const context = decision?.hookSpecificOutput?.additionalContext;\n` +
-        `    if (context && Array.isArray(output?.parts)) output.parts.push({ type: "text", text: context });\n` +
+        `    if (context && Array.isArray(output?.parts)) {\n` +
+        `      // Preserve the native part IDs required by current engine schemas.\n` +
+        `      const part = output.parts.find((part) => part?.type === "text" && typeof part.text === "string");\n` +
+        `      if (part) part.text += "\\n\\n" + context;\n` +
+        `    }\n` +
         `  },\n` +
         `  "tool.execute.before": async (input, output) => {\n` +
         `    if (!AGENT_SECURITY_ENABLED) return;\n` +
@@ -1167,12 +1000,12 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
         `    if (!id) return;\n` +
         `    const cwd = await resolveCwd(id, event?.properties?.info?.directory);\n` +
         `    if (event.type === "session.created") {\n` +
-        `      dispatch(START, { session_id: id, cwd, workspace_roots: [cwd] });\n` +
+        `      dispatch(START, { session_id: id, cwd, workspace_roots: [cwd], launch: LAUNCH });\n` +
         `      return;\n` +
         `    }\n` +
         `    if (event.type === "session.deleted") {\n` +
         `      const transcriptPath = transcriptPaths.get(id);\n` +
-        `      if (transcriptPath) dispatch(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
+        `      if (transcriptPath) dispatch(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd], launch: LAUNCH });\n` +
         `      transcriptPaths.delete(id);\n` +
         `      sessionDirectories.delete(id);\n` +
         `      fingerprints.delete(id);\n` +
@@ -1186,15 +1019,19 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
         `      const last = list.at(-1);\n` +
         `      const fingerprint = String(list.length) + ":" + String(last?.info?.id ?? last?.info?.time?.completed ?? "");\n` +
         `      if (fingerprints.get(id) === fingerprint) return;\n` +
-        `      fingerprints.set(id, fingerprint);\n` +
         `      const captureDir = path.join(os.homedir(), ".codiedev", "opencode-captures");\n` +
-        `      await mkdir(captureDir, { recursive: true, mode: 0o700 });\n` +
+        `      mkdirSync(captureDir, { recursive: true, mode: 0o700 });\n` +
         `      const safeId = String(id).replace(/[^a-zA-Z0-9._-]/g, "_");\n` +
         `      const transcriptPath = path.join(captureDir, safeId + ".json");\n` +
-        `      await writeFile(transcriptPath, JSON.stringify(list), { mode: 0o600 });\n` +
+        `      // The engine may exit as soon as it emits idle. Publish the complete\n` +
+        `      // transcript synchronously so exit finalization never sees a partial file.\n` +
+        `      const temporaryPath = transcriptPath + "." + process.pid + ".tmp";\n` +
+        `      writeFileSync(temporaryPath, JSON.stringify(list), { mode: 0o600 });\n` +
+        `      renameSync(temporaryPath, transcriptPath);\n` +
         `      transcriptPaths.set(id, transcriptPath);\n` +
-        `      dispatch(CAPTURE, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
-        `      dispatch(BACKUP, { session_id: id, cwd, workspace_roots: [cwd] });\n` +
+        `      fingerprints.set(id, fingerprint);\n` +
+        `      dispatch(CAPTURE, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd], launch: LAUNCH });\n` +
+        `      dispatch(BACKUP, { session_id: id, cwd, workspace_roots: [cwd], launch: LAUNCH });\n` +
         `    } catch {}\n` +
         `  },\n` +
         `  });\n` +
@@ -1203,11 +1040,6 @@ function installOpenCodeCapturePlugin(agentSecurityEnabled = true) {
     fs.writeFileSync(OPENCODE_PLUGIN_PATH, source, { encoding: "utf8", mode: 0o600 });
     fs.chmodSync(OPENCODE_PLUGIN_PATH, 0o600);
 }
-/**
- * VS Code with the GitHub Copilot Chat extension installed. The extension
- * directory pattern is `~/.vscode/extensions/github.copilot-chat-*`. We treat
- * the presence of any `github.copilot*` directory as the Copilot fingerprint.
- */
 function vscodeCopilotInstalled() {
     if (!fs.existsSync(VSCODE_EXTENSIONS_DIR))
         return false;
@@ -1220,19 +1052,10 @@ function vscodeCopilotInstalled() {
         return false;
     }
 }
-// Idempotently put a single codiedev hook (matcher ".*" by default, running our hook.js
-// with `subcommand`) into the given hook event, stripping any prior codiedev
-// entries first so connect re-runs / upgrades refresh the resolved binary path.
-// Mutates `hooks` in place. Exported for unit testing.
 function upsertCodiedevHook(hooks, eventName, subcommand, matcher = ".*") {
     if (!hooks[eventName])
         hooks[eventName] = [];
     const existing = hooks[eventName];
-    // Before stripping the old codiedev entry, remember the node path it used so a
-    // re-run/upgrade can honor a stable symlink the user pinned instead of
-    // overwriting it with the version-specific `process.execPath` (see
-    // resolveHookNodePath). Done in an explicit scan rather than as a side effect
-    // of the filter predicate below, which stays a pure predicate.
     let preservedNodePath;
     for (const hook of existing) {
         const inner = hook.hooks;
@@ -1257,7 +1080,6 @@ function upsertCodiedevHook(hooks, eventName, subcommand, matcher = ".*") {
     });
     hooks[eventName] = filtered;
 }
-/** Remove Codiedev's entries for one event while preserving foreign hooks. */
 function removeCodiedevHook(hooks, eventName) {
     const entries = hooks[eventName];
     if (!Array.isArray(entries))
@@ -1295,16 +1117,12 @@ function installHook(agentSecurityEnabled = true) {
         }
     }
     catch {
-        // Start with empty settings if file doesn't exist or is invalid
     }
     if (!settings.hooks) {
         settings.hooks = {};
     }
     const hooks = settings.hooks;
-    // SessionEnd → capture (upload the finished session for the team library).
     upsertCodiedevHook(hooks, "SessionEnd", "capture");
-    // Tool boundaries → ADR shadow detection. PreToolUse is the eventual
-    // enforcement point; alert mode always returns allow.
     if (agentSecurityEnabled) {
         upsertCodiedevHook(hooks, "PreToolUse", "security-pre");
         upsertCodiedevHook(hooks, "PostToolUse", "security-post");
@@ -1315,28 +1133,19 @@ function installHook(agentSecurityEnabled = true) {
         removeCodiedevHook(hooks, "PostToolUse");
         removeCodiedevHook(hooks, "PostToolUseFailure");
     }
-    // UserPromptSubmit → discover (surface a matching team skill for the task).
     upsertCodiedevHook(hooks, "UserPromptSubmit", "discover");
-    // Stop → backup (auto-back-up changed artifact files to your private library).
     upsertCodiedevHook(hooks, "Stop", "backup");
-    // StopFailure (matcher rate_limit) → limit (post rate-limit event to the team).
     upsertCodiedevHook(hooks, "StopFailure", "limit", "rate_limit");
-    // SessionStart → session-start (capture-coverage denominator: record that a
-    // session opened, independent of whether it later captures).
     upsertCodiedevHook(hooks, "SessionStart", "session-start");
     if (!fs.existsSync(CLAUDE_DIR)) {
         fs.mkdirSync(CLAUDE_DIR, { recursive: true });
     }
     fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
 }
-// Self-heal: ensure the discovery (UserPromptSubmit) hook is present without a
-// full `connect` re-run. Called from the capture hook on SessionEnd, so a user
-// who upgrades the CLI gets the new hook wired on their next session. Only
-// writes when missing, to avoid churning settings.json every run.
 function ensureDiscoveryHookInstalled() {
     try {
         if (!fs.existsSync(CLAUDE_SETTINGS_PATH))
-            return; // not a Claude Code user
+            return;
         const raw = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf8");
         const settings = JSON.parse(raw);
         const hooks = (settings.hooks ?? {});
@@ -1353,13 +1162,8 @@ function ensureDiscoveryHookInstalled() {
         fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
     }
     catch {
-        // Best-effort — never block a session on self-heal.
     }
 }
-// Self-heal: ensure the Stop → backup hook is present without a full `connect`
-// re-run, mirroring ensureDiscoveryHookInstalled. Called from the capture hook
-// so an upgraded-but-not-reconnected user gets auto-backup on their next
-// session. Only writes when missing, to avoid churning settings.json every run.
 function ensureBackupHookInstalled() {
     try {
         if (!fs.existsSync(CLAUDE_SETTINGS_PATH))
@@ -1377,12 +1181,8 @@ function ensureBackupHookInstalled() {
         upsertCodiedevHook(hooks, "Stop", "backup");
         fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
     }
-    catch { /* best-effort */ }
+    catch { }
 }
-// Self-heal: ensure the StopFailure (matcher rate_limit) → limit hook is
-// present without a full `connect` re-run, mirroring ensureBackupHookInstalled.
-// Called from the capture hook so an upgraded-but-not-reconnected user gets the
-// limit-event hook wired on their next session. Only writes when missing.
 function ensureLimitHookInstalled() {
     try {
         if (!fs.existsSync(CLAUDE_SETTINGS_PATH))
@@ -1400,26 +1200,12 @@ function ensureLimitHookInstalled() {
         upsertCodiedevHook(hooks, "StopFailure", "limit", "rate_limit");
         fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
     }
-    catch { /* best-effort */ }
-}
-// Self-heal ALL codiedev hooks in one read → one write. This replaces calling
-// the four per-hook ensure* functions in sequence, and fixes two real losses
-// seen in the field (Sonifi, 2026-07):
-//   1. The SessionEnd → capture hook — the one that actually uploads sessions
-//      — had NO self-heal at all: it was written once at `connect` and never
-//      repaired. Anything that stripped it (IT-managed dotfiles baseline, the
-//      race below) left SessionStart pinging forever while captures silently
-//      stopped — the exact "start pings arrive, captures never" signature.
-//   2. Each per-hook ensure* did its own read-modify-write of settings.json
-//      with no locking; two concurrent Claude Code sessions repairing
-//      different hooks could lose each other's writes. One read + one write
-//      shrinks that window and removes the intra-process version entirely.
-// The per-hook ensure* functions below are kept for tests/back-compat but are
-// no longer called from the hook entrypoint.
+    catch { }
+}
 function ensureAllCodiedevHooksInstalled(agentSecurityEnabled = readConfig()?.agentSecurityEnabled === true) {
     try {
         if (!fs.existsSync(CLAUDE_SETTINGS_PATH))
-            return; // not a Claude Code user
+            return;
         const settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf8"));
         const hooks = (settings.hooks ?? {});
         const wanted = [
@@ -1440,7 +1226,7 @@ function ensureAllCodiedevHooksInstalled(agentSecurityEnabled = readConfig()?.ag
         }
         const missing = wanted.filter(([eventName]) => !hasCodiedevHook(hooks, eventName));
         if (missing.length === 0 && !changed)
-            return; // steady state: no write, no churn
+            return;
         settings.hooks = hooks;
         for (const [eventName, subcommand, matcher] of missing) {
             upsertCodiedevHook(hooks, eventName, subcommand, matcher);
@@ -1448,16 +1234,38 @@ function ensureAllCodiedevHooksInstalled(agentSecurityEnabled = readConfig()?.ag
         fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
     }
     catch {
-        // Best-effort — never block a session on self-heal.
     }
 }
+const DIRECT_HOOK_PATH = /codiedev[^"'\s/\\]*[\\/]+dist[\\/]+hook\.js/;
+function hasDirectHookPath(configText) {
+    return DIRECT_HOOK_PATH.test(configText);
+}
+function migrateHooksToLauncher(agentSecurityEnabled = readConfig()?.agentSecurityEnabled === true) {
+    const probe = resolveHookInvocation("session-start");
+    if (!(0, launcher_1.usesLauncher)(probe.args[0]))
+        return [];
+    const targets = [
+        ["claude-code", CLAUDE_SETTINGS_PATH, () => installHook(agentSecurityEnabled)],
+        ["codex", CODEX_HOOKS_PATH, () => installCodexHook(agentSecurityEnabled)],
+        ["cursor", CURSOR_HOOKS_PATH, () => installCursorHook(agentSecurityEnabled)],
+        ["copilot", copilotHooksPath(), () => installCopilotHook(agentSecurityEnabled)],
+        ["opencode", OPENCODE_PLUGIN_PATH, () => installOpenCodeCapturePlugin(agentSecurityEnabled)],
+    ];
+    const migrated = [];
+    for (const [name, file, install] of targets) {
+        try {
+            if (!fs.existsSync(file) || !hasDirectHookPath(fs.readFileSync(file, "utf8")))
+                continue;
+            install();
+            migrated.push(name);
+        }
+        catch {
+        }
+    }
+    return migrated;
+}
 function hasCodiedevHook(hooks, eventName) {
     const entries = hooks[eventName] ?? [];
-    // A malformed (non-array) event value would make `.some` throw and — under
-    // ensureAll's single try/catch — abort EVERY heal, including the capture
-    // heal. Report "present" instead: leave the foreign/corrupt key alone and
-    // keep healing the other events (the per-hook fault isolation the old
-    // ensure* functions had).
     if (!Array.isArray(entries))
         return true;
     return entries.some((hook) => {
@@ -1466,10 +1274,6 @@ function hasCodiedevHook(hooks, eventName) {
             inner.some((h) => (0, detection_1.isCodiedevHookCommand)(h.command)));
     });
 }
-// Self-heal: ensure the SessionStart → session-start hook is present without a
-// full `connect` re-run, mirroring ensureLimitHookInstalled. Called from the
-// capture hook so an upgraded-but-not-reconnected user starts emitting the
-// capture-coverage denominator on their next session. Only writes when missing.
 function ensureSessionStartHookInstalled() {
     try {
         if (!fs.existsSync(CLAUDE_SETTINGS_PATH))
@@ -1487,16 +1291,12 @@ function ensureSessionStartHookInstalled() {
         upsertCodiedevHook(hooks, "SessionStart", "session-start");
         fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
     }
-    catch { /* best-effort */ }
+    catch { }
 }
-// ─────────────────────────────────────────────────────────────────────────────
-// MCP server installation — writes the codiedev MCP server config into each
-// agent CLI's expected location so "npx codiedev connect" wires it up once.
-// ─────────────────────────────────────────────────────────────────────────────
-const CLAUDE_USER_CONFIG_PATH = path.join(os.homedir(), ".claude.json");
-const CLAUDE_USER_INSTRUCTIONS_PATH = path.join(os.homedir(), ".claude", "CLAUDE.md");
-const CODEX_USER_INSTRUCTIONS_PATH = path.join(os.homedir(), ".codex", "AGENTS.md");
-const CODEX_CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
+const CLAUDE_USER_CONFIG_PATH = (0, harnessDirs_1.claudeUserConfigPath)();
+const CLAUDE_USER_INSTRUCTIONS_PATH = path.join((0, harnessDirs_1.claudeConfigDir)(), "CLAUDE.md");
+const CODEX_USER_INSTRUCTIONS_PATH = path.join((0, harnessDirs_1.codexHome)(), "AGENTS.md");
+const CODEX_CONFIG_PATH = path.join((0, harnessDirs_1.codexHome)(), "config.toml");
 const CODIEDEV_INSTRUCTIONS_BEGIN = "<!-- codiedev-cli:begin -->";
 const CODIEDEV_INSTRUCTIONS_END = "<!-- codiedev-cli:end -->";
 const CODIEDEV_INSTRUCTIONS_BODY = `## Codiedev — team artifact layer
@@ -1507,6 +1307,11 @@ decisions, and messages via a CLI on every dev's machine.
 **When the user asks to share, push, ping, check messages, or capture a
 thought, use the \`codiedev\` CLI via Bash:**
 
+If \`codiedev\` is not on PATH, run the same subcommand with
+\`npx codiedev@latest\` instead (for example,
+\`npx codiedev@latest inbox\`). The \`connect\` command installs hooks
+but does not install a global \`codiedev\` executable.
+
 | Intent | Command |
 |---|---|
 | "push this spec" / "save this as a skill" | \`codiedev push <file.md>\` |
@@ -1524,6 +1329,7 @@ thought, use the \`codiedev\` CLI via Bash:**
 | "why did we…?" / "what does the team know about X?" | \`codiedev ask "<question>"\` (synthesized answer + citations) |
 | "show my library" / "what artifacts exist?" | \`codiedev library [--scope mine\\|shared\\|all] [--kind doc\\|skill]\` |
 | "react 🛠 to that post" / "mark as used" | \`codiedev react <postId> <emoji>\` |
+| "run my agent's test cases" / "check the suite on model Y" | \`codiedev traces cases <agent> [--suite <name>] [--model <id>]\` (writes cases + RUN_CASES.md + results.json; follow it, then \`codiedev traces report <results.json>\`) |
 
 **Just push the file — we'll figure out where it goes.** Every artifact
 is classified into one of two kinds at upload time:
@@ -1569,19 +1375,13 @@ Tell the user the portal URL when the submit returns.
   API token from https://codiedev.com/portal/integrations/claude-code
 - "ambiguous recipient" → surface candidates to the user
 `;
-/**
- * Write the codiedev agent-facing docs block to the user-level Claude
- * instructions file so Claude Code picks up the commands in every session
- * (no per-repo CLAUDE.md needed). Idempotent — replaces the existing block
- * between its begin/end markers on re-run.
- */
-function writeInstructionsBlock(targetPath) {
+function writeInstructionsBlock(targetPath, body = CODIEDEV_INSTRUCTIONS_BODY) {
     const dir = path.dirname(targetPath);
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
     const block = `${CODIEDEV_INSTRUCTIONS_BEGIN}\n` +
-        CODIEDEV_INSTRUCTIONS_BODY +
+        body +
         `\n${CODIEDEV_INSTRUCTIONS_END}\n`;
     let existing = "";
     if (fs.existsSync(targetPath)) {
@@ -1591,14 +1391,12 @@ function writeInstructionsBlock(targetPath) {
     const endIdx = existing.indexOf(CODIEDEV_INSTRUCTIONS_END);
     let next;
     if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
-        // Replace the existing block in place.
         next =
             existing.slice(0, beginIdx) +
                 block +
                 existing.slice(endIdx + CODIEDEV_INSTRUCTIONS_END.length);
     }
     else if (existing.trim()) {
-        // Append with a blank-line separator.
         next = existing.replace(/\n*$/, "\n\n") + block;
     }
     else {
@@ -1612,8 +1410,12 @@ function installClaudeCodeInstructions() {
 function installCodexInstructions() {
     writeInstructionsBlock(CODEX_USER_INSTRUCTIONS_PATH);
 }
-// Cursor uses .mdc rule files with YAML frontmatter (description, alwaysApply,
-// globs). `.cursorrules` is deprecated and ignored by Agent mode as of 2026.
+function copilotInstructionsPath() {
+    return path.join((0, copilotHooks_1.copilotHome)(), "copilot-instructions.md");
+}
+function installCopilotInstructions() {
+    writeInstructionsBlock(copilotInstructionsPath(), `${teamSkillContext_1.TEAM_SKILL_CONTEXT}\n\n${CODIEDEV_INSTRUCTIONS_BODY}`);
+}
 const CURSOR_INSTRUCTIONS_FRONTMATTER = `---
 description: Codiedev team artifact layer — push, pull, search, ping, and share artifacts with teammates
 alwaysApply: true
@@ -1627,7 +1429,7 @@ function installCursorInstructions() {
     const block = CURSOR_INSTRUCTIONS_FRONTMATTER +
         CODIEDEV_INSTRUCTIONS_BEGIN +
         "\n" +
-        CODIEDEV_INSTRUCTIONS_BODY +
+        `${teamSkillContext_1.TEAM_SKILL_CONTEXT}\n\n${CODIEDEV_INSTRUCTIONS_BODY}` +
         "\n" +
         CODIEDEV_INSTRUCTIONS_END +
         "\n";
@@ -1635,8 +1437,6 @@ function installCursorInstructions() {
     if (fs.existsSync(CURSOR_RULES_PATH)) {
         existing = fs.readFileSync(CURSOR_RULES_PATH, "utf8");
     }
-    // If the file already has our markers, replace just the block — preserve
-    // any frontmatter edits the user made.
     const beginIdx = existing.indexOf(CODIEDEV_INSTRUCTIONS_BEGIN);
     const endIdx = existing.indexOf(CODIEDEV_INSTRUCTIONS_END);
     let next;
@@ -1645,7 +1445,7 @@ function installCursorInstructions() {
             existing.slice(0, beginIdx) +
                 CODIEDEV_INSTRUCTIONS_BEGIN +
                 "\n" +
-                CODIEDEV_INSTRUCTIONS_BODY +
+                `${teamSkillContext_1.TEAM_SKILL_CONTEXT}\n\n${CODIEDEV_INSTRUCTIONS_BODY}` +
                 "\n" +
                 CODIEDEV_INSTRUCTIONS_END +
                 existing.slice(endIdx + CODIEDEV_INSTRUCTIONS_END.length);
@@ -1671,10 +1471,6 @@ function readMcpConfigSafely(path) {
         return {};
     }
 }
-/**
- * Install the Codiedev MCP server into Claude Code's user-scope config.
- * Safe to call multiple times — updates the existing entry if present.
- */
 function installClaudeCodeMcp() {
     const config = readMcpConfigSafely(CLAUDE_USER_CONFIG_PATH);
     const mcpServers = config.mcpServers ?? {};
@@ -1687,12 +1483,6 @@ function installClaudeCodeMcp() {
     config.mcpServers = mcpServers;
     fs.writeFileSync(CLAUDE_USER_CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
 }
-/**
- * Install the Codiedev MCP server into Cursor's user-scope config.
- * Cursor uses the same `mcpServers` schema as Claude Code; just a different
- * file path (~/.cursor/mcp.json). Project-scoped servers can also live at
- * <project>/.cursor/mcp.json — we only manage the user-scope one.
- */
 function installCursorMcp() {
     if (!fs.existsSync(CURSOR_DIR)) {
         fs.mkdirSync(CURSOR_DIR, { recursive: true });
@@ -1708,17 +1498,6 @@ function installCursorMcp() {
     config.mcpServers = mcpServers;
     fs.writeFileSync(CURSOR_MCP_PATH, JSON.stringify(config, null, 2), "utf8");
 }
-/**
- * Install the Codiedev MCP server into VS Code's user-scope MCP config so
- * GitHub Copilot Chat picks it up. VS Code uses a different schema than
- * Claude / Cursor: top-level key is `servers` (not `mcpServers`). On first
- * Copilot Chat run after install, VS Code prompts the user to trust the
- * server — that's expected and documented in the connect success message.
- *
- * Reverse-ticket and the other on-demand verbs work in Copilot identically
- * to Claude Code since the MCP server's reverse_ticket handler is already
- * 100% diff-driven (no transcript dependency).
- */
 function installVSCodeMcp() {
     if (!fs.existsSync(VSCODE_USER_DIR)) {
         fs.mkdirSync(VSCODE_USER_DIR, { recursive: true });
@@ -1735,14 +1514,6 @@ function installVSCodeMcp() {
     config.servers = servers;
     fs.writeFileSync(VSCODE_USER_MCP_PATH, JSON.stringify(config, null, 2), "utf8");
 }
-// ─────────────────────────────────────────────────────────────────────────────
-// Migration cleanup — strips MCP server entries written by pre-CLI-only
-// versions of `codiedev connect`. Those entries pointed at `npx codiedev-mcp`,
-// a binary that was removed from package.json in 0.3.4. Without these
-// cleanups, customers who upgrade to 0.7.11+ keep seeing "MCP server failed
-// to start" errors in their agent UIs even though the CLI works fine.
-// All cleanup helpers are idempotent and safe to run when no entry exists.
-// ─────────────────────────────────────────────────────────────────────────────
 function removeJsonKey(filePath, parentKey) {
     if (!fs.existsSync(filePath))
         return;
@@ -1751,7 +1522,7 @@ function removeJsonKey(filePath, parentKey) {
         parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
     }
     catch {
-        return; // Don't damage a file we can't parse.
+        return;
     }
     const parent = parsed[parentKey];
     if (!parent || typeof parent !== "object")
@@ -1761,33 +1532,15 @@ function removeJsonKey(filePath, parentKey) {
     delete parent.codiedev;
     fs.writeFileSync(filePath, JSON.stringify(parsed, null, 2), "utf8");
 }
-/**
- * Removes `mcpServers.codiedev` from `~/.claude.json` if present. Leaves
- * other MCP servers and unrelated top-level settings untouched.
- */
 function cleanupClaudeCodeMcp() {
     removeJsonKey(CLAUDE_USER_CONFIG_PATH, "mcpServers");
 }
-/**
- * Removes `mcpServers.codiedev` from `~/.cursor/mcp.json` if present.
- */
 function cleanupCursorMcp() {
     removeJsonKey(CURSOR_MCP_PATH, "mcpServers");
 }
-/**
- * Removes `servers.codiedev` from VS Code's user-scope mcp.json. VS Code
- * uses a different schema (`servers` not `mcpServers`), so this is a
- * separate helper.
- */
 function cleanupVSCodeMcp() {
     removeJsonKey(VSCODE_USER_MCP_PATH, "servers");
 }
-/**
- * Removes the `# codiedev-mcp` block from `~/.codex/config.toml`. The
- * install side appends a well-marked block; we strip it the same way —
- * the marker line through the end of its TOML section. Whitespace-only
- * gaps between sections are preserved.
- */
 function cleanupCodexMcp() {
     if (!fs.existsSync(CODEX_CONFIG_PATH))
         return;
@@ -1804,31 +1557,22 @@ function cleanupCodexMcp() {
             continue;
         }
         if (skipping) {
-            // Stay in skip mode through the [mcp_servers.codiedev] block until
-            // we hit a blank line or a different TOML section header.
             const trimmed = line.trim();
             if (trimmed === "") {
                 skipping = false;
-                continue; // also drop the blank that immediately follows the block
+                continue;
             }
             if (trimmed.startsWith("[") && !trimmed.startsWith("[mcp_servers.codiedev")) {
                 skipping = false;
                 out.push(line);
                 continue;
             }
-            // Skip lines belonging to the codiedev block.
             continue;
         }
         out.push(line);
     }
     fs.writeFileSync(CODEX_CONFIG_PATH, out.join("\n"), "utf8");
 }
-/**
- * Best-effort append of the Codiedev MCP server block to ~/.codex/config.toml.
- *
- * Codex uses TOML and we don't want a full parser for such a small addition,
- * so we append a well-marked block if one isn't already present. Idempotent.
- */
 function installCodexMcp() {
     if (!fs.existsSync(CODEX_DIR)) {
         fs.mkdirSync(CODEX_DIR, { recursive: true });
@@ -1851,9 +1595,6 @@ function installCodexMcp() {
     fs.writeFileSync(CODEX_CONFIG_PATH, existing + block, "utf8");
     return true;
 }
-// Codex doesn't have a SessionEnd event yet — Stop fires after every turn.
-// The backend dedupes on (companyId, sessionId) and replaces the stored
-// transcript on re-upload, so the latest turn's snapshot wins.
 function installCodexHook(agentSecurityEnabled = true) {
     let hooksFile = {};
     try {
@@ -1863,7 +1604,6 @@ function installCodexHook(agentSecurityEnabled = true) {
         }
     }
     catch {
-        // Start fresh if missing or invalid
     }
     if (!hooksFile.hooks) {
         hooksFile.hooks = {};
@@ -1878,9 +1618,6 @@ function installCodexHook(agentSecurityEnabled = true) {
             return true;
         return !inner.some((h) => (0, detection_1.isCodiedevHookCommand)(h.command));
     });
-    // Codex has no StopFailure matcher. Its Stop transcript includes a
-    // structured rate-limit snapshot, so this tiny hook reports only when that
-    // snapshot says a boundary was reached.
     filtered.push({
         hooks: [
             {
@@ -1899,7 +1636,6 @@ function installCodexHook(agentSecurityEnabled = true) {
             },
         ],
     });
-    // Stop → backup: auto-back-up changed artifact files to the private library.
     filtered.push({
         hooks: [
             {
@@ -1910,9 +1646,6 @@ function installCodexHook(agentSecurityEnabled = true) {
         ],
     });
     hooks.Stop = filtered;
-    // Codex uses the same Claude-style matcher-group shape. Keep these as
-    // separate entries because Codex hook coverage is still evolving and a
-    // malformed/unavailable post hook must not interfere with PreToolUse.
     if (agentSecurityEnabled) {
         upsertCodiedevHook(hooks, "PreToolUse", "security-pre-codex");
         upsertCodiedevHook(hooks, "PostToolUse", "security-post-codex");
@@ -1923,10 +1656,6 @@ function installCodexHook(agentSecurityEnabled = true) {
         removeCodiedevHook(hooks, "PostToolUse");
         removeCodiedevHook(hooks, "PostToolUseFailure");
     }
-    // Prompt guard + skill discovery. The guard runs locally before any prompt
-    // content can reach either the model or Codiedev's discovery endpoint.
-    // Codex models UserPromptSubmit as a non-matcher event (the trust-key model
-    // intentionally excludes it from MATCHER_EVENTS), so omit the matcher key.
     upsertCodiedevHook(hooks, "UserPromptSubmit", "discover-codex", null);
     if (!fs.existsSync(CODEX_DIR)) {
         fs.mkdirSync(CODEX_DIR, { recursive: true });
@@ -1934,8 +1663,6 @@ function installCodexHook(agentSecurityEnabled = true) {
     fs.writeFileSync(CODEX_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
     (0, codexHookTrust_1.writeCodexHookTrust)(CODEX_CONFIG_PATH, CODEX_HOOKS_PATH, hooksFile);
 }
-// Existing Codex users already have capture-codex on Stop. After a CLI
-// upgrade, that hook repairs newer lifecycle hooks without requiring connect.
 function ensureCodexLimitHookInstalled() {
     try {
         if (!fs.existsSync(CODEX_HOOKS_PATH))
@@ -1970,18 +1697,11 @@ function ensureCodexLimitHookInstalled() {
             return;
         hooksFile.hooks = hooks;
         fs.writeFileSync(CODEX_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
-        // Trust keys include each hook's positional index. Adding the new hook at
-        // the front shifts capture/backup, so refresh every Codiedev hash together.
         (0, codexHookTrust_1.writeCodexHookTrust)(CODEX_CONFIG_PATH, CODEX_HOOKS_PATH, hooksFile);
     }
     catch {
-        // Best-effort: capture must never fail because hook repair did.
     }
 }
-// Cursor's hooks.json uses { version: 1, hooks: { sessionEnd: [{ command, type, timeout }] } }.
-// `sessionEnd` fires when a conversation closes (completed, aborted, error,
-// window_close, user_close); the base stdin payload includes transcript_path
-// and session_id which `codiedev-hook capture-cursor` reads to upload.
 function installCursorHook(agentSecurityEnabled = true) {
     if (!fs.existsSync(CURSOR_DIR)) {
         fs.mkdirSync(CURSOR_DIR, { recursive: true });
@@ -2018,31 +1738,97 @@ function installCursorHook(agentSecurityEnabled = true) {
         else
             hooks[eventName] = [...preserved, ...managed];
     };
-    // Cursor-native lifecycle names and flat hook entries. Capture only at the
-    // real IDE session boundary; backup at every completed agent turn. The
-    // Cursor-specific backup entrypoint keeps that non-final snapshot labeled
-    // and normalized as Cursor rather than accidentally treating it as Claude.
     replaceManaged("sessionStart", ["session-start-cursor"]);
     replaceManaged("sessionEnd", ["capture-cursor"]);
     replaceManaged("stop", ["backup-cursor"]);
+    replaceManaged("subagentStart", ["observe-cursor"]);
+    replaceManaged("subagentStop", ["observe-cursor"]);
     if (agentSecurityEnabled) {
-        // Cursor supports blocking here, but not dynamic context injection.
         replaceManaged("beforeSubmitPrompt", ["security-prompt-cursor"]);
         replaceManaged("preToolUse", ["security-pre-cursor"]);
-        replaceManaged("postToolUse", ["security-post-cursor"]);
-        replaceManaged("postToolUseFailure", ["security-failure-cursor"]);
+        replaceManaged("postToolUse", ["observe-cursor", "security-post-cursor"]);
+        replaceManaged("postToolUseFailure", ["observe-cursor", "security-failure-cursor"]);
     }
     else {
         replaceManaged("beforeSubmitPrompt", []);
         replaceManaged("preToolUse", []);
-        replaceManaged("postToolUse", []);
-        replaceManaged("postToolUseFailure", []);
+        replaceManaged("postToolUse", ["observe-cursor"]);
+        replaceManaged("postToolUseFailure", ["observe-cursor"]);
     }
     fs.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(hooksFile, null, 2), "utf8");
 }
-/** Repair Cursor's complete flat hook set after upgrades or configuration
- * drift. This is deliberately separate from Claude Code's nested-hook healer:
- * the schemas and event names differ, and mixing them risks corrupting both. */
+function copilotHooksPath() {
+    return path.join((0, copilotHooks_1.copilotHome)(), "hooks", "codiedev.json");
+}
+function copilotManagedHooks(agentSecurityEnabled) {
+    return [
+        ["sessionStart", "session-start-copilot", 10],
+        ["userPromptSubmitted", "discover-copilot", 10],
+        ["agentStop", "backup-copilot", 30],
+        ["sessionEnd", "capture-copilot", 30],
+        ["errorOccurred", "limit-copilot", 10],
+        ...(agentSecurityEnabled
+            ? [
+                ["preToolUse", "security-pre-copilot", 10],
+                ["postToolUse", "security-post-copilot", 10],
+            ]
+            : []),
+    ];
+}
+const COPILOT_EVENTS = ["sessionStart", "userPromptSubmitted", "agentStop", "sessionEnd", "preToolUse", "postToolUse", "errorOccurred"];
+function installCopilotHook(agentSecurityEnabled = false) {
+    const hooksPath = copilotHooksPath();
+    let hooksFile = {};
+    try {
+        if (fs.existsSync(hooksPath)) {
+            const raw = fs.readFileSync(hooksPath, "utf8");
+            hooksFile = raw.trim() ? JSON.parse(raw) : {};
+        }
+    }
+    catch {
+        hooksFile = {};
+    }
+    hooksFile.version = 1;
+    const hooks = (hooksFile.hooks && typeof hooksFile.hooks === "object" ? hooksFile.hooks : {});
+    const managed = copilotManagedHooks(agentSecurityEnabled);
+    for (const eventName of COPILOT_EVENTS) {
+        const existing = Array.isArray(hooks[eventName]) ? hooks[eventName] : [];
+        const preserved = existing.filter((hook) => !(0, detection_1.isCodiedevHookCommand)((hook.bash ?? hook.powershell ?? hook.command)));
+        const ours = managed
+            .filter(([event]) => event === eventName)
+            .map(([, subcommand, timeoutSec]) => {
+            const command = resolveHookCommand(subcommand);
+            return { type: "command", bash: command, powershell: command, timeoutSec };
+        });
+        if (preserved.length + ours.length === 0)
+            delete hooks[eventName];
+        else
+            hooks[eventName] = [...preserved, ...ours];
+    }
+    hooksFile.hooks = hooks;
+    fs.mkdirSync(path.dirname(hooksPath), { recursive: true });
+    fs.writeFileSync(hooksPath, JSON.stringify(hooksFile, null, 2), "utf8");
+}
+function ensureCopilotCodiedevHooksInstalled(agentSecurityEnabled = readConfig()?.agentSecurityEnabled === true) {
+    try {
+        const hooksPath = copilotHooksPath();
+        if (!fs.existsSync(hooksPath))
+            return;
+        const parsed = JSON.parse(fs.readFileSync(hooksPath, "utf8"));
+        const hooks = parsed.hooks ?? {};
+        const commandsFor = (eventName) => (Array.isArray(hooks[eventName]) ? hooks[eventName] : [])
+            .map((entry) => (entry.bash ?? entry.powershell ?? entry.command))
+            .filter((command) => typeof command === "string" && (0, detection_1.isCodiedevHookCommand)(command));
+        const required = copilotManagedHooks(agentSecurityEnabled);
+        const complete = required.every(([eventName, subcommand]) => commandsFor(eventName).filter((command) => command.trim().endsWith(subcommand)).length === 1);
+        const stale = COPILOT_EVENTS.some((eventName) => commandsFor(eventName).length !== required.filter(([event]) => event === eventName).length);
+        if (complete && !stale)
+            return;
+        installCopilotHook(agentSecurityEnabled);
+    }
+    catch {
+    }
+}
 function ensureCursorCodiedevHooksInstalled(agentSecurityEnabled = readConfig()?.agentSecurityEnabled === true) {
     try {
         if (!fs.existsSync(CURSOR_HOOKS_PATH))
@@ -2062,6 +1848,10 @@ function ensureCursorCodiedevHooksInstalled(agentSecurityEnabled = readConfig()?
             ["sessionStart", "session-start-cursor"],
             ["sessionEnd", "capture-cursor"],
             ["stop", "backup-cursor"],
+            ["postToolUse", "observe-cursor"],
+            ["postToolUseFailure", "observe-cursor"],
+            ["subagentStart", "observe-cursor"],
+            ["subagentStop", "observe-cursor"],
             ...(agentSecurityEnabled
                 ? [
                     ["beforeSubmitPrompt", "security-prompt-cursor"],
@@ -2075,7 +1865,8 @@ function ensureCursorCodiedevHooksInstalled(agentSecurityEnabled = readConfig()?
             "beforeSubmitPrompt", "preToolUse", "postToolUse", "postToolUseFailure",
         ].some((eventName) => {
             const entries = hooks[eventName];
-            return Array.isArray(entries) && entries.some((entry) => (0, detection_1.isCodiedevHookCommand)(entry.command));
+            return Array.isArray(entries) && entries.some((entry) => (0, detection_1.isCodiedevHookCommand)(entry.command) &&
+                !String(entry.command).trim().endsWith("observe-cursor"));
         });
         if (required.every(([eventName, subcommand]) => has(eventName, subcommand)) && !hasStaleSecurity) {
             return;
@@ -2083,7 +1874,6 @@ function ensureCursorCodiedevHooksInstalled(agentSecurityEnabled = readConfig()?
         installCursorHook(agentSecurityEnabled);
     }
     catch {
-        // Best-effort — a malformed third-party config must never block capture.
     }
 }
 function parseClaudeSteering(content) {
@@ -2092,10 +1882,8 @@ function parseClaudeSteering(content) {
     for (const line of content.split("\n")) {
         if (!line.trim())
             continue;
-        // "[Request interrupted by user]" / "...for tool use" — Claude Code markers
         if (line.includes("[Request interrupted by user"))
             interrupts++;
-        // Standard Claude Code tool-rejection sentinels in tool_result content
         if (line.includes("doesn't want to take this action") ||
             line.includes("user doesn't want to proceed"))
             rejections++;
@@ -2120,56 +1908,59 @@ function parseCodexSteering(content) {
             }
         }
         catch {
-            // skip malformed
         }
     }
     return { interrupts, rejections };
 }
 function parseSteering(content, mode) {
+    if (mode === "cursor" || mode === "copilot")
+        return (0, nativeSteering_1.parseNativeSteering)(content);
     return mode === "codex"
         ? parseCodexSteering(content)
         : parseClaudeSteering(content);
 }
 function parseClaudeUsage(content) {
-    // Claude Code logs per-turn usage; sum across the session. `input_tokens` is
-    // already fresh (cache read/creation are reported separately).
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let cacheReadTokens = 0;
-    let cacheCreationTokens = 0;
+    const models = (0, transcriptModels_1.parseTranscriptModels)(content, "claude-code");
     let model = null;
     for (const line of content.split("\n")) {
-        if (!line.trim())
-            continue;
         try {
-            const e = JSON.parse(line);
-            const m = e?.message;
-            const u = m?.usage;
-            if (u) {
-                inputTokens += u.input_tokens ?? 0;
-                outputTokens += u.output_tokens ?? 0;
-                cacheReadTokens += u.cache_read_input_tokens ?? 0;
-                cacheCreationTokens += u.cache_creation_input_tokens ?? 0;
-            }
-            if (typeof m?.model === "string" && m.model)
-                model = m.model;
-        }
-        catch {
-            // skip malformed
+            const value = JSON.parse(line)?.message?.model;
+            if (typeof value === "string" && value.trim() && !value.startsWith("<"))
+                model = value;
         }
+        catch { }
     }
-    return {
-        inputTokens,
-        outputTokens,
-        cacheTokens: cacheReadTokens + cacheCreationTokens,
-        cacheReadTokens,
-        cacheCreationTokens,
-        model,
-    };
+    const sum = (field) => models.reduce((total, usage) => total + usage[field], 0);
+    const cacheReadTokens = sum("cacheReadTokens"), cacheCreationTokens = sum("cacheCreationTokens");
+    const stats = { inputTokens: sum("inputTokens"), outputTokens: sum("outputTokens"),
+        cacheTokens: cacheReadTokens + cacheCreationTokens, cacheReadTokens, cacheCreationTokens, model };
+    return model ? stats : fromClaudeCostState(content, stats);
+}
+function fromClaudeCostState(content, stats) {
+    let usage;
+    for (const line of content.split("\n")) {
+        if (!line.includes('"cost-state"'))
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (e?.type === "cost-state" && e.modelUsage && typeof e.modelUsage === "object")
+                usage = e.modelUsage;
+        }
+        catch { }
+    }
+    const n = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+    const entries = Object.entries(usage ?? {}).filter(([id, u]) => id.trim() && !id.startsWith("<") && u && typeof u === "object");
+    if (!entries.length)
+        return stats;
+    const [model] = entries.reduce((best, entry) => n(entry[1].outputTokens) > n(best[1].outputTokens) ? entry : best);
+    if (stats.inputTokens || stats.outputTokens || stats.cacheTokens)
+        return { ...stats, model };
+    const total = (field) => entries.reduce((sum, [, u]) => sum + n(u[field]), 0);
+    const cacheReadTokens = total("cacheReadInputTokens"), cacheCreationTokens = total("cacheCreationInputTokens");
+    return { inputTokens: total("inputTokens"), outputTokens: total("outputTokens"),
+        cacheTokens: cacheReadTokens + cacheCreationTokens, cacheReadTokens, cacheCreationTokens, model };
 }
 function parseCodexUsage(content) {
-    // Codex reports a CUMULATIVE token_count per turn — the last one is the
-    // session total. `input_tokens` includes the cached portion, so subtract it.
     let model = null;
     let last = null;
     for (const line of content.split("\n")) {
@@ -2187,7 +1978,6 @@ function parseCodexUsage(content) {
             }
         }
         catch {
-            // skip malformed
         }
     }
     if (!last) {
@@ -2197,31 +1987,19 @@ function parseCodexUsage(content) {
     const input = last.input_tokens ?? 0;
     return {
         inputTokens: Math.max(0, input - cached),
-        // Reasoning is included in output_tokens, not additional output.
         outputTokens: last.output_tokens ?? 0,
-        // Codex only reports cached reads; creation is structurally zero.
         cacheTokens: cached,
         cacheReadTokens: cached,
         cacheCreationTokens: 0,
         model,
     };
 }
-// opencode SDK transcripts (the plugin's client.session.messages dump) are a
-// single JSON ARRAY of {info, parts} — not Claude Code's JSONL. Sum assistant
-// token/cost metadata; model = providerID/modelID (matches modelPricing slugs
-// like "openrouter/…" never resolving — stored cost is authoritative here).
 function parseOpencodeUsage(content) {
     let inputTokens = 0, outputTokens = 0, cacheReadTokens = 0, cacheCreationTokens = 0, costUsd = 0;
-    // A session can switch models (user picks another, or a provider falls back).
-    // Attribute it to the model that did the most work rather than whichever
-    // spoke last, since this label drives pricing and the model-mix card.
     const outputByModel = new Map();
     let lastModel = null;
     try {
         const parsed = JSON.parse(content);
-        // Accept both shapes the SDK can produce: a bare array, or the
-        // {data: [...]} envelope normalizeOpenCodeTranscript already unwraps.
-        // Disagreeing with that parser would silently zero out a session's usage.
         const list = Array.isArray(parsed)
             ? parsed
             : (parsed && typeof parsed === "object" && Array.isArray(parsed.data)
@@ -2251,14 +2029,10 @@ function parseOpencodeUsage(content) {
             }
         }
     }
-    catch { /* malformed transcript — zero-safe */ }
-    // Ties (e.g. every turn reporting zero output) fall back to the last model
-    // seen, preserving the previous behaviour for single-model sessions.
+    catch { }
     let model = lastModel;
     let best = -1;
     for (const [id, out] of outputByModel) {
-        // >= so the later model wins a tie, matching the previous last-wins
-        // behaviour when no turn reports output tokens.
         if (out >= best) {
             best = out;
             model = id;
@@ -2274,8 +2048,6 @@ function parseUsage(content, mode) {
         return parseOpencodeUsage(content);
     return mode === "codex" ? parseCodexUsage(content) : parseClaudeUsage(content);
 }
-// Lead-time start proxy: the earliest top-level `timestamp` in the transcript.
-// Both Claude Code and Codex stamp every line, so this is mode-agnostic.
 function parseSessionStart(content) {
     let min = null;
     for (const line of content.split("\n")) {
@@ -2291,7 +2063,6 @@ function parseSessionStart(content) {
             }
         }
         catch {
-            // skip malformed
         }
     }
     return min;
@@ -2299,33 +2070,38 @@ function parseSessionStart(content) {
 function parseClaudeCodeStats(content) {
     let messageCount = 0;
     let toolCallCount = 0;
+    const messages = new Set();
+    const tools = new Set();
     const lines = content.split("\n").filter((l) => l.trim());
     for (const line of lines) {
         try {
             const entry = JSON.parse(line);
             if (!entry || typeof entry !== "object")
                 continue;
-            if (entry.type === "user" || entry.type === "assistant") {
+            const id = entry.message?.id ?? entry.uuid;
+            const messageKey = `${entry.type}:${id ?? messages.size}`;
+            if ((entry.type === "user" || entry.type === "assistant") && !messages.has(messageKey)) {
+                messages.add(messageKey);
                 messageCount++;
             }
             const c = entry.message?.content;
             if (Array.isArray(c)) {
-                for (const block of c) {
-                    if (block && block.type === "tool_use")
+                for (const [index, block] of c.entries()) {
+                    if (!block || block.type !== "tool_use")
+                        continue;
+                    const toolKey = block.id ?? `${messageKey}:${index}`;
+                    if (!tools.has(toolKey)) {
+                        tools.add(toolKey);
                         toolCallCount++;
+                    }
                 }
             }
         }
         catch {
-            // Skip malformed lines
         }
     }
     return { messageCount, toolCallCount };
 }
-/** Convert OpenCode's SDK message array (`{info, parts}[]`) into the same
- * newline-delimited shape used by Claude Code. The rest of capture—privacy
- * exclusions, git keys, token parsing, scrubbing, storage, and merge joins—can
- * therefore stay one shared pipeline instead of becoming a parallel product. */
 function normalizeOpenCodeTranscript(content) {
     let parsed;
     try {
@@ -2360,14 +2136,14 @@ function normalizeOpenCodeTranscript(content) {
             else if (part.type === "tool") {
                 normalizedParts.push({
                     type: "tool_use",
-                    id: part.callID ?? part.id ?? "tool",
+                    id: part.callID ?? part.id,
                     name: part.tool ?? "tool",
                     input: part.state?.input ?? {},
                 });
                 if (part.state?.output != null || part.state?.error != null) {
                     normalizedParts.push({
                         type: "tool_result",
-                        tool_use_id: part.callID ?? part.id ?? "tool",
+                        tool_use_id: part.callID ?? part.id,
                         content: part.state?.output ?? part.state?.error,
                         is_error: part.state?.status === "error" || part.state?.error != null,
                     });
@@ -2383,6 +2159,7 @@ function normalizeOpenCodeTranscript(content) {
             type: role,
             timestamp,
             message: {
+                id: typeof info.id === "string" ? info.id : undefined,
                 role,
                 model: typeof info.modelID === "string" ? info.modelID : undefined,
                 usage: role === "assistant" ? {
@@ -2397,15 +2174,6 @@ function normalizeOpenCodeTranscript(content) {
     }
     return lines.join("\n") + (lines.length ? "\n" : "");
 }
-// Codex session JSONL format (rollout-*.jsonl):
-//   {type:"session_meta", payload:{id, cwd, git:{repository_url,...}, ...}}
-//   {type:"response_item", payload:{type:"message", role, content:[{type:"input_text",text}|{type:"output_text",text}]}}
-//   {type:"response_item", payload:{type:"function_call", name, arguments, call_id}}
-//   {type:"response_item", payload:{type:"function_call_output", call_id, output}}
-//   {type:"response_item", payload:{type:"custom_tool_call", name, input, call_id}}
-//   {type:"response_item", payload:{type:"custom_tool_call_output", call_id, output}}
-//   {type:"event_msg", payload:{type:"token_count"|"agent_reasoning"|...}}
-//   {type:"turn_context", payload:{cwd, model, ...}}
 function parseCodexStats(content) {
     let messageCount = 0;
     let toolCallCount = 0;
@@ -2426,13 +2194,10 @@ function parseCodexStats(content) {
             }
         }
         catch {
-            // Skip malformed lines
         }
     }
     return { messageCount, toolCallCount };
 }
-// Pull repository URL from the Codex transcript's session_meta line so we
-// don't depend on the hook's cwd being a git repo.
 function extractCodexRepoUrl(content) {
     const lines = content.split("\n");
     for (const line of lines) {
@@ -2445,24 +2210,16 @@ function extractCodexRepoUrl(content) {
                 const url = entry.payload?.git?.repository_url;
                 if (typeof url === "string" && url.length > 0)
                     return url;
-                return null; // session_meta is first — no point scanning further
+                return null;
             }
         }
         catch {
-            // Keep scanning
         }
     }
     return null;
 }
-// Give up after this many failed uploads (across sessions) so a permanently
-// failing job never litters /tmp forever. Paired with UPLOAD_TTL_MS.
 exports.MAX_UPLOAD_ATTEMPTS = 5;
 exports.UPLOAD_TTL_MS = 7 * 24 * 60 * 60 * 1000;
-// Open the capture log for appending so a detached child's stderr lands there
-// instead of vanishing into stdio:"ignore". Returns the stdio value to spawn
-// with plus the parent's fd (to close after spawn — the child gets its own
-// duplicate). Falls back to plain "ignore" when openSync is absent or throws,
-// so a missing/unwritable log dir never breaks a dispatch.
 function openCaptureLogStdio(openSync) {
     if (!openSync)
         return { stdio: "ignore" };
@@ -2474,70 +2231,36 @@ function openCaptureLogStdio(openSync) {
         return { stdio: "ignore" };
     }
 }
-// Best-effort close of the parent's log-fd copy. No-op when there's no fd or
-// no closeSync dep — never throws into the capture path.
 function closeCaptureLogFd(fd, closeSync) {
     if (fd === undefined || !closeSync)
         return;
     try {
         closeSync(fd);
     }
-    catch { /* best-effort */ }
-}
-// Hand the SessionEnd capture off to a detached child so the inline hook can
-// exit 0 immediately. Detaching only the network upload (dispatchCaptureDetached)
-// wasn't enough: the synchronous transcript read + parse and — the killer on
-// Windows — one `git rev-parse` per SHA in the transcript (parseAuthoredShas)
-// still ran inline, overrunning Claude Code's SessionEnd shutdown window and
-// triggering "Hook cancelled" on long sessions. This moves ALL of that work
-// into the child. The job carries only the raw hook inputs (the child re-reads
-// the transcript and re-runs git), so the parent's inline work is a single
-// small file write plus a spawn.
+    catch { }
+}
 function dispatchCaptureFinish(input, hookScriptPath, deps) {
     deps.writeFileSync(deps.tmpFile, JSON.stringify(input), { mode: 0o600 });
-    // Route the child's stderr to the capture log so any crash output is
-    // visible to `codiedev doctor`. The caller must explicitly pass openSync
-    // (e.g. fs.openSync in hook.ts) to enable this; when omitted (tests,
-    // older call-sites) we fall back to "ignore" so existing behaviour is
-    // unchanged and no real fd is opened.
     const { stdio, fd } = openCaptureLogStdio(deps.openSync);
     try {
         const child = deps.spawn(deps.nodePath ?? process.execPath, [hookScriptPath, "capture-finish", deps.tmpFile], { detached: true, stdio });
         child.unref();
     }
     finally {
-        // Close the PARENT's fd copy even when spawn throws — the child (if
-        // spawned) holds its own duplicate, so this never cuts off its stderr.
         closeCaptureLogFd(fd, deps.closeSync);
     }
 }
-// Fire-and-forget the session-capture upload from a fully detached child so the
-// SessionEnd hook can exit 0 immediately. Awaiting the upload inline let Claude
-// Code's shutdown window elapse and kill the hook ("Hook cancelled") on large
-// transcripts. The job (incl. bearer token) is written to a file rather than
-// passed via argv so it never shows up in the process list.
 function dispatchCaptureDetached(job, hookScriptPath, deps) {
     deps.writeFileSync(deps.tmpFile, JSON.stringify(job), { mode: 0o600 });
-    // Route the child's stderr to the capture log (same pattern as
-    // dispatchCaptureFinish). The caller must explicitly pass openSync to
-    // enable this; when omitted we fall back to "ignore" so existing callers
-    // keep working unchanged.
     const { stdio, fd } = openCaptureLogStdio(deps.openSync);
     try {
         const child = deps.spawn(deps.nodePath ?? process.execPath, [hookScriptPath, "upload", deps.tmpFile], { detached: true, stdio });
         child.unref();
     }
     finally {
-        // Close the PARENT's fd copy even when spawn throws — the child (if
-        // spawned) holds its own duplicate, so this never cuts off its stderr.
         closeCaptureLogFd(fd, deps.closeSync);
     }
 }
-// Deferred twin of dispatchCaptureDetached: persist the job, then spawn the
-// `upload-deferred` child which sleeps for delayMs before claiming + uploading
-// (or finding itself superseded by a newer turn). Used when decideDispatch
-// says a non-final per-turn capture is inside the throttle window. Identical
-// stdio/fd-hygiene contract to the other dispatch fns.
 function dispatchDeferredUpload(job, hookScriptPath, deps, delayMs) {
     deps.writeFileSync(deps.tmpFile, JSON.stringify(job), { mode: 0o600 });
     const { stdio, fd } = openCaptureLogStdio(deps.openSync);
@@ -2546,29 +2269,11 @@ function dispatchDeferredUpload(job, hookScriptPath, deps, delayMs) {
         child.unref();
     }
     finally {
-        // Close the PARENT's fd copy even when spawn throws — the child (if
-        // spawned) holds its own duplicate, so this never cuts off its stderr.
         closeCaptureLogFd(fd, deps.closeSync);
     }
 }
-// A claimed job whose uploader hasn't finished after this long is presumed
-// crashed and gets renamed back to its canonical name for a later retry.
 exports.CLAIM_STALE_MS = 15 * 60 * 1000;
-// A finish-input file older than this is an orphan: its capture-finish child
-// normally consumes + unlinks it within seconds, so an hour-old file means the
-// child died (spawn failure, OOM/AV kill, machine sleep). Generous so we never
-// race a legitimately slow child.
 exports.FINISH_ORPHAN_AGE_MS = 60 * 60 * 1000;
-// Retry kept-on-failure capture jobs: re-dispatch each pending
-// `codiedev-capture-*.json` to the detached uploader (which bumps attempts /
-// gives up at the cap). Best-effort — never throws into the hook.
-//
-// Each job is CLAIMED with an atomic rename before dispatch. Several
-// session-end hooks can run this sweep over the same tmpdir at once, and
-// without the claim each of them dispatched an uploader for the same job —
-// every duplicate upload triggered a full server-side re-summarize of the
-// session (real LLM spend per duplicate). Rename is atomic, so exactly one
-// sweeper wins each file; the losers' renames throw and they skip it.
 function sweepPendingCaptures(deps) {
     let files;
     try {
@@ -2578,10 +2283,6 @@ function sweepPendingCaptures(deps) {
         return;
     }
     const now = deps.now?.() ?? Date.now();
-    // Recover claims orphaned by a crashed/killed uploader: a stale claim is
-    // renamed back to its canonical name so a LATER sweep retries it. (Not this
-    // one — the uploader may legitimately still be running near the threshold,
-    // and dispatching reclaimed work immediately would race it.)
     for (const f of files) {
         const m = /^(codiedev-capture-.*\.json)\.claim-\d+$/.exec(f);
         if (!m)
@@ -2593,14 +2294,8 @@ function sweepPendingCaptures(deps) {
             }
         }
         catch {
-            // raced another sweeper or the uploader just finished — fine
         }
     }
-    // Orphaned finish-inputs: the FIRST detached child (capture-finish) died
-    // before it could build an upload job. That path has no retry queue — the
-    // payload is gone — but the loss must not stay invisible: report the
-    // sessionId (filename embeds it: codiedev-finish-<sid>-<pid>-<ts>.json) so
-    // it lands as a skip-reason, then clean the file up.
     if (deps.unlinkSync) {
         for (const f of files) {
             const m = /^codiedev-finish-(.+)-\d+-\d+\.json$/.exec(f);
@@ -2611,19 +2306,13 @@ function sweepPendingCaptures(deps) {
                 if (now - deps.statSync(orphanPath).mtimeMs < exports.FINISH_ORPHAN_AGE_MS)
                     continue;
                 deps.unlinkSync(orphanPath);
-                // finishInputTmpFile falls back to the PID when the hook had no
-                // session_id (codiedev-finish-<pid>-<pid>-<ts>.json). A pure-digit
-                // capture is that fallback, not a session id — reporting it would
-                // create a phantom session row server-side. Real session ids are
-                // UUIDs and never all-digits.
                 const sid = /^\d+$/.test(m[1]) ? undefined : m[1];
                 try {
                     deps.reportOrphan?.(sid);
                 }
-                catch { /* report is best-effort */ }
+                catch { }
             }
             catch {
-                // raced its owner or another sweeper — fine
             }
         }
     }
@@ -2631,12 +2320,6 @@ function sweepPendingCaptures(deps) {
         .filter((f) => /^codiedev-capture-.*\.json$/.test(f))
         .map((f) => path.join(deps.dir, f))
         .filter((p) => p !== deps.exclude)
-        // Min-age guard: a YOUNG job file may be a sleeping deferred upload whose
-        // own upload-deferred child will consume it within CAPTURE_THROTTLE_MS of
-        // its mtime. The sweep must not steal it — that would upload per-turn and
-        // defeat the throttle with 2+ concurrent sessions. Only genuinely stuck
-        // jobs (older than SWEEP_MIN_AGE_MS) are retried. A stat failure means the
-        // job was claimed/consumed mid-sweep — skip it.
         .filter((p) => {
         try {
             return now - deps.statSync(p).mtimeMs >= exports.SWEEP_MIN_AGE_MS;
@@ -2646,8 +2329,6 @@ function sweepPendingCaptures(deps) {
         }
     })
         .slice(0, deps.max ?? 10);
-    // One log fd shared by every re-dispatched uploader in this batch (each
-    // spawn duplicates it); the parent's copy is closed after the loop.
     const { stdio, fd } = openCaptureLogStdio(deps.openSync);
     for (const jobFile of jobs) {
         const claimed = `${jobFile}.claim-${process.pid}`;
@@ -2655,135 +2336,71 @@ function sweepPendingCaptures(deps) {
             deps.renameSync(jobFile, claimed);
         }
         catch {
-            continue; // another sweeper claimed it first
+            continue;
         }
         try {
             const child = deps.spawn(deps.nodePath ?? process.execPath, [deps.hookScriptPath, "upload", claimed], { detached: true, stdio });
             child.unref();
         }
         catch {
-            // Couldn't fork the uploader — release the claim so a later sweep
-            // retries instead of the job dying invisible under the claimed name.
             try {
                 deps.renameSync(claimed, jobFile);
             }
             catch {
-                // best-effort
             }
         }
     }
     closeCaptureLogFd(fd, deps.closeSync);
-    // Housekeeping: prune per-session upload-state files older than the upload
-    // TTL so capture-state doesn't grow forever. Best-effort, never throws.
     try {
         (deps.pruneState ?? pruneCaptureStateDir)();
     }
     catch {
-        // best-effort
     }
 }
-// ─────────────────────────────────────────────────────────────────────────────
-// Per-session upload throttle — defers mid-session Stop-hook uploads so we
-// don't hammer the server (and re-summarize) after every single turn.
-// ─────────────────────────────────────────────────────────────────────────────
-// Minimum interval between non-final uploads for the same session. 10 minutes:
-// fine-grained enough to capture recent work while avoiding per-turn churn.
 exports.CAPTURE_THROTTLE_MS = 10 * 60 * 1000;
-// Minimum AGE of a job file before the retry sweep may claim it. An actively
-// deferred job is consumed by its own upload-deferred child within
-// CAPTURE_THROTTLE_MS of its mtime — a sweep stealing it early would upload
-// per-turn and defeat the throttle whenever 2+ sessions run concurrently.
-// The 2-min slack covers the child's wake-up + claim. Side effect: failed
-// uploads (whose retry bump refreshes mtime) now wait ~12 min between retry
-// attempts — fine for a 7-day-TTL retry queue, and a free rate-limit on
-// retry storms.
 exports.SWEEP_MIN_AGE_MS = exports.CAPTURE_THROTTLE_MS + 2 * 60 * 1000;
-// Map the hook's capture argv to the payload's `final` flag. EXPLICIT
-// ALLOWLIST: Claude Code and Cursor SessionEnd entrypoints are true final
-// signals. capture-opencode/
-// capture-desktop (per-turn snapshot) and capture-opencode-final/
-// capture-desktop-final (real session end) get an explicit false/true.
-// Everything else — capture-codex (Codex's Stop fires per-turn; final:true
-// would close the server-side session lease every turn), and any FUTURE mode
-// (e.g. a capture-windsurf added to resolveMode but not
-// audited here) — gets undefined, i.e. legacy server behaviour. Defaulting
-// unknowns to true would silently re-introduce the per-turn lease-close bug
-// for every new agent.
 function resolveCaptureFinal(argv2) {
     if (argv2 === "capture-opencode" || argv2 === "capture-desktop")
         return false;
     if (argv2 === "capture-opencode-final" || argv2 === "capture-desktop-final")
         return true;
-    return argv2 === "capture" || argv2 === "capture-cursor" || argv2 === undefined
+    return argv2 === "capture" || argv2 === "capture-cursor" || argv2 === "capture-copilot" || argv2 === undefined
         ? true
         : undefined;
 }
-// Build a UNIQUE finish-input tmpFile name per dispatch. Both the Stop hook and
-// SessionEnd dispatch capture-finish children, and the child unlinks its input
-// in `finally` — a SHARED per-session name let interleavings drop the final
-// dispatch (Stop's child unlinks the file SessionEnd just wrote) or
-// double-dispatch. Unique names mean each child owns its file exclusively; at
-// worst concurrent Stop+SessionEnd children both upload, which is harmless
-// (the server upserts by sessionId). Orphans (child dies before unlink) sit in
-// tmpdir OUTSIDE the sweep regex (codiedev-finish- ≠ codiedev-capture-);
-// negligible volume (one tiny JSON per crashed child), though note Windows
-// %TEMP% is not auto-cleaned — acceptable.
 function finishInputTmpFile(sessionId) {
     const safeId = String(sessionId ?? process.pid).replace(/[^A-Za-z0-9._-]/g, "_");
     return path.join(os.tmpdir(), `codiedev-finish-${safeId}-${process.pid}-${Date.now()}.json`);
 }
-// Immediate uploads must also own unique job files. A Codie/OpenCode runtime
-// emits idle + final captures almost simultaneously on process exit; when both
-// children shared codiedev-capture-<sid>.json, their uploader grandchildren
-// raced to read/unlink the same file and could lose the final handoff entirely.
-// Deferred uploads intentionally keep the stable per-session name because
-// overwriting it is how newer turns supersede older scheduled snapshots.
 function captureUploadTmpFile(sessionId, mode, pid = process.pid, now = Date.now()) {
     const id = String(sessionId ?? pid).replace(/[^A-Za-z0-9._-]/g, "_");
     return path.join(os.tmpdir(), mode === "immediate"
         ? `codiedev-capture-${id}-${pid}-${now}.json`
         : `codiedev-capture-${id}.json`);
 }
-// Best-effort cancellation for a scheduled per-turn upload when a real final
-// capture arrives. Deferred jobs deliberately share one canonical filename;
-// removing it makes every sleeping uploader lose its later claim-by-rename.
-// The backend's capturedAt guard covers the narrow race where a child claimed
-// the file immediately before this unlink.
 function cancelDeferredCaptureUpload(sessionId, deps = fs) {
     try {
         deps.unlinkSync(captureUploadTmpFile(sessionId, "deferred"));
         return true;
     }
     catch {
-        // Missing means there was nothing pending (or another process won).
         return false;
     }
 }
-// Decide whether to upload immediately or defer until the throttle window expires.
-//   final=true  → always immediate (SessionEnd: close the session now)
-//   null        → immediate (first upload for this session)
-//   outside window → immediate
-//   inside window  → deferred with exact remaining delay
-//   future clock skew → deferred clamped to CAPTURE_THROTTLE_MS
 function decideDispatch(args) {
     if (args.final || args.lastUploadAt === null)
         return { mode: "immediate" };
     const elapsed = args.now - args.lastUploadAt;
-    // Clock-skew guard: elapsed < 0 means lastUploadAt is in the future. Clamping
-    // to 0 also bounds delayMs to at most CAPTURE_THROTTLE_MS (safeElapsed >= 0).
     const safeElapsed = Math.max(0, elapsed);
     if (safeElapsed >= exports.CAPTURE_THROTTLE_MS)
         return { mode: "immediate" };
     return { mode: "deferred", delayMs: exports.CAPTURE_THROTTLE_MS - safeElapsed };
 }
-// Per-session state dir: ~/.codiedev/capture-state/<sanitized-session-id>.json
 const CAPTURE_STATE_DIR = path.join(CONFIG_DIR, "capture-state");
 function captureStatePath(sessionId) {
     const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "_");
     return path.join(CAPTURE_STATE_DIR, `${safe}.json`);
 }
-// Read the per-session upload state from ~/.codiedev/capture-state/<id>.json.
-// Returns null when missing or unreadable. Never throws.
 function readSessionUploadState(sessionId, deps = fs) {
     try {
         const p = captureStatePath(sessionId);
@@ -2795,8 +2412,6 @@ function readSessionUploadState(sessionId, deps = fs) {
         return null;
     }
 }
-// Write the per-session upload state to ~/.codiedev/capture-state/<id>.json.
-// Best-effort: never throws into the capture path.
 function writeSessionUploadState(sessionId, state, deps = fs) {
     try {
         if (!deps.existsSync(CAPTURE_STATE_DIR)) {
@@ -2806,13 +2421,8 @@ function writeSessionUploadState(sessionId, state, deps = fs) {
         deps.writeFileSync(p, JSON.stringify(state), { mode: 0o600 });
     }
     catch {
-        // best-effort — never break the capture path
     }
 }
-// Prune per-session upload-state files older than UPLOAD_TTL_MS (7 days — same
-// TTL as the upload retry queue) so ~/.codiedev/capture-state (one tiny file
-// per session) doesn't grow forever. Called from sweepPendingCaptures, i.e. on
-// the cadence captures already run housekeeping. Best-effort: never throws.
 function pruneCaptureStateDir(deps = fs, dir = CAPTURE_STATE_DIR, now = Date.now()) {
     try {
         for (const f of deps.readdirSync(dir)) {
@@ -2822,25 +2432,13 @@ function pruneCaptureStateDir(deps = fs, dir = CAPTURE_STATE_DIR, now = Date.now
                     deps.unlinkSync(p);
             }
             catch {
-                // raced another pruner or unreadable — skip
             }
         }
     }
     catch {
-        // dir missing/unreadable — nothing to prune
     }
 }
-// Base64 length above which the transcript goes straight to storage instead
-// of inline in the captureSession JSON body. The backend's HTTP-action
-// isolate has a 64MB cap and inline base64 amplifies ~8x in memory (request
-// text + parsed JSON + decode output all resident) — ~7MB transcripts OOM it
-// (observed live 2026-07-02). 2M base64 chars ≈ 1.5MB raw: far below the
-// cliff, while per-turn snapshots (typically KBs) skip the extra roundtrips.
 exports.DIRECT_UPLOAD_THRESHOLD_CHARS = 2_000_000;
-// "Last session captured" breadcrumb. Written next to config.json on a
-// successful capture upload; read by `codiedev doctor` so a user can confirm
-// their most recent session actually landed (the single hardest thing to
-// self-verify today — it previously required eyeballing the portal).
 const LAST_CAPTURE_PATH = path.join(CONFIG_DIR, "last-capture.json");
 function buildLastCaptureRecord(job, now) {
     const b = job.body;
@@ -2863,7 +2461,6 @@ function writeLastCapture(record, deps = fs, filePath = LAST_CAPTURE_PATH) {
         deps.writeFileSync(filePath, JSON.stringify(record), { mode: 0o600 });
     }
     catch {
-        // breadcrumb is best-effort — never throw on the capture path.
     }
 }
 function readLastCapture(deps = fs, filePath = LAST_CAPTURE_PATH) {
@@ -2876,21 +2473,16 @@ function readLastCapture(deps = fs, filePath = LAST_CAPTURE_PATH) {
         return null;
     }
 }
-// Runs inside the detached child spawned by `dispatchCaptureDetached`: read the
-// persisted job, POST it, and ALWAYS delete the temp file afterwards (even on
-// failure) so we don't litter the tmp dir. Never throws — capture is
-// best-effort.
 async function runCaptureUpload(jobFile, deps) {
     let job = null;
     try {
         job = JSON.parse(deps.readFileSync(jobFile, "utf8"));
     }
     catch {
-        // unreadable/corrupt job — delete it and stop.
         try {
             deps.unlinkSync(jobFile);
         }
-        catch { /* gone */ }
+        catch { }
         return;
     }
     const sessionId = job.body?.sessionId;
@@ -2899,18 +2491,15 @@ async function runCaptureUpload(jobFile, deps) {
             try {
                 deps.log({ stage: "upload", sessionId, outcome: "skip", detail: "ignored-path" });
             }
-            catch { /* log is best-effort */ }
+            catch { }
         }
         try {
             deps.unlinkSync(jobFile);
         }
-        catch { /* gone */ }
+        catch { }
         return;
     }
     try {
-        // Big transcript + capable deps → direct-to-storage: fetch a one-time
-        // upload URL, PUT the raw bytes, send captureSession the storageId. Any
-        // step failing throws into the retry path below, same as a failed POST.
         let body = job.body;
         const transcript = body?.transcript;
         if (transcript &&
@@ -2922,49 +2511,39 @@ async function runCaptureUpload(jobFile, deps) {
             const { storageId } = await deps.uploadBytes(uploadUrl, Buffer.from(transcript, "base64"), "application/json");
             body = { ...body, transcriptStorageId: storageId };
             delete body.transcript;
-            // Persist the storage id before the metadata POST. Previously a failed
-            // captureSession request retried the entire direct upload, creating one
-            // unreferenced raw transcript blob per attempt. Once the PUT succeeds,
-            // every retry must reuse that exact blob.
             job.body = body;
             if (deps.writeFileSync) {
                 deps.writeFileSync(jobFile, JSON.stringify(job), { mode: 0o600 });
             }
         }
         await deps.post(job.url, body, job.token);
-        // success — drop a "last session captured" breadcrumb (before removing the
-        // job) so doctor can confirm the most recent session actually landed.
         if (deps.recordSuccess) {
             try {
                 deps.recordSuccess(job);
             }
-            catch { /* breadcrumb is best-effort */ }
+            catch { }
         }
-        // Write the per-session upload state so the throttle can defer the next
-        // non-final (per-turn) upload until the window expires.
         const uploadedSessionId = job.body?.sessionId;
         if (uploadedSessionId && deps.writeSessionState) {
             try {
                 deps.writeSessionState(uploadedSessionId, { lastUploadAt: deps.now ? deps.now() : Date.now() });
             }
-            catch { /* best-effort */ }
+            catch { }
         }
         const attempt = (job.attempts ?? 0) + 1;
         if (deps.log) {
             try {
                 deps.log({ stage: "upload", sessionId, outcome: "ok", detail: `attempt=${attempt}` });
             }
-            catch { /* log is best-effort */ }
+            catch { }
         }
         try {
             deps.unlinkSync(jobFile);
         }
-        catch { /* gone */ }
+        catch { }
         return;
     }
     catch (err) {
-        // Failure: keep the job for a later sweep to retry, UNLESS we've hit the
-        // attempt cap or TTL — then give up so /tmp doesn't accumulate forever.
         const now = deps.now ? deps.now() : Date.now();
         const attempts = (job.attempts ?? 0) + 1;
         const queuedAt = job.queuedAt ?? now;
@@ -2981,19 +2560,12 @@ async function runCaptureUpload(jobFile, deps) {
                         detail: `attempt=${attempts} age=${ageMs}ms`,
                     });
                 }
-                catch { /* log is best-effort */ }
+                catch { }
             }
-            // Unlink FIRST: if the skip ping below hangs (no timeout on injected
-            // post impls), a still-present job file would be reclaimed by the
-            // 15-min stale-claim sweep and re-enter this give-up path forever.
             try {
                 deps.unlinkSync(jobFile);
             }
-            catch { /* gone */ }
-            // Tell the server this capture is permanently lost and why. The full
-            // transcript POST may be what's blocked (proxy/DLP body inspection) —
-            // this tiny ping often still passes, turning an invisible loss into a
-            // per-reason bucket on the admin Capture Health panel.
+            catch { }
             if (sessionId) {
                 try {
                     const skipUrl = job.url.replace(/\/api\/captureSession$/, "/api/cli/sessionSkip");
@@ -3005,52 +2577,42 @@ async function runCaptureUpload(jobFile, deps) {
                         }, job.token);
                     }
                 }
-                catch { /* best-effort — the ping may be blocked too */ }
+                catch { }
             }
             return;
         }
-        // Log the error before persisting the retry bump.
         if (deps.log) {
             try {
                 const msg = err.message ?? String(err);
-                // Extract http=<status> when the error message carries one (format used
-                // by postJson: "HTTP <status>: <body>"). Truncate to 200 chars.
                 const httpMatch = msg.match(/\bhttp[= ](\d{3})\b/i);
                 const httpPart = httpMatch ? `http=${httpMatch[1]} ` : "";
                 const detail = `${httpPart}${msg.slice(0, 200)} attempt=${attempts}`;
                 deps.log({ stage: "upload", sessionId, outcome: "ERROR", detail });
             }
-            catch { /* log is best-effort */ }
+            catch { }
         }
-        // The sweep hands us a CLAIMED path (`<job>.claim-<pid>`). Persist the
-        // retry bump under the canonical name — the sweep only matches
-        // `codiedev-capture-*.json`, so a bump left on the claimed path would
-        // never be retried (a silently dropped capture).
         const canonical = jobFile.replace(/\.claim-\d+$/, "");
-        const writeFn = deps.writeFileSync; // always set here: giveUp branch checked !deps.writeFileSync
+        const writeFn = deps.writeFileSync;
         try {
             writeFn(canonical, JSON.stringify({ ...job, attempts, queuedAt }), { mode: 0o600 });
             if (canonical !== jobFile) {
                 try {
                     deps.unlinkSync(jobFile);
                 }
-                catch { /* gone */ }
+                catch { }
             }
         }
         catch {
-            // couldn't persist the bump — drop it rather than risk a stuck file.
             try {
                 deps.unlinkSync(jobFile);
             }
-            catch { /* gone */ }
+            catch { }
         }
     }
 }
 async function runDeferredUpload(jobFile, delayMs, deps) {
     const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     await sleep(delayMs);
-    // Claim via rename. If the file is gone or already claimed, a newer turn's
-    // upload superseded this one: log and exit silently.
     const claimed = `${jobFile}.claim-${process.pid}`;
     try {
         deps.renameSync(jobFile, claimed);
@@ -3058,33 +2620,24 @@ async function runDeferredUpload(jobFile, delayMs, deps) {
     catch {
         if (deps.log) {
             try {
-                // The job file is gone, so its body (and sessionId) is unreadable —
-                // recover the session id from the per-session filename so doctor can
-                // still tie this line to a session.
                 const sid = /^codiedev-capture-(.+)\.json/.exec(path.basename(jobFile))?.[1];
                 deps.log({ stage: "upload-deferred", sessionId: sid, outcome: "superseded" });
             }
-            catch { /* log is best-effort */ }
+            catch { }
         }
         return;
     }
     await runCaptureUpload(claimed, deps);
 }
-// Classify a transcript read failure at capture time. ENOENT = the transcript
-// never existed: a desktop-app phantom helper session (SessionStart/End hooks
-// fire, no conversation ever happens), not lost work — the backend excludes
-// "no-transcript" from coverage. Anything else means a real transcript was
-// there but the read failed: a genuine loss, tagged with the errno so it stays
-// diagnosable from the server side.
 function transcriptReadSkipReason(err) {
     const code = err?.code;
     if (code === "ENOENT")
         return "no-transcript";
     return `transcript-unreadable:${code || "unknown"}`;
 }
-// Per-turn snapshots are backups, not session endings. Reporting their local
-// read/empty condition as a session skip would hide or close coverage while the
-// agent is still running; only final/legacy capture paths emit the skip ping.
+function isCodexRolloutPath(transcriptPath) {
+    return Boolean(transcriptPath && /^rollout-.*\.jsonl$/.test(path.basename(transcriptPath)));
+}
 function shouldReportCaptureSkip(final) {
     return final !== false;
 }