codiedev 0.10.0-beta.1 → 0.10.0-beta.10

package/dist/codexLimitScan.js

@@ -0,0 +1,359 @@
+"use strict";
+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.CODEX_LIMIT_STATE_PATH = void 0;
+exports.scanCodexRolloutForLimit = scanCodexRolloutForLimit;
+exports.readTailEndingAt = readTailEndingAt;
+exports.findRecentCodexRollouts = findRecentCodexRollouts;
+exports.sessionIdFromRolloutPath = sessionIdFromRolloutPath;
+exports.codexSessionsDir = codexSessionsDir;
+exports.recordCodexLimitReported = recordCodexLimitReported;
+exports.sweepCodexLimits = sweepCodexLimits;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const limitEvent_1 = require("./limitEvent");
+const configDir_1 = require("./configDir");
+const harnessDirs_1 = require("./harnessDirs");
+const MARKER = Buffer.from("rate_limit_reached_type");
+const SPEND_MARKER = Buffer.from("spend_control_reached");
+const NEWLINE = 0x0a;
+const DEFAULT_CHUNK_SIZE = 256 * 1024;
+const DEFAULT_MAX_SCAN_BYTES = 16 * 1024 * 1024;
+const DEFAULT_TAIL_BYTES = 64 * 1024;
+function scanCodexRolloutForLimit(filePath, options = {}) {
+    const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
+    const maxScanBytes = options.maxScanBytes ?? DEFAULT_MAX_SCAN_BYTES;
+    let size = 0;
+    try {
+        size = fs.statSync(filePath).size;
+    }
+    catch {
+        return null;
+    }
+    if (size === 0)
+        return null;
+    let fd;
+    try {
+        fd = fs.openSync(filePath, "r");
+    }
+    catch {
+        return null;
+    }
+    try {
+        let pos = size;
+        let carry = Buffer.alloc(0);
+        let scanned = 0;
+        while (pos > 0 && scanned < maxScanBytes) {
+            const length = Math.min(chunkSize, pos, maxScanBytes - scanned);
+            if (length <= 0)
+                break;
+            pos -= length;
+            const chunk = Buffer.allocUnsafe(length);
+            const read = fs.readSync(fd, chunk, 0, length, pos);
+            scanned += read;
+            const window = Buffer.concat([chunk.subarray(0, read), carry]);
+            let completeStart = 0;
+            if (pos > 0) {
+                const firstNewline = window.indexOf(NEWLINE);
+                if (firstNewline < 0) {
+                    carry = window.length > maxScanBytes ? Buffer.alloc(0) : window;
+                    continue;
+                }
+                completeStart = firstNewline + 1;
+                carry = window.subarray(0, completeStart);
+            }
+            else {
+                carry = Buffer.alloc(0);
+            }
+            const region = window.subarray(completeStart);
+            if (region.indexOf(MARKER) < 0 && region.indexOf(SPEND_MARKER) < 0)
+                continue;
+            const bounds = [];
+            let lineStart = 0;
+            for (let index = 0; index < region.length; index += 1) {
+                if (region[index] === NEWLINE) {
+                    bounds.push([lineStart, index + 1]);
+                    lineStart = index + 1;
+                }
+            }
+            if (lineStart < region.length)
+                bounds.push([lineStart, region.length]);
+            for (let index = bounds.length - 1; index >= 0; index -= 1) {
+                const [start, end] = bounds[index];
+                const event = (0, limitEvent_1.parseCodexLimitEventFromTranscript)(region.subarray(start, end).toString("utf8"));
+                if (event)
+                    return { event, lineEnd: pos + completeStart + end };
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            fs.closeSync(fd);
+        }
+        catch {
+        }
+    }
+}
+function readTailEndingAt(filePath, lineEnd, maxBytes = DEFAULT_TAIL_BYTES) {
+    let end = lineEnd;
+    try {
+        end = Math.min(lineEnd, fs.statSync(filePath).size);
+    }
+    catch {
+        return "";
+    }
+    const start = Math.max(0, end - maxBytes);
+    const length = end - start;
+    if (length <= 0)
+        return "";
+    let fd;
+    try {
+        fd = fs.openSync(filePath, "r");
+    }
+    catch {
+        return "";
+    }
+    try {
+        const buffer = Buffer.allocUnsafe(length);
+        const read = fs.readSync(fd, buffer, 0, length, start);
+        const text = buffer.subarray(0, read).toString("utf8");
+        if (start === 0)
+            return text;
+        const newline = text.indexOf("\n");
+        return newline === -1 ? "" : text.slice(newline + 1);
+    }
+    catch {
+        return "";
+    }
+    finally {
+        try {
+            fs.closeSync(fd);
+        }
+        catch {
+        }
+    }
+}
+const DEFAULT_WITHIN_MS = 24 * 3600_000;
+const DEFAULT_MAX_FILES = 12;
+function findRecentCodexRollouts(sessionsDir, options = {}) {
+    const withinMs = options.withinMs ?? DEFAULT_WITHIN_MS;
+    const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+    const now = options.now ?? Date.now();
+    const found = [];
+    const walk = (directory, depth) => {
+        if (depth > 5)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+                continue;
+            try {
+                const mtime = fs.statSync(full).mtimeMs;
+                if (now - mtime > withinMs)
+                    continue;
+                found.push({ file: full, mtime });
+            }
+            catch {
+            }
+        }
+    };
+    walk(sessionsDir, 0);
+    return found
+        .sort((left, right) => right.mtime - left.mtime)
+        .slice(0, maxFiles)
+        .map((entry) => entry.file);
+}
+function sessionIdFromRolloutPath(filePath) {
+    const match = path.basename(filePath).match(/^rollout-.*?T[\d-]+-(.+)\.jsonl$/);
+    return match ? match[1] : undefined;
+}
+function codexSessionsDir() {
+    return path.join((0, harnessDirs_1.codexHome)(), "sessions");
+}
+exports.CODEX_LIMIT_STATE_PATH = path.join((0, configDir_1.codiedevStateDir)(), "codex-limit-state.json");
+const MAX_STATE_ENTRIES = 500;
+function readSweepState(statePath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    }
+    catch {
+        return { seen: {} };
+    }
+    const seen = {};
+    const raw = parsed.seen;
+    if (raw && typeof raw === "object") {
+        for (const [file, value] of Object.entries(raw)) {
+            const record = value;
+            if (typeof record?.size !== "number")
+                continue;
+            seen[file] = {
+                size: record.size,
+                mtime: typeof record.mtime === "number" ? record.mtime : -1,
+                at: typeof record.at === "number" ? record.at : null,
+                t: typeof record.t === "number" ? record.t : 0,
+            };
+        }
+    }
+    const legacyClean = parsed.clean;
+    if (legacyClean && typeof legacyClean === "object") {
+        for (const [file, size] of Object.entries(legacyClean)) {
+            if (typeof size === "number" && !seen[file])
+                seen[file] = { size, mtime: -1, at: null, t: 0 };
+        }
+    }
+    return { seen };
+}
+const PRUNE_AFTER_MS = 7 * 24 * 3600_000;
+function pruneSweepState(state, now) {
+    for (const [file, record] of Object.entries(state.seen)) {
+        if (now - (record.t ?? 0) < PRUNE_AFTER_MS)
+            continue;
+        if (!fs.existsSync(file))
+            delete state.seen[file];
+    }
+    const files = Object.keys(state.seen);
+    if (files.length <= MAX_STATE_ENTRIES)
+        return;
+    files
+        .sort((left, right) => (state.seen[right].t ?? 0) - (state.seen[left].t ?? 0))
+        .slice(MAX_STATE_ENTRIES)
+        .forEach((file) => delete state.seen[file]);
+}
+function commitSweepState(statePath, ours, now) {
+    const current = readSweepState(statePath);
+    for (const [file, record] of Object.entries(ours))
+        current.seen[file] = record;
+    pruneSweepState(current, now);
+    writeSweepState(statePath, current);
+}
+function writeSweepState(statePath, state) {
+    const temp = `${statePath}.${process.pid}.tmp`;
+    try {
+        fs.mkdirSync(path.dirname(statePath), { recursive: true });
+        fs.writeFileSync(temp, JSON.stringify(state), "utf8");
+        fs.renameSync(temp, statePath);
+    }
+    catch {
+        try {
+            fs.unlinkSync(temp);
+        }
+        catch {
+        }
+    }
+}
+function fingerprint(filePath) {
+    try {
+        const stat = fs.statSync(filePath);
+        return { size: stat.size, mtime: stat.mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+function recordCodexLimitReported(filePath, at, statePath = exports.CODEX_LIMIT_STATE_PATH) {
+    const print = fingerprint(filePath);
+    if (!print)
+        return;
+    commitSweepState(statePath, { [filePath]: { ...print, at, t: Date.now() } }, Date.now());
+}
+const DEFAULT_CANDIDATES = 200;
+const DEFAULT_MAX_SCANS = 64;
+const DEFAULT_DEADLINE_MS = 1_500;
+async function sweepCodexLimits(args) {
+    const statePath = args.statePath ?? exports.CODEX_LIMIT_STATE_PATH;
+    const state = readSweepState(statePath);
+    const files = findRecentCodexRollouts(args.sessionsDir, {
+        maxFiles: DEFAULT_CANDIDATES,
+        ...args.findOptions,
+    });
+    const now = Date.now();
+    const touched = {};
+    let budget = args.maxScans ?? DEFAULT_MAX_SCANS;
+    const deadline = now + (args.deadlineMs ?? DEFAULT_DEADLINE_MS);
+    const pending = [];
+    for (const file of files) {
+        const print = fingerprint(file);
+        if (!print)
+            continue;
+        const record = state.seen[file];
+        if (record && record.size === print.size && record.mtime === print.mtime)
+            continue;
+        if (budget <= 0 || Date.now() >= deadline)
+            break;
+        budget -= 1;
+        const hit = scanCodexRolloutForLimit(file, args.scanOptions);
+        if (!hit) {
+            touched[file] = { ...print, at: null, t: now };
+            continue;
+        }
+        if (record && record.at === hit.event.at) {
+            touched[file] = { ...print, at: record.at, t: now };
+            continue;
+        }
+        pending.push({ file, print, hit });
+    }
+    const results = await Promise.allSettled(pending.map(({ file, hit }) => args.post({
+        source: "codex",
+        ...hit.event,
+        sessionId: sessionIdFromRolloutPath(file),
+        transcriptTail: readTailEndingAt(file, hit.lineEnd),
+    })));
+    let posted = 0;
+    results.forEach((result, index) => {
+        if (result.status !== "fulfilled")
+            return;
+        const { file, print, hit } = pending[index];
+        touched[file] = { ...print, at: hit.event.at, t: now };
+        posted += 1;
+    });
+    commitSweepState(statePath, touched, now);
+    return posted;
+}

package/dist/codie.js

@@ -1,15 +1,5 @@
 #!/usr/bin/env node
 "use strict";
-// `codie` — Codiedev's governed coding harness.
-//
-// Ships from the same package as `codiedev` so a developer runs one install and
-// then picks their surface: Claude Code, Codex, and Cursor get session capture
-// via `codiedev connect`; `codie` launches the governed harness against the
-// same token. OpenCode is the embedded engine; all user-facing identity,
-// credentials, models, policy, and capture belong to Codiedev.
-//
-// The engine is downloaded on first run (see codieRuntime.ts) so capture-only
-// users never pay for it.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -51,10 +41,17 @@ const child_process_1 = require("child_process");
 const url_1 = require("url");
 const configDir_1 = require("./configDir");
 const codieLauncher_1 = require("./codieLauncher");
+const codieBrandInstall_1 = require("./codieBrandInstall");
+const codieUsage_1 = require("./codieUsage");
 const codieRuntime_1 = require("./codieRuntime");
 const codieRuntimeInstall_1 = require("./codieRuntimeInstall");
-const codieStartup_1 = require("./codieStartup");
 const upgradeNudge_1 = require("./upgradeNudge");
+const codie_1 = require("./packs/codie");
+const paths_1 = require("./packs/paths");
+const managedPi_1 = require("./managedPi");
+const cliSession_1 = require("./cliSession");
+const CODIE_MIN_TOKEN_VALIDITY_MS = 12 * 60 * 60_000;
+const USAGE_SETTLE_MS = 1200;
 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() : "";
@@ -83,8 +80,6 @@ function existingInlineConfig() {
         throw new Error("OPENCODE_CONFIG_CONTENT is not valid JSON");
     }
 }
-// The one credential. `codiedev connect` wrote it; the gateway validates the
-// same userApiTokens row, so there is no second harness token to mint.
 function connectedCodiedevConfig() {
     try {
         return JSON.parse(fs.readFileSync(path.join((0, configDir_1.codiedevStateDir)(), "config.json"), "utf8"));
@@ -93,40 +88,23 @@ function connectedCodiedevConfig() {
         return {};
     }
 }
-function assetPath(name) {
-    // dist/codie.js → ../assets/<name>; src/codie.ts → ../assets/<name>.
-    return path.join(__dirname, "..", "assets", name);
-}
-// Stage the home-screen branding plugin. TUI plugins only load from tui.json
-// in the OpenCode config dir, so the packaged file is copied next to the
-// capture plugin and referenced with a relative spec. Best-effort: any
-// failure (e.g. a hand-edited tui.json with comments) leaves the stock logo.
-function installBrandPlugin() {
+function withStarterPacks(existing, approved, catalog) {
     try {
-        // OpenCode resolves its config dir per the XDG spec, so a customized
-        // XDG_CONFIG_HOME must be honored or tui.json lands where it never reads.
-        const configDir = path.join(process.env.XDG_CONFIG_HOME?.trim() || path.join(os.homedir(), ".config"), "opencode");
-        const pluginDir = path.join(configDir, "plugins");
-        fs.mkdirSync(pluginDir, { recursive: true });
-        const source = fs.readFileSync(assetPath("tui-brand-plugin.tsx"), "utf8");
-        const destination = path.join(pluginDir, "codiedev-brand.tsx");
-        if (!fs.existsSync(destination) || fs.readFileSync(destination, "utf8") !== source) {
-            fs.writeFileSync(destination, source);
+        const packs = (0, codie_1.codiePackConfig)((0, paths_1.packsRoot)(), { approvedModels: approved, catalog });
+        if (process.env.CODIEDEV_DEBUG) {
+            for (const note of packs.notes)
+                console.error(`codie: starter pack ${note}`);
         }
-        const tuiConfigPath = path.join(configDir, "tui.json");
-        const existing = fs.existsSync(tuiConfigPath) ? JSON.parse(fs.readFileSync(tuiConfigPath, "utf8")) : {};
-        const { config, changed } = (0, codieLauncher_1.withBrandPlugin)(existing);
-        if (changed)
-            fs.writeFileSync(tuiConfigPath, `${JSON.stringify(config, null, 2)}\n`);
+        return (0, codie_1.mergeCodiePackConfig)(existing, packs);
     }
     catch (error) {
-        console.error(`codie: continuing without Codiedev branding (${error instanceof Error ? error.message : error})`);
+        console.error(`codie: skipping starter packs (${error instanceof Error ? error.message : error})`);
+        return existing;
     }
 }
-// Remove the engine's boot/exit banner wordmark in place (see
-// patchBrandWordmark). Best-effort like the TUI plugin: any failure rolls the
-// bytes back and the stock banner keeps working. Runs once per install; an
-// already-suppressed binary has no known source region and is skipped.
+function assetPath(name) {
+    return path.join(__dirname, "..", "assets", name);
+}
 function installBrandWordmark(runtime) {
     try {
         installBrandWordmarkUnsafe(runtime);
@@ -140,10 +118,6 @@ function installBrandWordmarkUnsafe(runtime) {
     const { changed, offset, replacement } = (0, codieLauncher_1.patchBrandWordmark)(binary);
     if (!changed || !replacement)
         return;
-    // In-place write (not copy+rename): opencode-ai/bin/opencode.exe and the
-    // platform package's binary are hardlinks to one inode, and this keeps them
-    // consistent. Restoring the original bytes is a true rollback — identical
-    // content revalidates the existing macOS signature.
     const writeAt = (bytes) => {
         const fd = fs.openSync(runtime, "r+");
         try {
@@ -156,7 +130,6 @@ function installBrandWordmarkUnsafe(runtime) {
     const restore = () => writeAt(binary.subarray(offset, offset + replacement.length));
     writeAt(replacement);
     if (process.platform === "darwin") {
-        // A modified Mach-O needs a fresh ad-hoc signature or the OS kills it.
         const signed = (0, child_process_1.spawnSync)("codesign", ["--force", "--sign", "-", runtime], { stdio: "ignore" });
         if (signed.status !== 0) {
             restore();
@@ -186,7 +159,6 @@ async function runNonInteractive(runtime, runtimeArgs, env) {
                 return;
             }
             catch {
-                // Fall back to the direct child if its process group already exited.
             }
         }
         child.kill(signal);
@@ -196,73 +168,8 @@ async function runNonInteractive(runtime, runtimeArgs, env) {
     process.once("SIGINT", forwardInterrupt);
     process.once("SIGTERM", forwardTermination);
     return await new Promise((resolve, reject) => {
-        let blockReason;
-        const errorPrefixes = [Buffer.from("\x1b[91m\x1b[1mError:"), Buffer.from("Error: {")];
-        const retainedPrefixBytes = Math.max(...errorPrefixes.map((prefix) => prefix.length)) - 1;
-        // OpenCode's generic UnknownError and the adapter's private reason can be
-        // delivered in either order — and the generic block can arrive on stdout
-        // or stderr. Gate both streams by content, retaining only a possible final
-        // error block. Ordinary output stays streaming apart from the few bytes
-        // needed to recognize a split prefix.
-        const createOutputGate = (write) => {
-            let tail = Buffer.alloc(0);
-            let possibleError;
-            return {
-                push(chunk, blocked) {
-                    if (blocked) {
-                        if (possibleError)
-                            possibleError.push(Buffer.from(chunk));
-                        return;
-                    }
-                    if (possibleError) {
-                        possibleError.push(Buffer.from(chunk));
-                        return;
-                    }
-                    const combined = Buffer.concat([tail, chunk]);
-                    let errorStart = -1;
-                    for (const prefix of errorPrefixes) {
-                        const index = combined.indexOf(prefix);
-                        if (index >= 0 && (errorStart < 0 || index < errorStart))
-                            errorStart = index;
-                    }
-                    if (errorStart >= 0) {
-                        if (errorStart > 0)
-                            write(combined.subarray(0, errorStart));
-                        possibleError = [combined.subarray(errorStart)];
-                        tail = Buffer.alloc(0);
-                        return;
-                    }
-                    const flushBytes = Math.max(0, combined.length - retainedPrefixBytes);
-                    if (flushBytes > 0)
-                        write(combined.subarray(0, flushBytes));
-                    tail = combined.subarray(flushBytes);
-                },
-                finish(blocked) {
-                    if (tail.length > 0)
-                        write(tail);
-                    const heldError = possibleError ? Buffer.concat(possibleError).toString() : "";
-                    const genericBlockError = heldError.includes("UnknownError") &&
-                        heldError.includes("Unexpected server error");
-                    if (heldError && (!blocked || !genericBlockError))
-                        write(heldError);
-                },
-            };
-        };
-        const stdoutGate = createOutputGate((chunk) => process.stdout.write(chunk));
-        const stderrGate = createOutputGate((chunk) => process.stderr.write(chunk));
-        child.stdout?.on("data", (chunk) => {
-            stdoutGate.push(Buffer.from(chunk), Boolean(blockReason));
-        });
-        child.stderr?.on("data", (chunk) => {
-            const text = chunk.toString();
-            const reason = (0, codieLauncher_1.extractCodieSecurityBlock)(text);
-            if (reason) {
-                blockReason = reason;
-                signalChild("SIGTERM");
-                return;
-            }
-            stderrGate.push(Buffer.from(chunk), Boolean(blockReason));
-        });
+        child.stdout?.on("data", (chunk) => process.stdout.write(chunk));
+        child.stderr?.on("data", (chunk) => process.stderr.write(chunk));
         child.once("error", (error) => {
             if (child.stdin)
                 process.stdin.unpipe(child.stdin);
@@ -275,38 +182,57 @@ async function runNonInteractive(runtime, runtimeArgs, env) {
                 process.stdin.unpipe(child.stdin);
             process.removeListener("SIGINT", forwardInterrupt);
             process.removeListener("SIGTERM", forwardTermination);
-            stdoutGate.finish(Boolean(blockReason));
-            stderrGate.finish(Boolean(blockReason));
-            if (blockReason) {
-                console.error(`Codie Security blocked this action:\n${blockReason}`);
-            }
             resolve(status);
         });
     });
 }
 async function main() {
     (0, codieRuntime_1.assertCodieNodeVersion)(process.versions.node);
+    if (!process.env.CODIEDEV_GATEWAY_KEY && !process.env.CODIEDEV_TOKEN) {
+        const fresh = await (0, cliSession_1.ensureFreshToken)({ configPath: path.join((0, configDir_1.codiedevStateDir)(), "config.json") }, CODIE_MIN_TOKEN_VALIDITY_MS);
+        if (fresh.status === "signed_out") {
+            throw new Error("Your Codiedev sign-in has ended. Run `codiedev connect` to sign in again");
+        }
+    }
     const connected = connectedCodiedevConfig();
+    if (!process.env.CODIEDEV_GATEWAY_KEY && !process.env.CODIEDEV_TOKEN && connected.auth) {
+        process.env.CODIEDEV_SESSION_CONFIG = path.join((0, configDir_1.codiedevStateDir)(), "config.json");
+        process.env.CODIEDEV_CLI_JS = path.join(__dirname, "cli.js");
+        process.env.CODIEDEV_NODE = process.execPath;
+    }
     const key = process.env.CODIEDEV_GATEWAY_KEY ||
         process.env.CODIEDEV_TOKEN ||
         (typeof connected.token === "string" ? connected.token.trim() : "");
     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 policyRefresh = await (0, codieStartup_1.refreshCodieSecurityPolicy)(connected);
-    if (policyRefresh.status === "cached") {
-        console.error(`codie: security policy refresh failed; using the cached policy (${policyRefresh.error})`);
-    }
     const gatewayUrl = process.env.CODIEDEV_GATEWAY_URL || "https://gateway.codiedev.com/api/v1";
     const catalog = await (0, codieLauncher_1.fetchApprovedCatalog)({ baseUrl: gatewayUrl, key });
+    if (process.argv[2] === "--pi") {
+        let skillPaths = [];
+        try {
+            const approved = new Set(catalog.map((model) => (0, codieLauncher_1.bareModel)(model.id)).filter(Boolean));
+            skillPaths = (0, codie_1.codiePackConfig)((0, paths_1.packsRoot)(), { approvedModels: approved, catalog }).skillPaths;
+        }
+        catch (error) {
+            console.error(`codie: skipping starter packs (${error instanceof Error ? error.message : error})`);
+        }
+        try {
+            process.exitCode = (0, managedPi_1.runManagedPi)({
+                args: process.argv.slice(3), key, gatewayUrl, catalog, stateDir: (0, configDir_1.codiedevStateDir)(), skillPaths,
+            });
+        }
+        catch (error) {
+            console.error(`codie: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = error instanceof managedPi_1.ManagedPiArgError ? 2 : 1;
+        }
+        return;
+    }
     const parsed = (0, codieLauncher_1.parseCodieArgs)(process.argv.slice(2));
     if (parsed.args.length === 1 && parsed.args[0] === "models") {
         console.log("Codiedev approved models\n");
@@ -337,8 +263,18 @@ async function main() {
                     return null;
                 }
             },
+            isEngine: codieRuntimeInstall_1.isEngineOnDisk,
         }),
         install: (missing) => (0, codieRuntimeInstall_1.installCodieRuntimeOnDisk)(missing, stateDir),
+        repair: (unlinked) => {
+            console.error("codie: finishing the engine setup npm skipped (opencode-ai's postinstall)…");
+            const linked = (0, codieRuntimeInstall_1.linkEngineOnDisk)(unlinked.packageDir);
+            if (!linked.ok && linked.detail === codieRuntimeInstall_1.IGNORE_SCRIPTS)
+                throw new Error((0, codieRuntimeInstall_1.linkFailure)(linked, unlinked.packageDir));
+            if (!linked.ok)
+                console.error(`codie: ${(0, codieRuntimeInstall_1.linkFailure)(linked, unlinked.packageDir)} Reinstalling the engine.`);
+            return linked.ok;
+        },
         confirmUpdate: async (outdated) => {
             console.error("");
             console.error(`Codie harness ${outdated.expectedVersion} is available (you're on ${outdated.currentVersion}).`);
@@ -352,10 +288,10 @@ async function main() {
     });
     const metadataPlugin = (0, url_1.pathToFileURL)(assetPath("opencode-plugin.mjs")).href;
     const capturePlugin = (0, codieLauncher_1.resolveCapturePlugin)({ homeDir: os.homedir(), existsSync: fs.existsSync });
-    installBrandPlugin();
+    (0, codieBrandInstall_1.installTuiPlugin)();
     installBrandWordmark(runtime);
     const config = (0, codieLauncher_1.buildCodieConfig)({
-        existing: existingInlineConfig(),
+        existing: withStarterPacks(existingInlineConfig(), new Set(catalog.map((model) => (0, codieLauncher_1.bareModel)(model.id)).filter(Boolean)), catalog),
         catalog,
         env: { ...process.env, ...parsed.overrides, CODIEDEV_GATEWAY_URL: gatewayUrl },
         plugins: [capturePlugin, metadataPlugin],
@@ -371,10 +307,21 @@ async function main() {
     };
     const runtimeArgs = (0, codieLauncher_1.withCodieWorkingDirectory)(parsed.args, process.cwd());
     const nonInteractiveRun = runtimeArgs[0] === "run";
-    if (nonInteractiveRun)
-        env.CODIEDEV_SECURITY_BLOCK_OUTPUT = "marker";
     if (nonInteractiveRun) {
+        const reportCost = Boolean(process.stderr.isTTY);
+        const startedAt = Date.now();
+        if (reportCost) {
+            const line = (0, codieUsage_1.formatUsageLine)(await (0, codieUsage_1.fetchCodieUsage)({ baseUrl: gatewayUrl, key }));
+            if (line)
+                console.error(line);
+        }
         process.exitCode = (await runNonInteractive(runtime, runtimeArgs, env)) ?? 1;
+        if (reportCost) {
+            await new Promise((resolve) => setTimeout(resolve, USAGE_SETTLE_MS));
+            const cost = (0, codieUsage_1.formatSessionCostLine)(await (0, codieUsage_1.fetchCodieUsage)({ baseUrl: gatewayUrl, key, sinceMs: startedAt }));
+            if (cost)
+                console.error(cost);
+        }
         return;
     }
     const result = (0, child_process_1.spawnSync)(runtime, runtimeArgs, { stdio: "inherit", env });