codiedev 0.9.33 → 0.9.35

package/dist/codie.js

@@ -53,6 +53,7 @@ const configDir_1 = require("./configDir");
 const codieLauncher_1 = require("./codieLauncher");
 const codieRuntime_1 = require("./codieRuntime");
 const codieRuntimeInstall_1 = require("./codieRuntimeInstall");
+const upgradeNudge_1 = require("./upgradeNudge");
 function git(args) {
     const result = (0, child_process_1.spawnSync)("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
     return result.status === 0 ? result.stdout.trim() : "";
@@ -177,6 +178,14 @@ async function main() {
     if (!key) {
         throw new Error("Connect your Codiedev account first with `codiedev connect`");
     }
+    // Before anything paints: once the OpenCode engine owns stdio, a prompt is
+    // unreadable. A successful in-place upgrade relaunches this command with the
+    // new package, so the stale process must stop here.
+    const update = await (0, upgradeNudge_1.maybeOfferUpgrade)();
+    if (update.relaunched) {
+        process.exitCode = update.status ?? 0;
+        return;
+    }
     const gatewayUrl = process.env.CODIEDEV_GATEWAY_URL || "https://gateway.codiedev.com/api/v1";
     const catalog = await (0, codieLauncher_1.fetchApprovedCatalog)({ baseUrl: gatewayUrl, key });
     const parsed = (0, codieLauncher_1.parseCodieArgs)(process.argv.slice(2));
@@ -222,7 +231,8 @@ async function main() {
         CODIEDEV_HEAD_SHA: git(["rev-parse", "HEAD"]),
         OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
     };
-    const result = (0, child_process_1.spawnSync)(runtime, parsed.args, { stdio: "inherit", env });
+    const runtimeArgs = (0, codieLauncher_1.withCodieWorkingDirectory)(parsed.args, process.cwd());
+    const result = (0, child_process_1.spawnSync)(runtime, runtimeArgs, { stdio: "inherit", env });
     if (result.error)
         throw result.error;
     process.exitCode = result.status === null ? 1 : result.status;

package/dist/codieLauncher.d.ts

@@ -2,6 +2,13 @@ export interface CatalogModel {
     id: string;
     name?: string;
 }
+/**
+ * Pin non-interactive runs to the directory where `codie` was launched.
+ * OpenCode can reuse a previously-known project instance; without an explicit
+ * --dir, a real smoke run launched in a throwaway repo resumed the caller's
+ * main checkout and executed there. TUI mode already owns its cwd directly.
+ */
+export declare function withCodieWorkingDirectory(args: string[], cwd: string): string[];
 export declare function bareModel(value: unknown): string;
 export declare function buildCodieConfig({ existing, catalog, env, plugin, plugins, }: {
     existing?: Record<string, any>;

package/dist/codieLauncher.js

@@ -43,6 +43,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HIDDEN_WORDMARK = exports.CODIEDEV_WORDMARK = exports.LEGACY_CODIEDEV_WORDMARK = exports.STOCK_WORDMARK = exports.BRAND_PLUGIN_SPEC = void 0;
+exports.withCodieWorkingDirectory = withCodieWorkingDirectory;
 exports.bareModel = bareModel;
 exports.buildCodieConfig = buildCodieConfig;
 exports.withBrandPlugin = withBrandPlugin;
@@ -61,6 +62,19 @@ const DEFAULT_NAMES = {
     "z-ai/glm-5.2": "GLM 5.2 · Fireworks ZDR",
     "moonshotai/kimi-k2.7-code": "Kimi K2.7 Code · Fireworks ZDR",
 };
+/**
+ * Pin non-interactive runs to the directory where `codie` was launched.
+ * OpenCode can reuse a previously-known project instance; without an explicit
+ * --dir, a real smoke run launched in a throwaway repo resumed the caller's
+ * main checkout and executed there. TUI mode already owns its cwd directly.
+ */
+function withCodieWorkingDirectory(args, cwd) {
+    if (args[0] !== "run")
+        return args;
+    if (args.some((arg) => arg === "--dir" || arg.startsWith("--dir=")))
+        return args;
+    return [...args, "--dir", cwd];
+}
 function cleanBaseUrl(value) {
     return String(value || "https://gateway.codiedev.com/api/v1").replace(/\/+$/, "");
 }

package/dist/hook.js

@@ -661,6 +661,7 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     // worktree's branch+sha so all the resulting PRs attribute. branch/headSha
     // remain the primary (most-recent) values for back-compat.
     const keys = (0, utils_1.collectCaptureKeys)(captureDirs);
+    const gitRefs = (0, utils_1.collectCaptureGitRefs)(captureDirs);
     // Union the worktree-dir branches with the branches the agent actually
     // committed/pushed to (parsed from the transcript's git output). Like the
     // SHAs below, these are independent of end-of-session filesystem state, so
@@ -678,6 +679,7 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     const authoredShas = (0, utils_1.parseAuthoredShas)(transcriptContent, workspaceRoot);
     const headShas = [...new Set([...keys.headShas, ...authoredShas])];
     const headSha = keys.headSha ?? headShas[0] ?? null;
+    const pullRequestUrls = (0, utils_1.parsePullRequestUrls)(transcriptContent);
     // Cost/velocity/steering signals parsed straight from the transcript we're
     // already holding — no extra hooks, no extra git/process calls. parseUsage
     // keeps the literal mode (it has its own desktop parser) and reads the RAW
@@ -700,6 +702,8 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         headSha,
         branches,
         headShas,
+        gitRefs,
+        pullRequestUrls,
         inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens,
         cacheTokens: usage.cacheTokens,

package/dist/upgradeNudge.d.ts

@@ -5,3 +5,20 @@
  * this feature existed.
  */
 export declare function maybePrintUpgradeNudge(): Promise<void>;
+export interface OfferOpts {
+    env?: NodeJS.ProcessEnv;
+    argv?: string[];
+    nowMs?: number;
+    fetchImpl?: typeof fetch;
+    log?: (line: string) => void;
+    isTty?: boolean;
+}
+/**
+ * Prompt-capable sibling of maybePrintUpgradeNudge. Call this before handing
+ * the terminal to a TUI. A successful upgrade relaunches the fresh CLI and
+ * tells the stale caller to stop rather than continuing with old modules.
+ */
+export declare function maybeOfferUpgrade(opts?: OfferOpts): Promise<{
+    relaunched: boolean;
+    status?: number;
+}>;

package/dist/upgradeNudge.js

@@ -43,8 +43,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.maybePrintUpgradeNudge = maybePrintUpgradeNudge;
+exports.maybeOfferUpgrade = maybeOfferUpgrade;
 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");
@@ -122,3 +124,190 @@ async function maybePrintUpgradeNudge() {
         console.log("");
     }
 }
+const OFFER_CACHE_NAME = ".update-offer-cache.json";
+// This runs before the harness paints, so the timeout is startup latency the
+// user feels. A missed check costs nothing; the next stale-cache launch tries
+// again.
+const OFFER_FETCH_TIMEOUT_MS = 1500;
+const UPGRADE_TIMEOUT_MS = 120_000;
+function offerCachePath(env) {
+    const base = env.CODIEDEV_CONFIG_DIR?.trim()
+        ? path.resolve(env.CODIEDEV_CONFIG_DIR.trim())
+        : (0, configDir_1.codiedevStateDir)();
+    return path.join(base, OFFER_CACHE_NAME);
+}
+function readOfferCache(env) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(offerCachePath(env), "utf8"));
+        if (typeof parsed.fetchedAt !== "number")
+            return null;
+        return {
+            latest: typeof parsed.latest === "string" ? parsed.latest : null,
+            fetchedAt: parsed.fetchedAt,
+            promptedAt: typeof parsed.promptedAt === "number" ? parsed.promptedAt : 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// If this cannot be persisted, the whole feature stays off. Without memory,
+// every launch would refetch and re-nag on ephemeral or read-only filesystems.
+function writeOfferCache(entry, env) {
+    try {
+        const target = offerCachePath(env);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, JSON.stringify(entry), "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isCiEnvironment(env) {
+    return Boolean(env.CI || env.CONTINUOUS_INTEGRATION || env.GITHUB_ACTIONS || env.BUILD_NUMBER);
+}
+async function fetchLatest(fetchImpl) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), OFFER_FETCH_TIMEOUT_MS);
+        try {
+            const res = await fetchImpl(REGISTRY_URL, {
+                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;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    catch {
+        return null;
+    }
+}
+// Single-keypress y/n prompt. EOF, Ctrl-C, lost raw mode, and tty errors all
+// default to no so update handling can never strand the launcher.
+function promptYesNo(question) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        process.stdout.write(question);
+        const wasRaw = stdin.isRaw;
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            process.stdout.write("\n");
+            resolve(false);
+            return;
+        }
+        stdin.resume();
+        let settled = false;
+        const settle = (yes) => {
+            if (settled)
+                return;
+            settled = true;
+            stdin.removeListener("data", onData);
+            stdin.removeListener("end", onGone);
+            stdin.removeListener("error", onGone);
+            try {
+                stdin.setRawMode(Boolean(wasRaw));
+            }
+            catch {
+                // Best-effort; the engine resets the tty when it starts.
+            }
+            stdin.pause();
+            process.stdout.write(`${yes ? "y" : "n"}\n`);
+            resolve(yes);
+        };
+        const onData = (chunk) => settle(String(chunk).trim().toLowerCase() === "y");
+        const onGone = () => settle(false);
+        stdin.once("data", onData);
+        stdin.once("end", onGone);
+        stdin.once("error", onGone);
+    });
+}
+function runUpgrade() {
+    const result = (0, child_process_1.spawnSync)("npm", ["i", "-g", "codiedev@latest"], {
+        stdio: "inherit",
+        timeout: UPGRADE_TIMEOUT_MS,
+        shell: process.platform === "win32",
+    });
+    return !result.error && result.status === 0;
+}
+/**
+ * Prompt-capable sibling of maybePrintUpgradeNudge. Call this before handing
+ * the terminal to a TUI. A successful upgrade relaunches the fresh CLI and
+ * tells the stale caller to stop rather than continuing with old modules.
+ */
+async function maybeOfferUpgrade(opts = {}) {
+    const env = opts.env ?? process.env;
+    const argv = opts.argv ?? process.argv;
+    const nowMs = opts.nowMs ?? Date.now();
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const log = opts.log ?? ((line) => console.error(line));
+    if (env.CODIEDEV_NO_UPDATE_CHECK)
+        return { relaunched: false };
+    const cache = readOfferCache(env);
+    let latest = cache?.latest ?? null;
+    let fetchedAt = cache?.fetchedAt ?? 0;
+    const promptedAt = cache?.promptedAt ?? 0;
+    if (!cache || nowMs - cache.fetchedAt > CACHE_TTL_MS) {
+        // Probe writability before paying the network cost.
+        if (!writeOfferCache(cache ?? { latest: null, fetchedAt: 0, promptedAt: 0 }, env)) {
+            return { relaunched: false };
+        }
+        latest = await fetchLatest(fetchImpl);
+        fetchedAt = nowMs;
+        if (!writeOfferCache({ latest, fetchedAt, promptedAt }, env)) {
+            return { relaunched: false };
+        }
+    }
+    const installKind = (0, versionCheck_1.resolveInstallKind)({
+        dirname: __dirname,
+        env,
+        existsSync: fs.existsSync,
+        readFileSync: fs.readFileSync,
+        accessSync: fs.accessSync,
+    });
+    const { action, command } = (0, versionCheck_1.decideUpdateAction)({
+        current: version_1.CLI_VERSION,
+        latest,
+        installKind,
+        isTty: opts.isTty ?? Boolean(process.stdin.isTTY && process.stdout.isTTY),
+        isCi: isCiEnvironment(env),
+        promptedAt,
+        nowMs,
+    });
+    if (action === "none")
+        return { relaunched: false };
+    log("");
+    log(`\x1b[33mcodiedev ${latest} is available\x1b[0m (you're on ${version_1.CLI_VERSION})`);
+    if (action === "notify") {
+        log(`  Upgrade: \x1b[36m${command}\x1b[0m`);
+        log("");
+        return { relaunched: false };
+    }
+    writeOfferCache({ latest, fetchedAt, promptedAt: nowMs }, env);
+    if (!(await promptYesNo("  Update now? [y/N] "))) {
+        log(`  Skipping. Upgrade later with \x1b[36m${command}\x1b[0m`);
+        log("");
+        return { relaunched: false };
+    }
+    if (!runUpgrade()) {
+        log(`\x1b[33mcodiedev: upgrade failed — continuing on ${version_1.CLI_VERSION}\x1b[0m`);
+        log(`  Try it by hand: \x1b[36m${command}\x1b[0m`);
+        log("");
+        return { relaunched: false };
+    }
+    const relaunch = (0, child_process_1.spawnSync)(process.execPath, [argv[1], ...argv.slice(2)], {
+        stdio: "inherit",
+        env: { ...env, CODIEDEV_NO_UPDATE_CHECK: "1" },
+    });
+    if (relaunch.error)
+        return { relaunched: false };
+    return { relaunched: true, status: relaunch.status === null ? 1 : relaunch.status };
+}

package/dist/utils.d.ts

@@ -45,6 +45,13 @@ export declare function collectCaptureKeys(dirs: string[], getBranch?: (d: strin
     branches: string[];
     headShas: string[];
 };
+export type CaptureGitRef = {
+    repoUrl: string;
+    branch?: string;
+    headSha?: string;
+};
+export declare function collectCaptureGitRefs(dirs: string[], getRemote?: (d: string) => string | null, getBranch?: (d: string) => string | null, getSha?: (d: string) => string | null): CaptureGitRef[];
+export declare function parsePullRequestUrls(transcriptContent: string): string[];
 export declare function extractShaTokens(transcriptContent: string): string[];
 export declare function parseAuthoredBranches(transcriptContent: string): string[];
 export declare function parseAuthoredShas(transcriptContent: string, repoRoot: string, resolveFullBatch?: (shas: string[]) => Map<string, string>): string[];
@@ -64,6 +71,8 @@ export interface CapturePayloadInput {
     headSha?: string | null;
     branches?: string[];
     headShas?: string[];
+    gitRefs?: CaptureGitRef[];
+    pullRequestUrls?: string[];
     inputTokens?: number;
     outputTokens?: number;
     cacheTokens?: number;

package/dist/utils.js

@@ -46,6 +46,8 @@ exports.matchRepo = matchRepo;
 exports.resolveCaptureDir = resolveCaptureDir;
 exports.resolveCaptureDirs = resolveCaptureDirs;
 exports.collectCaptureKeys = collectCaptureKeys;
+exports.collectCaptureGitRefs = collectCaptureGitRefs;
+exports.parsePullRequestUrls = parsePullRequestUrls;
 exports.extractShaTokens = extractShaTokens;
 exports.parseAuthoredBranches = parseAuthoredBranches;
 exports.parseAuthoredShas = parseAuthoredShas;
@@ -450,6 +452,144 @@ function collectCaptureKeys(dirs, getBranch = getGitBranch, getSha = getGitHeadS
     }
     return { branch: branches[0] ?? null, headSha: headShas[0] ?? null, branches, headShas };
 }
+function collectCaptureGitRefs(dirs, getRemote = getGitRemoteUrl, getBranch = getGitBranch, getSha = getGitHeadSha) {
+    const out = [];
+    const seen = new Set();
+    for (const dir of dirs) {
+        const repoUrl = getRemote(dir)?.trim();
+        if (!repoUrl)
+            continue;
+        const branch = getBranch(dir)?.trim() || undefined;
+        const headSha = getSha(dir)?.trim().toLowerCase() || undefined;
+        if (!branch && !headSha)
+            continue;
+        const key = `${normalizeRepoUrl(repoUrl).toLowerCase()}::${branch ?? ""}::${headSha ?? ""}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ repoUrl, ...(branch ? { branch } : {}), ...(headSha ? { headSha } : {}) });
+    }
+    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;
+        }
+        return command.split(/&&|\|\||;|\n/).some((statement) => /^(?:(?:env\s+)?[A-Z_][A-Z0-9_]*=\S+\s+)*(?:gh\s+pr\s+create|glab\s+mr\s+create)\b/i
+            .test(statement.trim()));
+    };
+    const scanText = (text) => {
+        const normalized = text.replace(/\\\//g, "/");
+        const candidates = normalized.match(/https?:\/\/[^\s<>"']+/gi) ?? [];
+        for (const raw of candidates) {
+            const trimmed = raw.replace(/[),.;:\]}]+$/g, "");
+            try {
+                const url = new URL(trimmed);
+                const path = url.pathname.replace(/\/+$/, "");
+                const isGithubPr = /^\/.+\/pull\/\d+$/i.test(path);
+                const isGitlabMr = /^\/.+\/-\/merge_requests\/\d+$/i.test(path);
+                if (!isGithubPr && !isGitlabMr)
+                    continue;
+                const canonical = `${url.protocol}//${url.host}${path}`;
+                if (!out.includes(canonical))
+                    out.push(canonical);
+            }
+            catch {
+                // Malformed tool output is ignored; capture remains best-effort.
+            }
+        }
+    };
+    const scanContent = (value) => {
+        if (typeof value === "string") {
+            scanText(value);
+            return;
+        }
+        if (!Array.isArray(value))
+            return;
+        for (const part of value) {
+            if (typeof part === "string")
+                scanText(part);
+            else if (part && typeof part === "object") {
+                const text = part.text;
+                if (typeof text === "string")
+                    scanText(text);
+            }
+        }
+    };
+    const entries = [];
+    for (const line of transcriptContent.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            entries.push(entry);
+            const content = entry?.message?.content;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block?.type === "tool_use"
+                        && typeof block.id === "string"
+                        && isCreateCommand(block.input?.command)) {
+                        createToolIds.add(block.id);
+                    }
+                }
+            }
+            // Codex function calls carry arguments as serialized JSON.
+            if (entry?.type === "response_item"
+                && entry?.payload?.type === "function_call"
+                && typeof entry.payload.call_id === "string") {
+                let args = entry.payload.arguments;
+                if (typeof args === "string") {
+                    try {
+                        args = JSON.parse(args);
+                    }
+                    catch { /* leave as string */ }
+                }
+                if (isCreateCommand(args?.cmd ?? args?.command ?? args)) {
+                    createToolIds.add(entry.payload.call_id);
+                }
+            }
+        }
+        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)) {
+            for (const block of content) {
+                if (block?.type === "tool_result"
+                    && typeof block.tool_use_id === "string"
+                    && createToolIds.has(block.tool_use_id)
+                    && block.is_error !== true) {
+                    scanContent(block.content);
+                }
+            }
+        }
+        if (entry?.type === "response_item"
+            && entry?.payload?.type === "function_call_output"
+            && typeof entry.payload.call_id === "string"
+            && createToolIds.has(entry.payload.call_id)) {
+            scanContent(entry.payload.output);
+        }
+    }
+    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
@@ -690,6 +830,10 @@ function buildCapturePayload(input) {
         // 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,
+        pullRequestUrls: input.pullRequestUrls && input.pullRequestUrls.length
+            ? input.pullRequestUrls
+            : undefined,
         transcript: input.transcriptBase64,
         messageCount: input.messageCount,
         toolCallCount: input.toolCallCount,

package/dist/versionCheck.d.ts

@@ -26,3 +26,43 @@ export interface UpdateWarningInput {
  * as-given and answers a single question — should the user see a nag?
  */
 export declare function shouldShowUpdateWarning(input: UpdateWarningInput): boolean;
+export type InstallKind = "npx" | "container" | "global" | "readonly";
+export interface InstallKindDeps {
+    dirname: string;
+    env: NodeJS.ProcessEnv;
+    existsSync: (p: string) => boolean;
+    readFileSync: (p: string, enc: string) => string;
+    accessSync: (p: string, mode?: number) => void;
+}
+/**
+ * npx       — running from npm's _npx cache; nothing to upgrade in place.
+ * container — baked into an image; the honest fix is rebuilding it.
+ * global    — a real install directory we can write to. Upgradable.
+ * readonly  — a real install directory we cannot write to (root-owned global
+ *             on a shared box, read-only mount). Needs sudo, so print rather
+ *             than attempt an upgrade that would EACCES.
+ */
+export declare function resolveInstallKind(deps: InstallKindDeps): InstallKind;
+export declare function upgradeCommand(kind: InstallKind, pkg?: string): string;
+export type UpdateAction = "none" | "notify" | "prompt";
+export interface UpdateActionInput {
+    current: string;
+    latest: string | null;
+    installKind: InstallKind;
+    isTty: boolean;
+    isCi: boolean;
+    promptedAt?: number;
+    nowMs: number;
+    cacheTtlMs?: number;
+    pkg?: string;
+}
+/**
+ * `promptedAt` makes a decline stick until the next window instead of asking
+ * on every launch. It is deliberately not keyed to a dismissed version:
+ * somebody who says no today should be asked again tomorrow, not silently
+ * stranded on that version forever.
+ */
+export declare function decideUpdateAction(input: UpdateActionInput): {
+    action: UpdateAction;
+    command: string;
+};

package/dist/versionCheck.js

@@ -7,6 +7,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSemver = parseSemver;
 exports.compareSemver = compareSemver;
 exports.shouldShowUpdateWarning = shouldShowUpdateWarning;
+exports.resolveInstallKind = resolveInstallKind;
+exports.upgradeCommand = upgradeCommand;
+exports.decideUpdateAction = decideUpdateAction;
 function parseSemver(input) {
     if (!input)
         return null;
@@ -47,3 +50,68 @@ function shouldShowUpdateWarning(input) {
         return false;
     return compareSemver(input.current, input.latest) === -1;
 }
+/**
+ * npx       — running from npm's _npx cache; nothing to upgrade in place.
+ * container — baked into an image; the honest fix is rebuilding it.
+ * global    — a real install directory we can write to. Upgradable.
+ * readonly  — a real install directory we cannot write to (root-owned global
+ *             on a shared box, read-only mount). Needs sudo, so print rather
+ *             than attempt an upgrade that would EACCES.
+ */
+function resolveInstallKind(deps) {
+    if (/[\\/](?:_npx|\.npm[\\/]_npx)[\\/]/.test(deps.dirname))
+        return "npx";
+    if (deps.env.KUBERNETES_SERVICE_HOST)
+        return "container";
+    if (deps.existsSync("/.dockerenv"))
+        return "container";
+    try {
+        if (/docker|containerd|kubepods|lxc/.test(deps.readFileSync("/proc/1/cgroup", "utf8"))) {
+            return "container";
+        }
+    }
+    catch {
+        // not Linux, or no procfs — fall through to the writability probe
+    }
+    try {
+        // 2 = fs.constants.W_OK, inlined so this module stays fs-free.
+        deps.accessSync(deps.dirname, 2);
+        return "global";
+    }
+    catch {
+        return "readonly";
+    }
+}
+function upgradeCommand(kind, pkg = "codiedev") {
+    switch (kind) {
+        case "npx":
+            return `npx --package ${pkg}@latest codie`;
+        case "container":
+            return `rebuild your image (npm i -g ${pkg}@latest)`;
+        case "readonly":
+            return `sudo npm i -g ${pkg}@latest`;
+        default:
+            return `npm i -g ${pkg}@latest`;
+    }
+}
+/**
+ * `promptedAt` makes a decline stick until the next window instead of asking
+ * on every launch. It is deliberately not keyed to a dismissed version:
+ * somebody who says no today should be asked again tomorrow, not silently
+ * stranded on that version forever.
+ */
+function decideUpdateAction(input) {
+    const command = upgradeCommand(input.installKind, input.pkg);
+    const ttl = input.cacheTtlMs ?? 24 * 60 * 60 * 1000;
+    if (!input.latest || compareSemver(input.current, input.latest) !== -1) {
+        return { action: "none", command };
+    }
+    if (input.isCi || !input.isTty)
+        return { action: "none", command };
+    const promptedAt = input.promptedAt ?? 0;
+    const askedRecently = promptedAt > 0 && input.nowMs - promptedAt <= ttl;
+    if (input.installKind === "global" && !askedRecently) {
+        return { action: "prompt", command };
+    }
+    return { action: "notify", command };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.33",
+  "version": "0.9.35",
   "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",