codiedev 0.10.0-beta.4 → 0.10.0-beta.6

package/dist/codexLimitScan.js

@@ -41,49 +41,17 @@ exports.sessionIdFromRolloutPath = sessionIdFromRolloutPath;
 exports.codexSessionsDir = codexSessionsDir;
 exports.recordCodexLimitReported = recordCodexLimitReported;
 exports.sweepCodexLimits = sweepCodexLimits;
-// Reporting a Codex credit/rate-limit block.
-//
-// WHY THIS EXISTS: the `limit-codex` reporter is a Codex `Stop` hook, and
-// Codex does NOT run Stop hooks on the turn a block kills. Measured on real
-// rollouts: every normal `task_complete` pairs with a Stop-hook run within
-// ~200ms, and the blocked one never does (21 turns → 20 runs; 11 → 10, short
-// by exactly the blocked turn each time). Claude Code has a dedicated
-// StopFailure event with a `rate_limit` matcher, which is why it reports
-// correctly; Codex's HookEventName enum has no equivalent — there is no event
-// at all that fires at the block.
-//
-// So the block can only be reported LATER, from a hook that does run. This
-// module scans the rollout files Codex has already written and reports any
-// block that has not been reported yet. It is driven from UserPromptSubmit
-// (`discover-codex`), which fires on the developer's next prompt — in the
-// blocked session or in a new one — and from Stop, which still catches the
-// (rarer) case of a block followed by more turns.
-//
-// The scan reads BACKWARDS from end of file. The previous reader took a fixed
-// 512 KB tail, which silently lost the event whenever the session kept writing
-// after the block: in one real 44 MB rollout the marker sat 1.13 MB from the
-// end, outside the window, and the parse returned null.
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
 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;
-// Read backwards in 256 KB chunks, and give up after 16 MB. Codex rollouts run
-// to tens of megabytes, but a block is always in the session's LAST turn — the
-// bytes after it are whatever the session did once the window reset. 16 MB
-// covers that comfortably without ever loading a whole rollout.
 const DEFAULT_CHUNK_SIZE = 256 * 1024;
 const DEFAULT_MAX_SCAN_BYTES = 16 * 1024 * 1024;
-// Tail shipped to the server so it can summarize what the developer was doing
-// when they got blocked. Matches the server-side cap in http.ts.
 const DEFAULT_TAIL_BYTES = 64 * 1024;
-/**
- * Find the LAST rate-limit/credit block recorded in a Codex rollout file.
- * Returns null when the session was never blocked.
- */
 function scanCodexRolloutForLimit(filePath, options = {}) {
     const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
     const maxScanBytes = options.maxScanBytes ?? DEFAULT_MAX_SCAN_BYTES;
@@ -105,8 +73,6 @@ function scanCodexRolloutForLimit(filePath, options = {}) {
     }
     try {
         let pos = size;
-        // Bytes of the (earlier-read) chunk that belong to a line whose start we
-        // have not reached yet. Carried into the next, earlier chunk.
         let carry = Buffer.alloc(0);
         let scanned = 0;
         while (pos > 0 && scanned < maxScanBytes) {
@@ -118,15 +84,10 @@ function scanCodexRolloutForLimit(filePath, options = {}) {
             const read = fs.readSync(fd, chunk, 0, length, pos);
             scanned += read;
             const window = Buffer.concat([chunk.subarray(0, read), carry]);
-            // At pos > 0 the first line in the window is partial — its start lies in
-            // an earlier chunk — so hold it back rather than parse a torn line.
             let completeStart = 0;
             if (pos > 0) {
                 const firstNewline = window.indexOf(NEWLINE);
                 if (firstNewline < 0) {
-                    // The whole window is one unterminated line. A token_count record is
-                    // ~1 KB, so a line this long is never the one we want: drop it rather
-                    // than grow the carry without bound.
                     carry = window.length > maxScanBytes ? Buffer.alloc(0) : window;
                     continue;
                 }
@@ -139,8 +100,6 @@ function scanCodexRolloutForLimit(filePath, options = {}) {
             const region = window.subarray(completeStart);
             if (region.indexOf(MARKER) < 0 && region.indexOf(SPEND_MARKER) < 0)
                 continue;
-            // Walk this window's complete lines from the end backwards; the first
-            // match going backwards is the latest one in the file.
             const bounds = [];
             let lineStart = 0;
             for (let index = 0; index < region.length; index += 1) {
@@ -168,18 +127,10 @@ function scanCodexRolloutForLimit(filePath, options = {}) {
             fs.closeSync(fd);
         }
         catch {
-            /* best-effort */
         }
     }
 }
-/**
- * Read up to `maxBytes` of the rollout ENDING at `lineEnd` — the work the
- * developer was doing when the block hit, not whatever the session did after
- * the window reset. Resumes at a line boundary so every JSONL line parses.
- */
 function readTailEndingAt(filePath, lineEnd, maxBytes = DEFAULT_TAIL_BYTES) {
-    // Clamp to the file as it is NOW: the offset came from an earlier scan, and
-    // reading past EOF would return a short, garbled tail.
     let end = lineEnd;
     try {
         end = Math.min(lineEnd, fs.statSync(filePath).size);
@@ -215,13 +166,11 @@ function readTailEndingAt(filePath, lineEnd, maxBytes = DEFAULT_TAIL_BYTES) {
             fs.closeSync(fd);
         }
         catch {
-            /* best-effort */
         }
     }
 }
 const DEFAULT_WITHIN_MS = 24 * 3600_000;
 const DEFAULT_MAX_FILES = 12;
-/** Codex rollout files, newest first, limited by age and count. */
 function findRecentCodexRollouts(sessionsDir, options = {}) {
     const withinMs = options.withinMs ?? DEFAULT_WITHIN_MS;
     const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
@@ -252,7 +201,6 @@ function findRecentCodexRollouts(sessionsDir, options = {}) {
                 found.push({ file: full, mtime });
             }
             catch {
-                /* unreadable — skip */
             }
         }
     };
@@ -262,17 +210,14 @@ function findRecentCodexRollouts(sessionsDir, options = {}) {
         .slice(0, maxFiles)
         .map((entry) => entry.file);
 }
-/** Codex names rollouts `rollout-<ISO local time>-<session id>.jsonl`. */
 function sessionIdFromRolloutPath(filePath) {
     const match = path.basename(filePath).match(/^rollout-.*?T[\d-]+-(.+)\.jsonl$/);
     return match ? match[1] : undefined;
 }
-/** Where Codex writes its rollout JSONL files. */
 function codexSessionsDir() {
-    return path.join(os.homedir(), ".codex", "sessions");
+    return path.join((0, harnessDirs_1.codexHome)(), "sessions");
 }
 exports.CODEX_LIMIT_STATE_PATH = path.join((0, configDir_1.codiedevStateDir)(), "codex-limit-state.json");
-// Bounds the state file on a machine with a long Codex history.
 const MAX_STATE_ENTRIES = 500;
 function readSweepState(statePath) {
     let parsed;
@@ -297,10 +242,6 @@ function readSweepState(statePath) {
             };
         }
     }
-    // Migrate the 0.10.0-beta shape ({ reportedThrough, clean }). The old global
-    // watermark is DELIBERATELY dropped rather than carried over: it is exactly
-    // what could suppress an older block forever. Re-reporting is safe — the
-    // server deduplicates on (companyId, userId, at).
     const legacyClean = parsed.clean;
     if (legacyClean && typeof legacyClean === "object") {
         for (const [file, size] of Object.entries(legacyClean)) {
@@ -310,9 +251,6 @@ function readSweepState(statePath) {
     }
     return { seen };
 }
-// A record is dropped only once its file has been gone for a while. Pruning
-// the moment a path is missing would re-report an already-sent block after any
-// transient rename or move.
 const PRUNE_AFTER_MS = 7 * 24 * 3600_000;
 function pruneSweepState(state, now) {
     for (const [file, record] of Object.entries(state.seen)) {
@@ -329,11 +267,6 @@ function pruneSweepState(state, now) {
         .slice(MAX_STATE_ENTRIES)
         .forEach((file) => delete state.seen[file]);
 }
-/**
- * Merge our records into whatever is on disk NOW and write the result. Two
- * Codex sessions can submit a prompt at the same time; a plain
- * read-modify-write would silently drop the other process's records.
- */
 function commitSweepState(statePath, ours, now) {
     const current = readSweepState(statePath);
     for (const [file, record] of Object.entries(ours))
@@ -342,9 +275,6 @@ function commitSweepState(statePath, ours, now) {
     writeSweepState(statePath, current);
 }
 function writeSweepState(statePath, state) {
-    // Written through a temp file and renamed: Codex kills a hook that overruns
-    // its timeout, and a half-written state file would read as "nothing seen"
-    // and re-report every block in the window.
     const temp = `${statePath}.${process.pid}.tmp`;
     try {
         fs.mkdirSync(path.dirname(statePath), { recursive: true });
@@ -356,7 +286,6 @@ function writeSweepState(statePath, state) {
             fs.unlinkSync(temp);
         }
         catch {
-            /* best-effort */
         }
     }
 }
@@ -369,46 +298,15 @@ function fingerprint(filePath) {
         return null;
     }
 }
-/**
- * Record a block reported outside the sweep (the Stop path), so the next
- * prompt sweep neither re-scans the rollout nor re-posts the event.
- */
 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());
 }
-// Candidates are listed generously and settled by one statSync each; only
-// files that actually changed cost a read. The budget therefore bounds work
-// without letting idle sessions bury an unreported block.
-//
-// The budget binds only on a COLD START, where nothing has been seen before,
-// so it must be big enough to finish that first pass. A budget of 8 silently
-// starved the older blocked rollouts on a real machine: 49 candidates in the
-// window, the newest 8 all unblocked, nothing reported. A full pass over
-// those 49 costs ~205ms — the backward scan stops at the marker rather than
-// reading each file to its cap — so the budget can afford to cover them.
 const DEFAULT_CANDIDATES = 200;
 const DEFAULT_MAX_SCANS = 64;
-// The budget bounds how MANY files are read; this bounds how LONG. A count is
-// not enough on a slow or network-mounted disk, and this runs on the user's
-// prompt clock. Whatever is not reached stays unrecorded, so the next prompt
-// picks it up rather than skipping it.
 const DEFAULT_DEADLINE_MS = 1_500;
-/**
- * Report every Codex block this machine has not reported yet. Returns how many
- * events were posted. Never throws — it runs inside a hook.
- *
- * State is kept PER FILE, not as one newest-wins timestamp. A single global
- * watermark loses data: rollouts are capped per sweep, so a block in a file
- * outside the cap can be older than one already reported and would then be
- * suppressed forever. A per-file record can only ever cause a re-report, which
- * the server deduplicates on (companyId, userId, at).
- *
- * A file is recorded only after its POST succeeds, so a failed send is retried
- * on the next prompt.
- */
 async function sweepCodexLimits(args) {
     const statePath = args.statePath ?? exports.CODEX_LIMIT_STATE_PATH;
     const state = readSweepState(statePath);
@@ -426,8 +324,6 @@ async function sweepCodexLimits(args) {
         if (!print)
             continue;
         const record = state.seen[file];
-        // Settled by the stat alone — it has not changed since the last scan, so
-        // it holds nothing new and does not spend the read budget.
         if (record && record.size === print.size && record.mtime === print.mtime)
             continue;
         if (budget <= 0 || Date.now() >= deadline)
@@ -439,14 +335,11 @@ async function sweepCodexLimits(args) {
             continue;
         }
         if (record && record.at === hit.event.at) {
-            // Same block, already reported; the file just grew.
             touched[file] = { ...print, at: record.at, t: now };
             continue;
         }
         pending.push({ file, print, hit });
     }
-    // Posted concurrently: each file is independent, and this runs on the
-    // prompt path where a serial chain of network timeouts would be felt.
     const results = await Promise.allSettled(pending.map(({ file, hit }) => args.post({
         source: "codex",
         ...hit.event,

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);
@@ -55,10 +45,10 @@ 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");
-// How long to let the gateway finish booking the last request before asking
-// what the session cost.
+const codie_1 = require("./packs/codie");
+const paths_1 = require("./packs/paths");
+const managedPi_1 = require("./managedPi");
 const USAGE_SETTLE_MS = 1200;
 function git(args) {
     const result = (0, child_process_1.spawnSync)("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
@@ -88,8 +78,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"));
@@ -98,14 +86,23 @@ function connectedCodiedevConfig() {
         return {};
     }
 }
+function withStarterPacks(existing, approved, catalog) {
+    try {
+        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}`);
+        }
+        return (0, codie_1.mergeCodiePackConfig)(existing, packs);
+    }
+    catch (error) {
+        console.error(`codie: skipping starter packs (${error instanceof Error ? error.message : error})`);
+        return existing;
+    }
+}
 function assetPath(name) {
-    // dist/codie.js → ../assets/<name>; src/codie.ts → ../assets/<name>.
     return path.join(__dirname, "..", "assets", name);
 }
-// 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 installBrandWordmark(runtime) {
     try {
         installBrandWordmarkUnsafe(runtime);
@@ -119,10 +116,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 {
@@ -135,7 +128,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();
@@ -165,7 +157,6 @@ async function runNonInteractive(runtime, runtimeArgs, env) {
                 return;
             }
             catch {
-                // Fall back to the direct child if its process group already exited.
             }
         }
         child.kill(signal);
@@ -175,73 +166,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);
@@ -254,11 +180,6 @@ 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);
         });
     });
@@ -272,20 +193,33 @@ 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 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");
@@ -316,8 +250,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}).`);
@@ -334,7 +278,7 @@ async function main() {
     (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],
@@ -350,13 +294,7 @@ 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) {
-        // The TUI paints its own live status line from the same endpoint. A
-        // non-interactive run has no TUI, so the budget arrives as two printed
-        // lines instead — and only for a human at a terminal, so a scripted run
-        // is neither slowed nor polluted.
         const reportCost = Boolean(process.stderr.isTTY);
         const startedAt = Date.now();
         if (reportCost) {
@@ -366,8 +304,6 @@ async function main() {
         }
         process.exitCode = (await runNonInteractive(runtime, runtimeArgs, env)) ?? 1;
         if (reportCost) {
-            // The gateway books a request's cost after it has answered, so a poll
-            // fired the instant the run closes can miss the last one.
             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)

package/dist/codieBrandInstall.js

@@ -1,13 +1,4 @@
 "use strict";
-// Stages the Codiedev TUI plugin into the engine's config directory.
-//
-// TUI plugins load only from tui.json in the OpenCode config dir, so the
-// packaged template is copied there and referenced by a relative spec. The
-// copy also carries the status line, which needs an absolute path back into
-// this package — the plugin sits outside it and cannot reach it any other way.
-//
-// Every step is best-effort: a developer who cannot write this directory still
-// gets a working harness, just the stock logo and no status line.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -50,15 +41,8 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const codieLauncher_1 = require("./codieLauncher");
 function assetPath(name) {
-    // dist/codieBrandInstall.js → ../assets/<name>; src/… → ../assets/<name>.
     return path.join(__dirname, "..", "assets", name);
 }
-/**
- * The usage module this install should load. The shipped package has the
- * compiled file; a source checkout (and the test run) has the TypeScript one.
- * Naming a path that does not exist would cost the status line silently, so a
- * miss raises instead and the caller falls back to the plain plugin.
- */
 function usageModulePath() {
     const candidates = [
         path.join(__dirname, "codieUsage.js"),
@@ -69,8 +53,6 @@ function usageModulePath() {
         throw new Error("this install has no Codiedev usage module");
     return found;
 }
-/** The engine 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. */
 function openCodeConfigDir() {
     return path.join(process.env.XDG_CONFIG_HOME?.trim() || path.join(os.homedir(), ".config"), "opencode");
 }