codiedev 0.9.64 → 0.9.65

package/dist/captureLog.d.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 export declare const CAPTURE_LOG_MAX_BYTES: number;
 export declare const CAPTURE_LOG_PATH: string;
 export interface CaptureLogEntry {
-    stage: "capture-finish" | "upload" | "upload-deferred" | "stderr" | "limit";
+    stage: "capture-finish" | "upload" | "upload-deferred" | "stderr" | "limit" | "self-update";
     sessionId: string | undefined;
     outcome: string;
     detail?: string;

package/dist/hook.js

@@ -48,6 +48,7 @@ const limitEvent_1 = require("./limitEvent");
 const cursorLifecycle_1 = require("./cursorLifecycle");
 const codexLimitScan_1 = require("./codexLimitScan");
 const launchContext_1 = require("./launchContext");
+const selfUpdate_1 = require("./selfUpdate");
 const version_1 = require("./version");
 const captureLog_1 = require("./captureLog");
 const subagents_1 = require("./subagents");
@@ -527,6 +528,20 @@ async function main() {
         }
         process.exit(0);
     }
+    // Detached daily self-upgrade of this install (see selfUpdate.ts).
+    if (process.argv[2] === "self-update") {
+        await (0, selfUpdate_1.runSelfUpdate)(process.argv[1]);
+        process.exit(0);
+    }
+    // A hook reached directly (not via the stable launcher) means some harness
+    // config predates the launcher: move them all onto it once. Steady state is
+    // every call arriving via the launcher, which skips this entirely.
+    const migrated = process.env.CODIEDEV_VIA_LAUNCHER ? [] : (0, utils_1.migrateHooksToLauncher)();
+    // Every harness reaches this point, so one check covers all of them. Right
+    // after a migration, wait for the next call: it arrives via the launcher,
+    // which is what makes a pnpm install safe to upgrade.
+    if (migrated.length === 0)
+        (0, selfUpdate_1.maybeSpawnSelfUpdate)(process.argv[1]);
     let hookInput = {};
     try {
         const raw = await readStdin();
@@ -651,7 +666,7 @@ async function main() {
     // Same detached capture-finish child as SessionEnd, marked non-final so the
     // server renews the session lease instead of summarizing immediately.
     if (process.argv[2] === "backup" || process.argv[2] === "backup-cursor" || process.argv[2] === "backup-copilot") {
-        if (transcript_path) {
+        if (transcript_path && !(0, utils_1.isCodexRolloutPath)(transcript_path)) {
             try {
                 (0, utils_1.dispatchCaptureFinish)({
                     mode: process.argv[2] === "backup-cursor"

package/dist/launcher.d.ts

@@ -0,0 +1,20 @@
+export declare const LAUNCHER_FILE = "codiedev-hook-launcher.cjs";
+export interface InstallRecord {
+    hookScript: string;
+    version?: string;
+    recordedAt: number;
+}
+export declare function launcherPath(): string;
+/** True iff `cmd` invokes the stable launcher (from any state dir). */
+export declare function usesLauncher(cmd: string | undefined): boolean;
+export declare function readInstallRecord(): InstallRecord | null;
+/** Point the launcher at `hookScript`. Atomic, so a hook mid-launch never reads half a file. */
+export declare function recordCurrentInstall(hookScript: string): boolean;
+/**
+ * Make sure the launcher exists and forwards to `hookScript`, returning the
+ * launcher path to bake into hook configs — or null if the state dir is not
+ * writable, in which case callers keep baking the direct path. Memoized:
+ * one connect writes ~20 hook entries.
+ */
+export declare function ensureLauncher(hookScript: string): string | null;
+export declare function resetLauncherCacheForTests(): void;

package/dist/launcher.js

@@ -0,0 +1,167 @@
+"use strict";
+// Stable hook launcher.
+//
+// Harness configs used to bake the absolute path of whichever install ran
+// `connect` (…/node_modules/codiedev/dist/hook.js). That path is only stable
+// for npm/bun globals: pnpm puts every global install in a fresh hashed dir,
+// and repo checkouts, Homebrew cellar moves, etc. can strand it too. Instead,
+// every hook config points at one file we own —
+// <codiedevStateDir()>/bin/codiedev-hook-launcher.cjs — which forwards to the
+// install recorded in <codiedevStateDir()>/install.json. Moving to a new
+// install (self-update, re-connect) rewrites one JSON file, never the
+// harness configs, so Codex hook trust and IT-managed dotfiles stay put.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAUNCHER_FILE = void 0;
+exports.launcherPath = launcherPath;
+exports.usesLauncher = usesLauncher;
+exports.readInstallRecord = readInstallRecord;
+exports.recordCurrentInstall = recordCurrentInstall;
+exports.ensureLauncher = ensureLauncher;
+exports.resetLauncherCacheForTests = resetLauncherCacheForTests;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const configDir_1 = require("./configDir");
+exports.LAUNCHER_FILE = "codiedev-hook-launcher.cjs";
+// Bump when LAUNCHER_SOURCE changes so existing launchers get rewritten.
+const LAUNCHER_REVISION = 1;
+function launcherPath() {
+    return path.join((0, configDir_1.codiedevStateDir)(), "bin", exports.LAUNCHER_FILE);
+}
+function installRecordPath() {
+    return path.join((0, configDir_1.codiedevStateDir)(), "install.json");
+}
+/** True iff `cmd` invokes the stable launcher (from any state dir). */
+function usesLauncher(cmd) {
+    return typeof cmd === "string" && cmd.includes(exports.LAUNCHER_FILE);
+}
+// Plain CommonJS with no dependencies: it runs under whatever node the harness
+// config names, before any of our modules load. `fallback` is the install the
+// launcher was written for, used if install.json is missing or points at a
+// directory that no longer exists. If neither exists it exits 0 so a stranded
+// hook can never fail the developer's session.
+function launcherSource(fallback) {
+    return `// codiedev-hook-launcher revision ${LAUNCHER_REVISION}. Managed by codiedev; safe to delete (re-run \`codiedev connect\`).
+"use strict";
+const fs = require("fs");
+const path = require("path");
+const FALLBACK = ${JSON.stringify(fallback)};
+let target = null;
+try {
+  const rec = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "install.json"), "utf8"));
+  if (rec && typeof rec.hookScript === "string" && fs.existsSync(rec.hookScript)) target = rec.hookScript;
+} catch {}
+if (!target && fs.existsSync(FALLBACK)) target = FALLBACK;
+if (!target) process.exit(0);
+process.env.CODIEDEV_VIA_LAUNCHER = "1";
+process.argv[1] = target;
+require(target);
+`;
+}
+function writeAtomic(target, contents) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const tmp = `${target}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, contents, "utf8");
+    fs.renameSync(tmp, target);
+}
+function readInstallRecord() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(installRecordPath(), "utf8"));
+        return typeof parsed.hookScript === "string" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function packageVersionFor(hookScript) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(path.dirname(path.dirname(hookScript)), "package.json"), "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Point the launcher at `hookScript`. Atomic, so a hook mid-launch never reads half a file. */
+function recordCurrentInstall(hookScript) {
+    try {
+        const record = {
+            hookScript,
+            version: packageVersionFor(hookScript),
+            recordedAt: Date.now(),
+        };
+        writeAtomic(installRecordPath(), JSON.stringify(record, null, 2));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+let ensuredFor;
+/**
+ * Make sure the launcher exists and forwards to `hookScript`, returning the
+ * launcher path to bake into hook configs — or null if the state dir is not
+ * writable, in which case callers keep baking the direct path. Memoized:
+ * one connect writes ~20 hook entries.
+ */
+function ensureLauncher(hookScript) {
+    if (ensuredFor !== undefined && ensuredFor === hookScript)
+        return launcherPath();
+    try {
+        const target = launcherPath();
+        const source = launcherSource(hookScript);
+        let current = null;
+        try {
+            current = fs.readFileSync(target, "utf8");
+        }
+        catch {
+            // first install
+        }
+        if (current !== source)
+            writeAtomic(target, source);
+        if (readInstallRecord()?.hookScript !== hookScript && !recordCurrentInstall(hookScript)) {
+            return null;
+        }
+        ensuredFor = hookScript;
+        return target;
+    }
+    catch {
+        return null;
+    }
+}
+// Test-only: the memo lives for the process lifetime.
+function resetLauncherCacheForTests() {
+    ensuredFor = undefined;
+}

package/dist/selfUpdate.d.ts

@@ -0,0 +1,49 @@
+export type SelfUpdatePlan = {
+    kind: "npm";
+    prefix: string;
+} | {
+    kind: "pnpm";
+} | {
+    kind: "bun";
+} | {
+    kind: "skip";
+    reason: string;
+};
+export interface PlanDeps {
+    hookScriptReal: string;
+    env: NodeJS.ProcessEnv;
+    platform: NodeJS.Platform;
+    isContainer: boolean;
+    isWritable: (dir: string) => boolean;
+    viaLauncher?: boolean;
+}
+/**
+ * Decide which package manager owns this install, from where hook.js really
+ * lives. We only ever upgrade the install we are running from: running
+ * whatever `npm` is first on PATH would, under nvm/Homebrew mixes, upgrade a
+ * different global tree than the one the harness config points at.
+ */
+export declare function planSelfUpdate(deps: PlanDeps): SelfUpdatePlan;
+export interface SelfUpdateState {
+    lastAttemptAt: number;
+    lastResult?: string;
+    fromVersion?: string;
+    toVersion?: string;
+}
+export declare function isSelfUpdateDue(state: SelfUpdateState | null, nowMs: number): boolean;
+export declare function readSelfUpdateState(): SelfUpdateState | null;
+/**
+ * Called on every hook invocation, so the not-due path is one small file read.
+ * Stamps the attempt before spawning so a burst of parallel hooks spawns one
+ * child, not one each; the child's lock covers whatever still slips through.
+ */
+export declare function maybeSpawnSelfUpdate(hookEntry: string | undefined): void;
+/**
+ * Where the just-installed copy lives. npm/bun reinstall in place. pnpm's
+ * `root -g` is <root>/node_modules up to v10 but the bare global/v11 parent
+ * from v11 on, with each install in a hashed child — so check both shapes and
+ * take the copy that is actually at the version we just installed.
+ */
+export declare function findInstalledHookScript(plan: SelfUpdatePlan, hookEntry: string, version: string, pnpmRoot?: () => string | null): string | null;
+/** Body of the detached `codiedev-hook self-update` child. Never throws. */
+export declare function runSelfUpdate(hookEntry: string): Promise<SelfUpdateState>;

package/dist/selfUpdate.js

@@ -0,0 +1,390 @@
+"use strict";
+// Background self-update for the hook path.
+//
+// Onboarded developers never run `connect`/`doctor`/`codie` again — only the
+// harness hooks fire — so the interactive nudges in upgradeNudge.ts never
+// reach them. This module lets any hook invocation spawn a detached child
+// (at most once per day) that upgrades the exact install the hook is running
+// from. Harness configs bake the absolute path to dist/hook.js, so the next
+// hook call picks up the new code with no config change.
+//
+// Split like versionCheck.ts: `planSelfUpdate` is pure and unit-tested; the IO
+// (state file, lock, registry fetch, package-manager spawn) is below it.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planSelfUpdate = planSelfUpdate;
+exports.isSelfUpdateDue = isSelfUpdateDue;
+exports.readSelfUpdateState = readSelfUpdateState;
+exports.maybeSpawnSelfUpdate = maybeSpawnSelfUpdate;
+exports.findInstalledHookScript = findInstalledHookScript;
+exports.runSelfUpdate = runSelfUpdate;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const version_1 = require("./version");
+const versionCheck_1 = require("./versionCheck");
+const configDir_1 = require("./configDir");
+const captureLog_1 = require("./captureLog");
+const launcher_1 = require("./launcher");
+const PKG = "codiedev";
+const DAY_MS = 24 * 60 * 60 * 1000;
+const LOCK_STALE_MS = 10 * 60 * 1000;
+const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 5_000;
+/**
+ * Decide which package manager owns this install, from where hook.js really
+ * lives. We only ever upgrade the install we are running from: running
+ * whatever `npm` is first on PATH would, under nvm/Homebrew mixes, upgrade a
+ * different global tree than the one the harness config points at.
+ */
+function planSelfUpdate(deps) {
+    const { env } = deps;
+    if (env.CODIEDEV_NO_UPDATE_CHECK || env.CODIEDEV_NO_AUTO_UPDATE) {
+        return { kind: "skip", reason: "disabled" };
+    }
+    if (env.CI || env.CONTINUOUS_INTEGRATION || env.GITHUB_ACTIONS || env.BUILD_NUMBER) {
+        return { kind: "skip", reason: "ci" };
+    }
+    if (deps.isContainer)
+        return { kind: "skip", reason: "container" };
+    const p = deps.hookScriptReal.replace(/\\/g, "/");
+    if (/\/(?:_npx|\.npm\/_npx)\//.test(p))
+        return { kind: "skip", reason: "npx" };
+    const pkgDir = path.dirname(path.dirname(deps.hookScriptReal));
+    if (!deps.isWritable(pkgDir))
+        return { kind: "skip", reason: "readonly" };
+    // pnpm puts every global install in a fresh hashed dir
+    // (global/v11/<hash>/node_modules/codiedev). That is only safe to upgrade
+    // when the hook runs through the stable launcher, which runSelfUpdate
+    // re-points at the new dir; a direct-path config would stay on the old copy.
+    if (/\/\.pnpm\/|\/pnpm\/global\/|\/global\/v\d+\/[^/]+\/node_modules\/codiedev\/|\/store\/v\d+\/links\//.test(p)) {
+        return deps.viaLauncher ? { kind: "pnpm" } : { kind: "skip", reason: "pnpm-direct" };
+    }
+    // $BUN_INSTALL/install/global — ~/.bun by default, but BUN_INSTALL is often
+    // customized, so match the layout rather than the directory name.
+    if (/\/install\/global\/node_modules\/codiedev\/dist\/hook\.js$/.test(p))
+        return { kind: "bun" };
+    // npm global: <prefix>/lib/node_modules/codiedev/dist/hook.js on unix,
+    // <prefix>/node_modules/codiedev/dist/hook.js on Windows.
+    const unix = p.match(/^(.*)\/lib\/node_modules\/codiedev\/dist\/hook\.js$/);
+    if (unix && deps.platform !== "win32")
+        return { kind: "npm", prefix: unix[1] };
+    const win = p.match(/^(.*)\/node_modules\/codiedev\/dist\/hook\.js$/);
+    if (win && deps.platform === "win32")
+        return { kind: "npm", prefix: win[1] };
+    // A repo checkout, a project-local install, or a layout we don't know.
+    return { kind: "skip", reason: "unmanaged" };
+}
+function isSelfUpdateDue(state, nowMs) {
+    return !state || nowMs - state.lastAttemptAt > DAY_MS;
+}
+function statePath() {
+    return path.join((0, configDir_1.codiedevStateDir)(), ".self-update.json");
+}
+function lockPath() {
+    return path.join((0, configDir_1.codiedevStateDir)(), ".self-update.lock");
+}
+function readSelfUpdateState() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(statePath(), "utf8"));
+        return typeof parsed.lastAttemptAt === "number" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeState(state) {
+    try {
+        fs.mkdirSync((0, configDir_1.codiedevStateDir)(), { recursive: true });
+        fs.writeFileSync(statePath(), JSON.stringify(state), "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Called on every hook invocation, so the not-due path is one small file read.
+ * Stamps the attempt before spawning so a burst of parallel hooks spawns one
+ * child, not one each; the child's lock covers whatever still slips through.
+ */
+function maybeSpawnSelfUpdate(hookEntry) {
+    try {
+        if (!hookEntry || process.env.CODIEDEV_NO_AUTO_UPDATE || process.env.CODIEDEV_NO_UPDATE_CHECK)
+            return;
+        const now = Date.now();
+        if (!isSelfUpdateDue(readSelfUpdateState(), now))
+            return;
+        if (!writeState({ lastAttemptAt: now, lastResult: "spawned" }))
+            return;
+        const child = (0, child_process_1.spawn)(process.execPath, [hookEntry, "self-update"], {
+            detached: true,
+            stdio: "ignore",
+            // detached on Windows opens a console window unless hidden.
+            windowsHide: true,
+        });
+        child.unref();
+    }
+    catch {
+        // Best-effort; a failed spawn retries tomorrow.
+    }
+}
+function acquireLock() {
+    const lock = lockPath();
+    try {
+        fs.mkdirSync(lock);
+        return true;
+    }
+    catch {
+        try {
+            if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) {
+                fs.rmSync(lock, { recursive: true, force: true });
+                fs.mkdirSync(lock);
+                return true;
+            }
+        }
+        catch {
+            // Lost the race to another child.
+        }
+        return false;
+    }
+}
+function detectContainer(env) {
+    if (env.KUBERNETES_SERVICE_HOST)
+        return true;
+    // /run/.containerenv is podman's marker (e.g. Sonifi's dev containers);
+    // cgroup v2 hosts report a bare "0::/" there, so the cgroup probe misses it.
+    if (fs.existsSync("/.dockerenv") || fs.existsSync("/run/.containerenv"))
+        return true;
+    try {
+        return /docker|containerd|kubepods|lxc/.test(fs.readFileSync("/proc/1/cgroup", "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+function registryBase(env) {
+    const configured = env.npm_config_registry || env.NPM_CONFIG_REGISTRY;
+    return (configured || "https://registry.npmjs.org").replace(/\/+$/, "");
+}
+async function fetchLatest(env) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const res = await fetch(`${registryBase(env)}/${PKG}/latest`, {
+            headers: { Accept: "application/json" },
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            return null;
+        const json = (await res.json());
+        return typeof json.version === "string" ? json.version : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function installCommand(plan, version, env) {
+    const spec = `${PKG}@${version}`;
+    // Pass an env-level registry override explicitly so the install always
+    // hits the registry fetchLatest just read from (not every manager honors
+    // npm_config_registry for global installs).
+    const configured = env.npm_config_registry || env.NPM_CONFIG_REGISTRY;
+    const registry = configured ? ["--registry", registryBase(env)] : [];
+    switch (plan.kind) {
+        case "npm": {
+            const args = ["i", "-g", "--prefix", plan.prefix, "--no-fund", "--no-audit", ...registry, spec];
+            // Run the npm that ships beside the node running us (it owns this
+            // prefix even when PATH resolves a different node), through its JS
+            // entry. That avoids spawning npm.cmd, which on Windows needs a shell
+            // and would split a prefix like C:\Users\First Last\… on the space.
+            const execDir = path.dirname(process.execPath);
+            const npmCli = [
+                path.join(execDir, "node_modules", "npm", "bin", "npm-cli.js"),
+                path.join(execDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+            ].find((p) => fs.existsSync(p));
+            if (npmCli)
+                return { cmd: process.execPath, args: [npmCli, ...args] };
+            return { cmd: process.platform === "win32" ? "npm.cmd" : "npm", args, shell: process.platform === "win32" };
+        }
+        case "pnpm":
+            // pnpm on Windows is usually a .cmd shim; these args carry no paths.
+            return { cmd: "pnpm", args: ["add", "-g", ...registry, spec], shell: process.platform === "win32" };
+        case "bun":
+            return { cmd: "bun", args: ["add", "-g", ...registry, spec] };
+        default:
+            return null;
+    }
+}
+function readVersionAt(hookScript) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(path.dirname(path.dirname(hookScript)), "package.json"), "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Where the just-installed copy lives. npm/bun reinstall in place. pnpm's
+ * `root -g` is <root>/node_modules up to v10 but the bare global/v11 parent
+ * from v11 on, with each install in a hashed child — so check both shapes and
+ * take the copy that is actually at the version we just installed.
+ */
+function findInstalledHookScript(plan, hookEntry, version, pnpmRoot = pnpmGlobalRoot) {
+    if (plan.kind !== "pnpm")
+        return readVersionAt(hookEntry) === version ? hookEntry : null;
+    const root = pnpmRoot();
+    if (!root)
+        return null;
+    const candidates = [path.join(root, PKG, "dist", "hook.js")];
+    try {
+        for (const entry of fs.readdirSync(root)) {
+            candidates.push(path.join(root, entry, "node_modules", PKG, "dist", "hook.js"));
+        }
+    }
+    catch {
+        // root vanished between calls
+    }
+    for (const candidate of candidates) {
+        if (readVersionAt(candidate) !== version)
+            continue;
+        try {
+            return fs.realpathSync(candidate);
+        }
+        catch {
+            // dangling link; keep looking
+        }
+    }
+    return null;
+}
+function pnpmGlobalRoot() {
+    const root = (0, child_process_1.spawnSync)("pnpm", ["root", "-g"], {
+        encoding: "utf8",
+        timeout: 30_000,
+        shell: process.platform === "win32",
+        windowsHide: true,
+    });
+    const dir = root.status === 0 ? root.stdout.trim() : "";
+    return dir || null;
+}
+/** Body of the detached `codiedev-hook self-update` child. Never throws. */
+async function runSelfUpdate(hookEntry) {
+    const env = process.env;
+    const now = Date.now();
+    const finish = (lastResult, extra = {}) => {
+        const state = { lastAttemptAt: now, lastResult, fromVersion: version_1.CLI_VERSION, ...extra };
+        writeState(state);
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "self-update",
+            sessionId: undefined,
+            outcome: lastResult.startsWith("error") ? "ERROR" : "ok",
+            detail: `result=${lastResult} from=${version_1.CLI_VERSION} to=${extra.toVersion ?? "-"} elapsedMs=${Date.now() - now}`,
+        });
+        return state;
+    };
+    let hookScriptReal;
+    try {
+        hookScriptReal = fs.realpathSync(hookEntry);
+    }
+    catch {
+        return finish("skip:unresolved");
+    }
+    const plan = planSelfUpdate({
+        hookScriptReal,
+        env,
+        platform: process.platform,
+        isContainer: detectContainer(env),
+        viaLauncher: Boolean(env.CODIEDEV_VIA_LAUNCHER),
+        isWritable: (dir) => {
+            try {
+                fs.accessSync(dir, fs.constants.W_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    });
+    if (plan.kind === "skip")
+        return finish(`skip:${plan.reason}`);
+    if (!acquireLock()) {
+        // Another child is mid-install and owns the state file; overwriting it
+        // here would report "skip:locked" while that install is still running.
+        (0, captureLog_1.appendCaptureLog)({ stage: "self-update", sessionId: undefined, outcome: "ok", detail: "result=skip:locked" });
+        return { lastAttemptAt: now, lastResult: "skip:locked" };
+    }
+    try {
+        const latest = await fetchLatest(env);
+        if (!latest)
+            return finish("error:registry");
+        if ((0, versionCheck_1.compareSemver)(version_1.CLI_VERSION, latest) !== -1)
+            return finish("current", { toVersion: latest });
+        const install = installCommand(plan, latest, env);
+        if (!install)
+            return finish("skip:no-installer");
+        const result = (0, child_process_1.spawnSync)(install.cmd, install.args, {
+            stdio: "ignore",
+            timeout: INSTALL_TIMEOUT_MS,
+            env: { ...env, CODIEDEV_NO_AUTO_UPDATE: "1" },
+            shell: install.shell ?? false,
+            windowsHide: true,
+        });
+        if (result.error || result.status !== 0) {
+            return finish(`error:install-exit-${result.status ?? "spawn"}`, { toVersion: latest });
+        }
+        // Re-point the launcher. npm/bun reinstall in place; pnpm lands in a new
+        // hashed dir. Only switch once the new copy is on disk at the new version,
+        // so a half-finished install can never strand the hooks.
+        const installed = findInstalledHookScript(plan, hookScriptReal, latest);
+        if (!installed) {
+            return finish("error:not-found-after-install", { toVersion: latest });
+        }
+        if (!(0, launcher_1.recordCurrentInstall)(installed))
+            return finish("error:record", { toVersion: latest });
+        return finish("updated", { toVersion: latest });
+    }
+    finally {
+        try {
+            fs.rmSync(lockPath(), { recursive: true, force: true });
+        }
+        catch {
+            // A stale lock self-expires after LOCK_STALE_MS.
+        }
+    }
+}

package/dist/utils.d.ts

@@ -120,6 +120,9 @@ export declare function ensureDiscoveryHookInstalled(): void;
 export declare function ensureBackupHookInstalled(): void;
 export declare function ensureLimitHookInstalled(): void;
 export declare function ensureAllCodiedevHooksInstalled(): void;
+/** Exported for unit testing. */
+export declare function hasDirectHookPath(configText: string): boolean;
+export declare function migrateHooksToLauncher(): string[];
 export declare function ensureSessionStartHookInstalled(): void;
 export declare function installClaudeCodeInstructions(): void;
 export declare function installCodexInstructions(): void;
@@ -356,4 +359,5 @@ interface DeferredUploadDeps extends UploadDeps {
 }
 export declare function runDeferredUpload(jobFile: string, delayMs: number, deps: DeferredUploadDeps): Promise<void>;
 export declare function transcriptReadSkipReason(err: unknown): string;
+export declare function isCodexRolloutPath(transcriptPath: string | undefined): boolean;
 export declare function shouldReportCaptureSkip(final: boolean | undefined): boolean;

package/dist/utils.js

@@ -71,6 +71,8 @@ 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;
@@ -119,6 +121,7 @@ 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");
@@ -130,6 +133,7 @@ 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");
@@ -1019,7 +1023,10 @@ 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] };
+                // Bake the stable launcher, not this install's path, so later
+                // upgrades (including pnpm's hashed dirs) never strand the hook.
+                const launcher = (0, launcher_1.ensureLauncher)(hookScript);
+                return { command: nodePath, args: [launcher ?? hookScript, subcommand] };
             }
         }
     }
@@ -1392,6 +1399,44 @@ function ensureAllCodiedevHooksInstalled() {
         // Best-effort — never block a session on self-heal.
     }
 }
+// Matches a hook config that bakes an install's own dist/hook.js rather than
+// the stable launcher (see launcher.ts). Runs on raw file text, where JSON
+// doubles Windows separators (codiedev\\dist\\hook.js), hence `+`.
+const DIRECT_HOOK_PATH = /codiedev[^"'\s/\\]*[\\/]+dist[\\/]+hook\.js/;
+/** Exported for unit testing. */
+function hasDirectHookPath(configText) {
+    return DIRECT_HOOK_PATH.test(configText);
+}
+// Move configs written before the launcher existed onto it, by re-running each
+// harness's own installer (which, for Codex, also re-trusts the new commands).
+// Only harnesses that already carry a direct-path codiedev hook are touched,
+// each in isolation. Bails when the launcher can't be written, so a read-only
+// state dir doesn't rewrite every config on every hook call.
+function migrateHooksToLauncher() {
+    const probe = resolveHookInvocation("session-start");
+    if (!(0, launcher_1.usesLauncher)(probe.args[0]))
+        return [];
+    const targets = [
+        ["claude-code", CLAUDE_SETTINGS_PATH, installHook],
+        ["codex", CODEX_HOOKS_PATH, installCodexHook],
+        ["cursor", CURSOR_HOOKS_PATH, installCursorHook],
+        ["copilot", copilotHooksPath(), installCopilotHook],
+        ["opencode", OPENCODE_PLUGIN_PATH, installOpenCodeCapturePlugin],
+    ];
+    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 {
+            // Best-effort per harness; the next direct-path hook call retries.
+        }
+    }
+    return migrated;
+}
 function hasCodiedevHook(hooks, eventName) {
     const entries = hooks[eventName] ?? [];
     // A malformed (non-array) event value would make `.some` throw and — under
@@ -2132,7 +2177,37 @@ function parseClaudeUsage(content) {
     }
     const sum = (field) => models.reduce((total, usage) => total + usage[field], 0);
     const cacheReadTokens = sum("cacheReadTokens"), cacheCreationTokens = sum("cacheCreationTokens");
-    return { inputTokens: sum("inputTokens"), outputTokens: sum("outputTokens"),
+    const stats = { inputTokens: sum("inputTokens"), outputTokens: sum("outputTokens"),
+        cacheTokens: cacheReadTokens + cacheCreationTokens, cacheReadTokens, cacheCreationTokens, model };
+    return model ? stats : fromClaudeCostState(content, stats);
+}
+// Some Claude Code transcripts carry no assistant records, only a closing
+// `cost-state` whose `modelUsage` is keyed by model id. Without it these
+// sessions upload with no model and trip harness health model_missing.
+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 { /* partial records */ }
+    }
+    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;
+    // A session that switched models names the one that did most of the work.
+    const [model] = entries.reduce((best, entry) => n(entry[1].outputTokens) > n(best[1].outputTokens) ? entry : best);
+    // Assistant records, when present, already counted tokens; never add twice.
+    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) {
@@ -3046,6 +3121,13 @@ function transcriptReadSkipReason(err) {
         return "no-transcript";
     return `transcript-unreadable:${code || "unknown"}`;
 }
+// Codex's Stop hook also runs the plain `backup` command for artifact backup.
+// Its transcript is a Codex rollout, already captured per turn by
+// capture-codex; parsing it as Claude Code would upload an empty duplicate
+// session with no model under source claude-code.
+function isCodexRolloutPath(transcriptPath) {
+    return Boolean(transcriptPath && /^rollout-.*\.jsonl$/.test(path.basename(transcriptPath)));
+}
 // 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.64",
+  "version": "0.9.65",
   "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",