codiedev 0.9.64 → 0.9.66

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;
@@ -144,10 +147,6 @@ export declare function installCursorMcp(): void;
  * 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).
  */
 export declare function installVSCodeMcp(): void;
 /**
@@ -356,4 +355,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
@@ -1457,14 +1502,12 @@ thought, use the \`codiedev\` CLI via Bash:**
 | "any messages?" / "check my inbox" / "what did a teammate say?" | \`codiedev inbox\` |
 | "read that reply" / "mark that ping read" | \`codiedev read <ping-id>\` |
 | "note that X is a follow-up" / "remember X" | \`codiedev note "<text>"\` |
-| "promote the extracted spec" | \`codiedev promote <artifact-id>\` |
 | "create a ticket" / "scope this into tickets" / "ticket this for me" | \`codiedev create-ticket [optional-inline-prompt]\` |
 | "share with a teammate" / "give someone access" (no notification) | \`codiedev share <key> <name> [--role read\\|edit]\` |
 | "send this to a teammate" / "ask someone to look at this" | \`codiedev send <key> <name> ["<msg>"]\` |
 | "find something about X" / "has anyone solved Y?" | \`codiedev search "<query>" [--limit N]\` |
 | "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>\` |
 
 **Just push the file — we'll figure out where it goes.** Every artifact
 is classified into one of two kinds at upload time:
@@ -1661,10 +1704,6 @@ function installCursorMcp() {
  * 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)) {
@@ -2132,7 +2171,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 +3115,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.66",
   "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",

package/dist/commands/promote.d.ts

@@ -1 +0,0 @@
-export declare function runPromote(args: string[]): Promise<void>;

package/dist/commands/promote.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runPromote = runPromote;
-const shared_1 = require("./shared");
-function parseArgs(args) {
-    let artifactId;
-    let keyOverride;
-    for (let i = 0; i < args.length; i++) {
-        const a = args[i];
-        if ((a === "--key" || a === "-k") && i + 1 < args.length) {
-            keyOverride = args[++i];
-        }
-        else if (a.startsWith("--key=")) {
-            keyOverride = a.slice("--key=".length);
-        }
-        else if (!a.startsWith("--") && !artifactId) {
-            artifactId = a;
-        }
-    }
-    if (!artifactId) {
-        console.error("Usage: codiedev promote <extracted-artifact-id> [--key spec-foo.md]");
-        process.exit(1);
-    }
-    return { artifactId, keyOverride };
-}
-async function runPromote(args) {
-    const { artifactId, keyOverride } = parseArgs(args);
-    const config = (0, shared_1.requireConfig)();
-    const start = Date.now();
-    try {
-        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/promote", {
-            config,
-            body: { artifactId, keyOverride },
-        });
-        (0, shared_1.recordAgentEvent)(config, {
-            tool: "codiedev_promote",
-            ok: true,
-            latencyMs: Date.now() - start,
-        });
-        console.log(`✓ Promoted to authored artifact ${res.key}`);
-        console.log(`  id: ${res.artifactId}`);
-    }
-    catch (err) {
-        (0, shared_1.recordAgentEvent)(config, {
-            tool: "codiedev_promote",
-            ok: false,
-            latencyMs: Date.now() - start,
-            error: err.message,
-        });
-        console.error(`Promote failed: ${err.message}`);
-        process.exit(1);
-    }
-}

package/dist/commands/react.d.ts

@@ -1,2 +0,0 @@
-import type { CodiedevConfig } from "../utils";
-export declare function runReact(args: string[], configOverride?: CodiedevConfig): Promise<void>;