codiedev 0.9.57 → 0.9.59

package/assets/tui-brand-plugin.tsx

@@ -31,6 +31,7 @@ const MARK = [
 const REFRESH_MS = 30_000
 
 const [usageLine, setUsageLine] = createSignal("")
+const [usageTone, setUsageTone] = createSignal("normal")
 
 async function startUsagePolling() {
   let usage: any
@@ -56,7 +57,11 @@ async function startUsagePolling() {
       })
       // A failed poll leaves the last good line up rather than blanking it:
       // a number that stopped updating beats a number that vanished.
-      if (snapshot) setUsageLine(usage.formatUsageLine(snapshot))
+      if (snapshot) {
+        setUsageLine(usage.formatUsageLine(snapshot))
+        // Older installs of the usage module have no tone; stay muted there.
+        if (typeof usage.usageTone === "function") setUsageTone(usage.usageTone(snapshot))
+      }
     } catch {}
   }
   void poll()
@@ -69,7 +74,14 @@ void startUsagePolling().catch(() => {})
 
 function StatusLine(props: { theme: any }) {
   return (
-    <text fg={props.theme.textMuted} selectable={false}>
+    <text
+      fg={usageTone() === "critical"
+        ? (props.theme.error ?? props.theme.textMuted)
+        : usageTone() === "warn"
+          ? (props.theme.warning ?? props.theme.textMuted)
+          : props.theme.textMuted}
+      selectable={false}
+    >
       {usageLine()}
     </text>
   )

package/dist/codie.js

@@ -188,8 +188,22 @@ async function main() {
                     return null;
                 }
             },
+            isEngine: codieRuntimeInstall_1.isEngineOnDisk,
         }),
         install: (missing) => (0, codieRuntimeInstall_1.installCodieRuntimeOnDisk)(missing, stateDir),
+        repair: (unlinked) => {
+            // npm 12 skips dependency install scripts; codie runs opencode-ai's own
+            // link step instead (not when npm is explicitly set to ignore scripts).
+            console.error("codie: finishing the engine setup npm skipped (opencode-ai's postinstall)…");
+            const linked = (0, codieRuntimeInstall_1.linkEngineOnDisk)(unlinked.packageDir);
+            // npm set to ignore scripts: a reinstall would hit the same wall, so stop
+            // with the one clear step instead of downloading again every run.
+            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;
+        },
     });
     const metadataPlugin = (0, url_1.pathToFileURL)(assetPath("opencode-plugin.mjs")).href;
     const capturePlugin = (0, codieLauncher_1.resolveCapturePlugin)({ homeDir: os.homedir(), existsSync: fs.existsSync });

package/dist/codieRuntime.d.ts

@@ -8,12 +8,28 @@ export type CodieRuntime = {
     installDir: string;
     binary: string;
     spec: string;
+} | {
+    kind: "unlinked";
+    installDir: string;
+    binary: string;
+    spec: string;
+    packageDir: string;
 };
 export declare function codieRuntimeDir(stateDir: string): string;
-export declare function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }: {
+/**
+ * The real engine is a ~132MB native executable. opencode-ai ships
+ * bin/opencode.exe as a ~500-byte shell script that only prints "postinstall
+ * was not run" until its postinstall swaps the binary in; anything this small
+ * is that placeholder, not an engine. Pure.
+ */
+export declare const ENGINE_MIN_BYTES = 1000000;
+export declare function isEngineSize(bytes: number): boolean;
+export declare function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, isEngine, }: {
     env: Record<string, string | undefined>;
     stateDir: string;
     existsSync: (candidate: string) => boolean;
     resolveBundled: () => string | null;
+    /** Whether a candidate is a real engine, not opencode-ai's placeholder. */
+    isEngine?: (candidate: string) => boolean;
 }): CodieRuntime;
 export declare function assertCodieNodeVersion(version: string): void;

package/dist/codieRuntime.js

@@ -43,8 +43,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CODIE_MIN_NODE_MAJOR = exports.OPENCODE_RUNTIME_SPEC = void 0;
+exports.ENGINE_MIN_BYTES = exports.CODIE_MIN_NODE_MAJOR = exports.OPENCODE_RUNTIME_SPEC = void 0;
 exports.codieRuntimeDir = codieRuntimeDir;
+exports.isEngineSize = isEngineSize;
 exports.resolveCodieRuntime = resolveCodieRuntime;
 exports.assertCodieNodeVersion = assertCodieNodeVersion;
 const path = __importStar(require("path"));
@@ -62,7 +63,20 @@ function codieRuntimeDir(stateDir) {
 function installedBinary(stateDir) {
     return path.join(codieRuntimeDir(stateDir), "node_modules", "opencode-ai", "bin", "opencode.exe");
 }
-function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }) {
+/**
+ * The real engine is a ~132MB native executable. opencode-ai ships
+ * bin/opencode.exe as a ~500-byte shell script that only prints "postinstall
+ * was not run" until its postinstall swaps the binary in; anything this small
+ * is that placeholder, not an engine. Pure.
+ */
+exports.ENGINE_MIN_BYTES = 1_000_000;
+function isEngineSize(bytes) {
+    return bytes >= exports.ENGINE_MIN_BYTES;
+}
+function installedPackageDir(stateDir) {
+    return path.join(codieRuntimeDir(stateDir), "node_modules", "opencode-ai");
+}
+function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, isEngine = () => true, }) {
     // 1. Explicit override — the air-gapped / pre-provisioned escape hatch.
     const override = env.CODIEDEV_OPENCODE_BINARY?.trim();
     if (override) {
@@ -74,12 +88,16 @@ function resolveCodieRuntime({ env, stateDir, existsSync, resolveBundled, }) {
     // 2. A bundled engine, if this package was installed with one (dev checkout,
     //    or a future vendored distribution).
     const bundled = resolveBundled();
-    if (bundled)
+    if (bundled && isEngine(bundled))
         return { kind: "ready", binary: bundled };
     // 3. The lazily installed engine.
     const binary = installedBinary(stateDir);
-    if (existsSync(binary))
+    if (existsSync(binary)) {
+        if (!isEngine(binary)) {
+            return { kind: "unlinked", installDir: codieRuntimeDir(stateDir), binary, spec: exports.OPENCODE_RUNTIME_SPEC, packageDir: installedPackageDir(stateDir) };
+        }
         return { kind: "ready", binary };
+    }
     return { kind: "missing", installDir: codieRuntimeDir(stateDir), binary, spec: exports.OPENCODE_RUNTIME_SPEC };
 }
 function assertCodieNodeVersion(version) {

package/dist/codieRuntimeInstall.d.ts

@@ -1,9 +1,17 @@
 import { CodieRuntime } from "./codieRuntime";
+type InstallableCodieRuntime = Exclude<CodieRuntime, {
+    kind: "ready";
+}>;
+/** Outcome of running opencode-ai's own link step. `detail` is its error. */
+export type LinkResult = {
+    ok: boolean;
+    detail?: string;
+};
+/** linkEngine's detail when npm is explicitly set not to run install scripts. */
+export declare const IGNORE_SCRIPTS = "ignore-scripts";
 export declare function buildRuntimeInstallArgs(stagingDir: string, spec: string): string[];
 export interface InstallDeps {
-    runtime: Extract<CodieRuntime, {
-        kind: "missing";
-    }>;
+    runtime: InstallableCodieRuntime;
     makeStagingDir: () => string;
     run: (args: string[]) => {
         status: number | null;
@@ -13,15 +21,36 @@ export interface InstallDeps {
     rename: (from: string, to: string) => void;
     remove: (target: string) => void;
     log: (message: string) => void;
+    /** Whether a file is a real engine, not opencode-ai's placeholder script. */
+    isEngine?: (candidate: string) => boolean;
+    /** Run opencode-ai's postinstall in a package dir. */
+    linkEngine?: (packageDir: string) => LinkResult;
 }
 export declare function installCodieRuntime(deps: InstallDeps): void;
-export declare function ensureCodieRuntimeBinary({ resolve, install, }: {
+export declare function ensureCodieRuntimeBinary({ resolve, install, repair, }: {
     resolve: () => CodieRuntime;
-    install: (runtime: Extract<CodieRuntime, {
-        kind: "missing";
-    }>) => void;
+    install: (runtime: InstallableCodieRuntime) => void;
+    /** Link an unlinked install in place (runs its postinstall); true if it's now an engine. */
+    repair?: (runtime: Extract<CodieRuntime, {
+        kind: "unlinked";
+    }>) => boolean;
 }): string;
-export declare function installCodieRuntimeOnDisk(runtime: Extract<CodieRuntime, {
-    kind: "missing";
-}>, stateDir: string): void;
+/** Why an installed engine still isn't runnable, with opencode-ai's own error. Pure. */
+export declare function linkFailure(linked: LinkResult, packageDir?: string): string;
+/** A cmd.exe command line: each argument double-quoted when it has spaces or
+ *  shell metacharacters (paths like C:\Users\First Last\…). Pure. */
+export declare function windowsCommand(command: string, args: string[]): string;
+/** A real engine on disk (not opencode-ai's placeholder script). */
+export declare function isEngineOnDisk(candidate: string): boolean;
+/** Whether npm is explicitly configured not to run install scripts (an org
+ *  policy codie shouldn't bypass). npm 12's default script approval isn't this. */
+export declare function npmIgnoresScripts(env?: Record<string, string | undefined>): boolean;
+/** Run opencode-ai's own postinstall, which links the platform binary into
+ *  bin/opencode.exe (and picks the right build for this CPU/libc). The same
+ *  step npm would have run; skipped when npm is set to ignore scripts. */
+export declare function linkEngineOnDisk(packageDir: string, { ignoreScripts }?: {
+    ignoreScripts?: () => boolean;
+}): LinkResult;
+export declare function installCodieRuntimeOnDisk(runtime: InstallableCodieRuntime, stateDir: string): void;
 export declare function defaultStagingRoot(): string;
+export {};

package/dist/codieRuntimeInstall.js

@@ -39,9 +39,15 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGNORE_SCRIPTS = void 0;
 exports.buildRuntimeInstallArgs = buildRuntimeInstallArgs;
 exports.installCodieRuntime = installCodieRuntime;
 exports.ensureCodieRuntimeBinary = ensureCodieRuntimeBinary;
+exports.linkFailure = linkFailure;
+exports.windowsCommand = windowsCommand;
+exports.isEngineOnDisk = isEngineOnDisk;
+exports.npmIgnoresScripts = npmIgnoresScripts;
+exports.linkEngineOnDisk = linkEngineOnDisk;
 exports.installCodieRuntimeOnDisk = installCodieRuntimeOnDisk;
 exports.defaultStagingRoot = defaultStagingRoot;
 const fs = __importStar(require("fs"));
@@ -49,6 +55,8 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const codieRuntime_1 = require("./codieRuntime");
+/** linkEngine's detail when npm is explicitly set not to run install scripts. */
+exports.IGNORE_SCRIPTS = "ignore-scripts";
 function buildRuntimeInstallArgs(stagingDir, spec) {
     // No --registry / --proxy: inherit whatever npm config the developer's
     // machine already has so an internal mirror keeps working.
@@ -64,7 +72,7 @@ function buildRuntimeInstallArgs(stagingDir, spec) {
     ];
 }
 function installCodieRuntime(deps) {
-    const { runtime, makeStagingDir, run, exists, rename, remove, log } = deps;
+    const { runtime, makeStagingDir, run, exists, rename, remove, log, isEngine = () => true, linkEngine } = deps;
     const staging = makeStagingDir();
     log(`Installing the Codie engine (${runtime.spec}). This runs once, and only for \`codie\`.`);
     let result;
@@ -87,6 +95,35 @@ function installCodieRuntime(deps) {
         throw new Error(`The Codie engine install did not produce a runtime binary. ` +
             `Check that ${runtime.spec} is available from your npm registry.`);
     }
+    // The placeholder exists even when postinstall never ran (npm 12 skips
+    // dependency install scripts); link it here — what opencode-ai's own error
+    // tells you to do — before promoting.
+    if (!isEngine(stagedBinary)) {
+        let linked = { ok: false };
+        try {
+            linked = linkEngine?.(path.dirname(path.dirname(stagedBinary))) ?? { ok: false };
+        }
+        catch (error) {
+            linked = { ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+        if (!linked.ok || !isEngine(stagedBinary)) {
+            if (linked.detail === exports.IGNORE_SCRIPTS) {
+                // npm is set to ignore scripts: keep the install (promote it) so the
+                // printed postinstall path exists and the next run is a no-download
+                // "unlinked" that stops with the same step, not another download.
+                try {
+                    rename(staging, runtime.installDir);
+                }
+                finally {
+                    remove(staging);
+                }
+            }
+            else {
+                remove(staging);
+            }
+            throw new Error(linkFailure(linked, path.join(runtime.installDir, "node_modules", "opencode-ai")));
+        }
+    }
     try {
         rename(staging, runtime.installDir);
     }
@@ -98,13 +135,33 @@ function installCodieRuntime(deps) {
     }
 }
 // Resolve the engine, downloading it once if this is the first `codie` run.
-function ensureCodieRuntimeBinary({ resolve, install, }) {
+function ensureCodieRuntimeBinary({ resolve, install, repair, }) {
     const runtime = resolve();
     if (runtime.kind === "ready")
         return runtime.binary;
+    // An install whose postinstall never ran: link it in place (no download).
+    // Re-resolve after, so a concurrent repair or a partial link falls through
+    // to a reinstall rather than launching a missing file.
+    if (runtime.kind === "unlinked" && repair?.(runtime)) {
+        const after = resolve();
+        if (after.kind === "ready")
+            return after.binary;
+    }
     install(runtime);
     return runtime.binary;
 }
+/** Why an installed engine still isn't runnable, with opencode-ai's own error. Pure. */
+function linkFailure(linked, packageDir) {
+    if (linked.detail === exports.IGNORE_SCRIPTS) {
+        const script = packageDir ? `"${path.join(packageDir, "postinstall.mjs")}"` : "postinstall.mjs in the opencode-ai package";
+        return (`The Codie engine installed, but npm is set to ignore install scripts (ignore-scripts=true), ` +
+            `so codie won't run opencode-ai's setup step. Run \`node ${script}\` yourself, ` +
+            `or set CODIEDEV_OPENCODE_BINARY to an opencode binary.`);
+    }
+    return (`The Codie engine installed, but its setup step (opencode-ai's postinstall) failed, so there is no runnable engine` +
+        (linked.detail ? `: ${linked.detail}` : ".") +
+        ` Set CODIEDEV_OPENCODE_BINARY to an opencode binary to use a pre-provisioned engine.`);
+}
 function installFailure(detail) {
     return new Error(`Could not download the Codie engine: ${detail}\n` +
         `If you are behind a proxy or an internal registry, make sure npm can reach it. ` +
@@ -112,6 +169,62 @@ function installFailure(detail) {
 }
 // ── Real-world wiring ───────────────────────────────────────────────────
 // Kept separate from the pure logic above so tests never shell out to npm.
+/** A cmd.exe command line: each argument double-quoted when it has spaces or
+ *  shell metacharacters (paths like C:\Users\First Last\…). Pure. */
+function windowsCommand(command, args) {
+    const quote = (a) => (/[\s"&|<>^()%!]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a);
+    return [command, ...args.map(quote)].join(" ");
+}
+/** A real engine on disk (not opencode-ai's placeholder script). */
+function isEngineOnDisk(candidate) {
+    try {
+        return (0, codieRuntime_1.isEngineSize)(fs.statSync(candidate).size);
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether npm is explicitly configured not to run install scripts (an org
+ *  policy codie shouldn't bypass). npm 12's default script approval isn't this. */
+function npmIgnoresScripts(env = process.env) {
+    // npm reads either case and treats anything but a false-ish value as true.
+    const fromEnv = env.npm_config_ignore_scripts ?? env.NPM_CONFIG_IGNORE_SCRIPTS;
+    if (fromEnv !== undefined)
+        return !["", "false", "0", "null", "no"].includes(fromEnv.trim().toLowerCase());
+    const opts = { encoding: "utf8", timeout: 10_000, windowsHide: true };
+    // npm.cmd needs a shell on Windows (Node 20+ refuses to spawn .cmd without
+    // one). One constant command string — args plus shell:true is deprecated.
+    const result = process.platform === "win32"
+        ? (0, child_process_1.spawnSync)("npm.cmd config get ignore-scripts", { ...opts, shell: true })
+        : (0, child_process_1.spawnSync)("npm", ["config", "get", "ignore-scripts"], opts);
+    return result.status === 0 && (result.stdout || "").trim() === "true";
+}
+const LINK_TIMEOUT_MS = 120_000;
+/** Run opencode-ai's own postinstall, which links the platform binary into
+ *  bin/opencode.exe (and picks the right build for this CPU/libc). The same
+ *  step npm would have run; skipped when npm is set to ignore scripts. */
+function linkEngineOnDisk(packageDir, { ignoreScripts = npmIgnoresScripts } = {}) {
+    const script = path.join(packageDir, "postinstall.mjs");
+    if (!fs.existsSync(script))
+        return { ok: false, detail: "opencode-ai has no postinstall.mjs" };
+    if (ignoreScripts())
+        return { ok: false, detail: exports.IGNORE_SCRIPTS };
+    const result = (0, child_process_1.spawnSync)(process.execPath, [script], {
+        cwd: packageDir,
+        encoding: "utf8",
+        stdio: ["ignore", "ignore", "pipe"],
+        timeout: LINK_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    if (result.error || result.signal) {
+        return { ok: false, detail: result.error ? result.error.message : `timed out after ${LINK_TIMEOUT_MS / 1000}s` };
+    }
+    if (result.status !== 0)
+        return { ok: false, detail: (result.stderr || "").trim().split("\n").slice(-3).join(" ") || `exit ${result.status}` };
+    return isEngineOnDisk(path.join(packageDir, "bin", "opencode.exe"))
+        ? { ok: true }
+        : { ok: false, detail: "postinstall ran but left no engine" };
+}
 function installCodieRuntimeOnDisk(runtime, stateDir) {
     installCodieRuntime({
         runtime,
@@ -121,12 +234,16 @@ function installCodieRuntimeOnDisk(runtime, stateDir) {
             return fs.mkdtempSync(path.join(path.dirname((0, codieRuntime_1.codieRuntimeDir)(stateDir)), ".runtime-staging-"));
         },
         run: (args) => {
-            const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-            const result = (0, child_process_1.spawnSync)(npm, args, {
+            const opts = {
                 encoding: "utf8",
                 stdio: ["ignore", "inherit", "pipe"],
                 env: { ...process.env, npm_config_yes: "true" },
-            });
+            };
+            // Windows: Node 20+ refuses to spawn npm.cmd without a shell (EINVAL),
+            // which made the engine install fail outright there. One quoted string.
+            const result = process.platform === "win32"
+                ? (0, child_process_1.spawnSync)(windowsCommand("npm.cmd", args), { ...opts, shell: true, windowsHide: true })
+                : (0, child_process_1.spawnSync)("npm", args, opts);
             if (result.error)
                 throw result.error;
             return { status: result.status, stderr: result.stderr || "" };
@@ -138,6 +255,8 @@ function installCodieRuntimeOnDisk(runtime, stateDir) {
         },
         remove: (target) => fs.rmSync(target, { recursive: true, force: true }),
         log: (message) => console.error(message),
+        isEngine: isEngineOnDisk,
+        linkEngine: linkEngineOnDisk,
     });
 }
 function defaultStagingRoot() {

package/dist/codieUsage.d.ts

@@ -39,6 +39,13 @@ export interface CodieUsage {
  * Returns "" when there is nothing honest to say.
  */
 export declare function formatUsageLine(usage: CodieUsage | null | undefined): string;
+export type UsageTone = "normal" | "warn" | "critical";
+/**
+ * How urgently the status line should read, from the limit that will stop
+ * this developer first: their own cap, or the shared pool when they have no
+ * cap or the pool runs out sooner. 75% warns, 90% is critical.
+ */
+export declare function usageTone(usage: CodieUsage | null | undefined): UsageTone;
 /**
  * What this session just cost. Returns "" when the session billed nothing,
  * because a developer who spent nothing does not need to be told a number.

package/dist/codieUsage.js

@@ -9,6 +9,7 @@
 // delay, or break a coding session. No snapshot means no line.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatUsageLine = formatUsageLine;
+exports.usageTone = usageTone;
 exports.formatSessionCostLine = formatSessionCostLine;
 exports.fetchCodieUsage = fetchCodieUsage;
 const USAGE_TIMEOUT_MS = 4000;
@@ -51,6 +52,16 @@ function formatUsageLine(usage) {
         const share = percent(budget.userSpentUsd, budget.userBudgetUsd);
         if (share)
             segments.push(share);
+        // A personal cap does not help once the shared pool is nearly gone: say
+        // so when the pool is running low and will stop this developer before
+        // their own cap does.
+        if (poolBindsFirst(budget) && typeof budget.companyBudgetUsd === "number"
+            && budget.companyBudgetUsd > 0
+            && budget.companySpentUsd / budget.companyBudgetUsd >= 0.75) {
+            const share = percent(budget.companySpentUsd, budget.companyBudgetUsd);
+            if (share)
+                segments.push(`team pool ${share}`);
+        }
     }
     else {
         segments.push(money(budget.userSpentUsd));
@@ -62,6 +73,10 @@ function formatUsageLine(usage) {
                 segments.push(`team ${share}`);
         }
     }
+    if (typeof budget.companyBudgetUsd === "number" && budget.companyBudgetUsd > 0
+        && budget.companySpentUsd >= budget.companyBudgetUsd) {
+        segments.push("team pool used up");
+    }
     if (inFlight.requests > 0)
         segments.push(`${inFlight.requests} in flight`);
     // Stale holds cap a budget while doing no work. Naming them is the
@@ -70,6 +85,37 @@ function formatUsageLine(usage) {
         segments.push(`${money(inFlight.staleHeldUsd)} held stale`);
     return segments.join(" · ");
 }
+function poolBindsFirst(budget) {
+    if (typeof budget.companyBudgetUsd !== "number" || typeof budget.userBudgetUsd !== "number")
+        return false;
+    const poolLeft = Math.max(0, budget.companyBudgetUsd - budget.companySpentUsd);
+    const userLeft = Math.max(0, budget.userBudgetUsd - budget.userSpentUsd);
+    return budget.userBudgetUsd > 0 && poolLeft < userLeft;
+}
+/**
+ * How urgently the status line should read, from the limit that will stop
+ * this developer first: their own cap, or the shared pool when they have no
+ * cap or the pool runs out sooner. 75% warns, 90% is critical.
+ */
+function usageTone(usage) {
+    if (!usage || !usage.enabled)
+        return "normal";
+    const { budget } = usage;
+    const ratios = [];
+    if (typeof budget.userBudgetUsd === "number" && budget.userBudgetUsd > 0) {
+        ratios.push(budget.userSpentUsd / budget.userBudgetUsd);
+    }
+    if (typeof budget.companyBudgetUsd === "number" && budget.companyBudgetUsd > 0
+        && (typeof budget.userBudgetUsd !== "number" || poolBindsFirst(budget))) {
+        ratios.push(budget.companySpentUsd / budget.companyBudgetUsd);
+    }
+    const worst = ratios.length ? Math.max(...ratios) : 0;
+    if (worst >= 0.9)
+        return "critical";
+    if (worst >= 0.75)
+        return "warn";
+    return "normal";
+}
 function tokens(total) {
     // Rounded by arithmetic, not toFixed: 2.55 is not exactly representable, so
     // toFixed(1) rounds it down and the same count can read two ways.

package/package.json

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