codiedev 0.10.0-beta.4 → 0.10.0-beta.5

package/dist/commands/react.js

@@ -1,6 +1,4 @@
 "use strict";
-// `codiedev react <postId> <emoji>` — toggle a reaction on a feed post.
-// Calling twice with the same emoji removes it.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runReact = runReact;
 const shared_1 = require("./shared");

package/dist/commands/reverseTicket.js

@@ -5,15 +5,6 @@ exports.runReverseTicket = runReverseTicket;
 const child_process_1 = require("child_process");
 const shared_1 = require("./shared");
 const prUrl_1 = require("../prUrl");
-/**
- * Run a binary with an explicit argv, never a shell.
- *
- * The `gh`/`glab` API paths are built from an owner/repo parsed out of a URL the
- * caller pastes in. `parsePrOrMrUrl` only bounds those segments to "no slash",
- * so they can still carry `$(…)`, backticks or `;` — which a `shell: true`
- * invocation would execute. Passing argv directly means the shell never sees
- * them at all.
- */
 function runArgv(bin, argv, opts = {}) {
     const res = (0, child_process_1.spawnSync)(bin, argv, {
         stdio: ["pipe", "pipe", "pipe"],
@@ -28,10 +19,6 @@ function runArgv(bin, argv, opts = {}) {
     }
     return res.stdout ?? "";
 }
-// Git ref names legally contain `$()`, `;`, `|` and backticks, all of which
-// break out of the `shell: true` git calls in branch mode below. A ref supplied
-// via `--base` is caller-controlled, so bound it to the safe subset before it
-// reaches a command line. Mirrors `validate_ref` in modal/runner.py.
 const SAFE_REF_RE = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,255}$/;
 function isSafeRef(ref) {
     if (!ref || ref.startsWith("-"))
@@ -56,7 +43,6 @@ async function fetchPrOrMrBundle(parsed, rawUrl, noTruncate) {
                 diff = noTruncate ? rawDiff : rawDiff.slice(0, 12_000);
             }
             catch {
-                // diff is nice-to-have
             }
         }
         catch (err) {
@@ -80,9 +66,6 @@ async function fetchPrOrMrBundle(parsed, rawUrl, noTruncate) {
             htmlUrl: prJson.html_url ?? rawUrl,
         };
     }
-    // GitLab path. `glab api projects/<encoded-path>/...` returns the same
-    // MR shape as the REST API. We pull the diff from `merge_requests/<n>/changes`
-    // and reassemble a unified diff out of each file's `diff` blob.
     const projectPath = `${parsed.owner}/${parsed.repo}`;
     let mrJson;
     let changesJson;
@@ -142,9 +125,6 @@ function ghRaw(path) {
         path,
     ]);
 }
-// glab api takes a project path (URL-encoded) or numeric id and a sub-path.
-// For self-hosted GitLab, glab respects `GITLAB_HOST` env if the user has
-// configured glab against their internal instance.
 function glabApi(projectPath, subpath) {
     const encoded = encodeURIComponent(projectPath);
     return JSON.parse(runArgv("glab", ["api", `projects/${encoded}/${subpath}`]));
@@ -179,7 +159,6 @@ function parseArgs(args) {
 }
 async function runReverseTicket(args) {
     const { prUrl, base, forcedKey, noTruncate } = parseArgs(args);
-    // No PR URL → branch mode (mid-session, no PR exists yet).
     if (!prUrl) {
         return runBranchMode({ explicitBase: base, forcedKey });
     }
@@ -282,7 +261,6 @@ function safeGit(fn) {
     }
 }
 async function runBranchMode(opts) {
-    // Confirm we're in a git repo.
     try {
         git("rev-parse --is-inside-work-tree");
     }
@@ -290,13 +268,10 @@ async function runBranchMode(opts) {
         console.error("Not inside a git repository. Run this from a checked-out repo.");
         process.exit(1);
     }
-    // `--base` lands unquoted on a `git` command line below, so reject anything
-    // outside the safe-ref subset instead of letting the shell interpret it.
     if (opts.explicitBase !== undefined && !isSafeRef(opts.explicitBase)) {
         console.error(`Invalid --base ref: ${JSON.stringify(opts.explicitBase)}. Expected a plain branch or tag name.`);
         process.exit(1);
     }
-    // Resolve base ref — explicit, then origin/main, then origin/master.
     const candidates = opts.explicitBase
         ? [opts.explicitBase]
         : ["origin/main", "origin/master"];
@@ -308,7 +283,6 @@ async function runBranchMode(opts) {
             break;
         }
         catch {
-            // try next
         }
     }
     if (!baseRef) {
@@ -322,9 +296,6 @@ async function runBranchMode(opts) {
     }
     const baseSha = git(`merge-base HEAD ${baseRef}`);
     const headSha = git("rev-parse HEAD");
-    // Filter generated/lockfile noise from the diff body. The --stat (collected
-    // separately) still includes every file untouched, so excluded files still
-    // surface in the ticket's "Other files touched" section.
     const isNoise = (p) => /(^|\/)(node_modules|dist|build|\.next|\.turbo|coverage|out)\//.test(p) ||
         /(^|\/)package-lock\.json$/.test(p) ||
         /(^|\/)yarn\.lock$/.test(p) ||
@@ -348,8 +319,6 @@ async function runBranchMode(opts) {
         }
     };
     const shQuote = (s) => `'${s.replace(/'/g, "'\\''")}'`;
-    // Capture all work relative to the base ref: committed + uncommitted-tracked
-    // + new untracked. Matches "ticket my current changes" intent.
     const trackedRaw = git(`diff --name-only ${baseSha}`);
     const trackedFiles = trackedRaw ? trackedRaw.split("\n").filter(Boolean) : [];
     const untrackedRaw = safeGit(() => git("ls-files --others --exclude-standard"));
@@ -375,7 +344,6 @@ async function runBranchMode(opts) {
             .slice(0, 8_000);
     }
     catch {
-        // best effort
     }
     let diff = "";
     try {
@@ -391,7 +359,6 @@ async function runBranchMode(opts) {
             .slice(0, 40_000);
     }
     catch {
-        // best effort
     }
     let repo;
     try {

package/dist/commands/search.js

@@ -1,8 +1,4 @@
 "use strict";
-// `codiedev search "<query>"` — semantic + keyword search across the org's
-// captured sessions, artifacts, and skills. Hits are filtered by companyId
-// server-side, so a single search surfaces results from every teammate's
-// prior sessions in the same workspace.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSearch = runSearch;
 const shared_1 = require("./shared");

package/dist/commands/send.js

@@ -1,8 +1,4 @@
 "use strict";
-// `codiedev send <filename> <recipient> [message]` — share an artifact AND
-// send a short message that lands in the teammate's inbox. The active-
-// handoff version of `codiedev share`. Use this when the user is actively
-// looping someone in.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSend = runSend;
 const shared_1 = require("./shared");
@@ -13,7 +9,6 @@ function parseArgs(args) {
         console.error('Usage: codiedev send <filename> <recipient> ["<message>"]');
         process.exit(1);
     }
-    // Recombine remaining tokens — supports both quoted and unquoted messages.
     const message = rest.length > 0 ? (0, shared_1.stripQuotes)(rest.join(" ")) : undefined;
     return { filename, to, message };
 }

package/dist/commands/share.js

@@ -1,7 +1,4 @@
 "use strict";
-// `codiedev share <filename> <recipient> [--role read|edit]` — silently
-// grant a teammate access to an artifact (no notification). Use
-// `codiedev send` instead when the user wants to actively loop someone in.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runShare = runShare;
 const shared_1 = require("./shared");
@@ -71,7 +68,6 @@ async function runShare(args, configOverride) {
             latencyMs: Date.now() - start,
             error: err.message,
         });
-        // Ambiguous recipients return 409 with candidates in the body.
         const body = err.body;
         if (body && Array.isArray(body.candidates) && body.candidates.length > 0) {
             console.error(`Recipient "${parsed.to}" is ambiguous. Candidates:`);

package/dist/commands/shared.js

@@ -45,13 +45,6 @@ const https = __importStar(require("https"));
 const http = __importStar(require("http"));
 const utils_1 = require("../utils");
 const version_1 = require("../version");
-/**
- * Layer per-command env overrides on top of the on-disk config. Useful for
- * ad-hoc testing — point a prod-connected CLI at a dev Convex deployment
- * without re-running `codiedev connect`. Both CODIEDEV_URL and CODIEDEV_TOKEN
- * must be set together (half-overrides would mismatch URL and auth realm).
- * Other fields (companyId, repos[]) come from the file unchanged.
- */
 function applyConfigEnvOverrides(config) {
     const url = process.env.CODIEDEV_URL;
     const token = process.env.CODIEDEV_TOKEN;
@@ -60,10 +53,6 @@ function applyConfigEnvOverrides(config) {
     }
     return config;
 }
-/**
- * Require a connected Codiedev config. Exits the process with a helpful
- * message if the user hasn't run `codiedev connect` yet.
- */
 function requireConfig() {
     const config = (0, utils_1.readConfig)();
     if (!config) {
@@ -72,10 +61,6 @@ function requireConfig() {
     }
     return applyConfigEnvOverrides(config);
 }
-/**
- * Perform an authenticated HTTP request against the Codiedev backend.
- * Returns the parsed JSON response body. Throws on non-2xx.
- */
 function apiRequest(method, path, options) {
     return new Promise((resolve, reject) => {
         const base = options.config.backendUrl;
@@ -135,12 +120,6 @@ function apiRequest(method, path, options) {
         req.end();
     });
 }
-/**
- * Fire-and-forget per-invocation telemetry from CLI subcommands. Mirrors
- * the MCP server's emitTelemetry but stamps `source: "cli"` so adoption
- * dashboards can distinguish between the two surfaces. Never blocks the
- * user's command, never throws — telemetry must not change behavior.
- */
 function recordAgentEvent(config, event) {
     apiRequest("POST", "/api/telemetry/mcp-event", {
         config,
@@ -153,7 +132,6 @@ function recordAgentEvent(config, event) {
             source: "cli",
         },
     }).catch(() => {
-        // Swallow — telemetry must never affect user-facing flow.
     });
 }
 function recordInstallEvent(config, event) {
@@ -169,14 +147,8 @@ function recordInstallEvent(config, event) {
             cliVersion: version_1.CLI_VERSION,
         },
     }).catch(() => {
-        // Swallow — telemetry must never affect connect flow.
     });
 }
-/**
- * Wraps a CLI subcommand body so success and failure both record telemetry
- * and the original error propagates after the event is queued. Use this in
- * each `runXxx` command instead of inline timing + try/catch boilerplate.
- */
 async function withTelemetry(config, tool, fn) {
     const start = Date.now();
     try {
@@ -194,9 +166,6 @@ async function withTelemetry(config, tool, fn) {
         throw err;
     }
 }
-/**
- * Relative-time formatter for inbox / listing output.
- */
 function timeAgo(ts) {
     const diff = Date.now() - ts;
     const mins = Math.floor(diff / 60000);
@@ -210,10 +179,6 @@ function timeAgo(ts) {
     const days = Math.floor(hours / 24);
     return `${days}d ago`;
 }
-/**
- * Strip surrounding quotes from a CLI argument if the user wrapped it.
- * `codiedev ping <name> "hey"` on some shells passes the quotes through.
- */
 function stripQuotes(s) {
     if ((s.startsWith('"') && s.endsWith('"')) ||
         (s.startsWith("'") && s.endsWith("'"))) {

package/dist/commands/traces.js

@@ -0,0 +1,280 @@
+"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.TRACES_HELP = void 0;
+exports.slugify = slugify;
+exports.casesBrief = casesBrief;
+exports.resultsTemplate = resultsTemplate;
+exports.runTraces = runTraces;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const shared_1 = require("./shared");
+exports.TRACES_HELP = `
+codiedev traces — test cases saved from Codiedev → Traces
+
+  codiedev traces agents                 Agents you maintain, with saved case counts
+  codiedev traces cases <agent> [--suite name] [--case id[,id]] [--model id] [--out dir] [--json]
+                                         Write an agent's cases (one suite, or just
+                                         the cases named) into this repo, default
+                                         .codiedev/traces/<agent>[/<suite>]/, then
+                                         ask your coding agent to run them.
+                                         --model runs them on another model, e.g.
+                                         the replacement for a retiring one
+  codiedev traces report <results.json> [--harness name]
+                                         Send the filled-in results back, so
+                                         Traces shows the pass rate for that model
+
+  <agent> is the agent's name (its API key name) or id. Only an agent's
+  maintainers can pull its cases or report on them.
+`.trim();
+const FLAG_LABEL = {
+    budget_block: "refused for budget",
+    errors: "model call failed",
+    tool_loop: "repeated the same tool call",
+    truncated: "reply cut off at max_tokens",
+    context_overflow: "prompt over 70% of the context window",
+};
+const TRIES = 3;
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+const recordedModel = (res) => res.cases.flatMap((c) => c.steps.map((s) => s.model))[0] ?? "the recorded model";
+function slugify(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+function casesBrief(res, casesFile, opts = {}) {
+    const fix = res.cases.filter((c) => c.kind === "fix");
+    const keep = res.cases.filter((c) => c.kind === "keep");
+    const withBodies = res.cases.filter((c) => c.steps.some((s) => s.request)).length;
+    const target = opts.model;
+    const results = opts.resultsFile ? path.basename(opts.resultsFile) : "results.json";
+    const lines = [
+        `# Test cases for ${res.agent.name}${res.suite ? ` · ${res.suite}` : ""}${target ? ` on ${target}` : ""}`,
+        "",
+        res.agent.description ? `${res.agent.description}\n` : "",
+        `Saved from Codiedev → Traces. ${plural(res.cases.length, "case")} in \`${path.basename(casesFile)}\` (one JSON object per line):`,
+        `- **${fix.length} to fix**: production runs that failed. The fix should make them pass.`,
+        `- **${keep.length} to keep passing**: good runs. They should still pass after any change.`,
+        "",
+    ];
+    if (target) {
+        lines.push("## This is a model check", "", `Run every case on **${target}** instead of ${recordedModel(res)} (the model the cases were recorded on). Change only the model the agent asks the gateway for; keep its prompts and tools as they are, so the result says how ${target} does on the same work.`, "");
+    }
+    lines.push("## How to run them", "", "1. Find where this agent builds its model requests and calls the Codiedev gateway.", `2. For each case, replay \`steps[0].request\` (the first prompt the agent sent) through the agent's own code path, so tools and prompts are the current version, not the recorded one${target ? `, with the model set to ${target}` : ""}.`, "3. Judge each try against the case:", "   - A case's `expected`, when present, is what a passing answer looks like (a reference reply or criteria). It wins over everything below.", "   - `fix` cases: the run must not reproduce its `flags` (listed below), and must finish (no failed call, no `finish_reason: \"length\"`, no repeated identical tool call).", "   - `keep` cases: the final reply must still do what the recorded final reply did. Compare meaning, not wording.", "   - A case's `note`, when present, is the engineer's extra context.");
+    if (res.judge?.model || res.judge?.rubric) {
+        lines.push(`   - Where passing needs judgement, judge with **${res.judge.model ?? "a strong model"}** through the gateway${res.judge.rubric ? `, using this rubric: "${res.judge.rubric}"` : ""}. Use the same judge for every model so results compare.`);
+    }
+    lines.push(`4. Run each case ${TRIES} times: agents are stochastic, so report a pass rate per case, not a single result.`, `5. Fill in \`${results}\`: for each case set \`passes\` (out of \`tries\`), \`output\` (the agent's final reply on one try, so it can be compared side by side with other models) and a one-line \`note\` on any failure. Set \`harness\` to the coding agent you are (claude-code, codex, cursor, copilot, …).`, `6. Send it back: \`codiedev traces report ${opts.resultsFile ? path.relative(process.cwd(), opts.resultsFile) || results : results}\`. Then show a table: case, kind, passes out of ${TRIES}, and the failure note.`, "", "Send real model calls through the gateway with the agent's usual key and `X-Codiedev-Run-Id: case-<id>-<try>`, so the replays show up in Traces too.", "");
+    if (withBodies < res.cases.length) {
+        lines.push(`Note: ${plural(res.cases.length - withBodies, "case")} ${res.cases.length - withBodies === 1 ? "has" : "have"} no recorded prompt (the agent wasn't keeping prompts then). For those, rebuild the input from the case's \`expected\` or \`note\`, or skip them and say so.`, "");
+    }
+    lines.push("## Cases", "");
+    for (const c of res.cases) {
+        const flags = c.flags.length ? c.flags.map((f) => FLAG_LABEL[f] ?? f).join(", ") : "no flags";
+        lines.push(`- \`${c.id}\` · ${c.name} · ${c.kind} · ${flags} · ${plural(c.steps.length, "model call")}${c.expected ? ` · expected: "${c.expected.replace(/\s+/g, " ").slice(0, 200)}"` : ""}${c.note ? ` · note: "${c.note}"` : ""}`);
+    }
+    return lines.filter((line, i, all) => !(line === "" && all[i - 1] === "")).join("\n") + "\n";
+}
+function resultsTemplate(res, model) {
+    return {
+        agent: res.agent.name,
+        suite: res.suite,
+        model: model ?? recordedModel(res),
+        judgeModel: res.judge?.model ?? null,
+        harness: null,
+        results: res.cases.map((c) => ({ caseId: c.id, name: c.name, passes: null, tries: TRIES, note: null, output: null })),
+    };
+}
+function flag(args, i, name) {
+    const a = args[i];
+    if (a === name && i + 1 < args.length)
+        return { value: args[i + 1], skip: 1 };
+    if (a.startsWith(`${name}=`))
+        return { value: a.slice(name.length + 1), skip: 0 };
+    return { skip: -1 };
+}
+function parseCasesArgs(args) {
+    const parsed = { json: false };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        let matched = false;
+        for (const [name, key] of [["--out", "out"], ["-o", "out"], ["--suite", "suite"], ["--model", "model"], ["--case", "caseIds"]]) {
+            const f = flag(args, i, name);
+            if (f.skip >= 0) {
+                parsed[key] = f.value;
+                i += f.skip;
+                matched = true;
+                break;
+            }
+        }
+        if (matched)
+            continue;
+        if (a === "--json")
+            parsed.json = true;
+        else if (!a.startsWith("-") && !parsed.agent)
+            parsed.agent = a;
+    }
+    return parsed;
+}
+async function runAgents(config) {
+    const start = Date.now();
+    let res;
+    try {
+        res = await (0, shared_1.apiRequest)("GET", "/api/cli/traces/agents", { config });
+    }
+    catch (err) {
+        const e = err;
+        (0, shared_1.recordAgentEvent)(config, { tool: "codiedev_traces_agents", ok: false, latencyMs: Date.now() - start, error: e.message });
+        console.error(`Couldn't list agents: ${e.message}`);
+        process.exit(1);
+    }
+    (0, shared_1.recordAgentEvent)(config, { tool: "codiedev_traces_agents", ok: true, latencyMs: Date.now() - start });
+    if (!res.agents.length) {
+        console.log("You don't maintain any agents yet. Connect one in Codiedev → Traces → How it works.");
+        return;
+    }
+    for (const agent of res.agents) {
+        const capture = agent.promptDays ? `prompts kept ${agent.promptDays} days` : "metadata only";
+        console.log(`${agent.name.padEnd(28)} ${plural(agent.cases, "case").padStart(9)}   ${capture}`);
+    }
+    console.log("\nPull one: codiedev traces cases <agent>");
+}
+async function runCases(args, config) {
+    const { agent, suite, model, caseIds, out, json } = parseCasesArgs(args);
+    if (!agent) {
+        console.error("Usage: codiedev traces cases <agent> [--suite name] [--model id] [--out dir] [--json]");
+        process.exit(1);
+    }
+    const start = Date.now();
+    let res;
+    try {
+        res = await (0, shared_1.apiRequest)("GET", "/api/cli/traces/cases", { config, query: { agent, ...(suite ? { suite } : {}), ...(caseIds ? { case: caseIds } : {}) } });
+    }
+    catch (err) {
+        const e = err;
+        (0, shared_1.recordAgentEvent)(config, { tool: "codiedev_traces_cases", ok: false, latencyMs: Date.now() - start, error: e.message });
+        if (e.status === 404)
+            console.error(`No agent called "${agent}". See your agents with: codiedev traces agents`);
+        else if (e.status === 403)
+            console.error(`Only ${agent}'s maintainers can pull its test cases.`);
+        else
+            console.error(`Couldn't pull cases: ${e.message}`);
+        process.exit(1);
+    }
+    (0, shared_1.recordAgentEvent)(config, { tool: "codiedev_traces_cases", ok: true, latencyMs: Date.now() - start });
+    if (json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+    }
+    if (!res.cases.length) {
+        console.log(suite
+            ? `${res.agent.name} has no test cases in "${suite}". See your suites in Codiedev → Traces → Test cases.`
+            : `${res.agent.name} has no saved test cases. Open a run in Codiedev → Traces and click "Save as test case".`);
+        return;
+    }
+    const dir = path.resolve(process.cwd(), out ?? path.join(".codiedev", "traces", slugify(res.agent.name), ...(res.suite ? [slugify(res.suite)] : []), ...(caseIds && res.cases.length === 1 ? [slugify(res.cases[0].name)] : []), ...(model ? [slugify(model)] : [])));
+    fs.mkdirSync(dir, { recursive: true });
+    const casesFile = path.join(dir, "cases.jsonl");
+    fs.writeFileSync(casesFile, res.cases.map((c) => JSON.stringify(c)).join("\n") + "\n", "utf8");
+    const resultsFile = path.join(dir, "results.json");
+    fs.writeFileSync(resultsFile, JSON.stringify(resultsTemplate(res, model), null, 2) + "\n", "utf8");
+    const briefFile = path.join(dir, "RUN_CASES.md");
+    fs.writeFileSync(briefFile, casesBrief(res, casesFile, { model, resultsFile }), "utf8");
+    const fix = res.cases.filter((c) => c.kind === "fix").length;
+    const rel = (file) => path.relative(process.cwd(), file) || file;
+    console.log(`✓ ${plural(res.cases.length, "case")} for ${res.agent.name}${res.suite ? ` · ${res.suite}` : ""}${model ? ` on ${model}` : ""} (${fix} to fix, ${res.cases.length - fix} to keep passing)`);
+    console.log(`  ${rel(casesFile)}`);
+    console.log(`  ${rel(briefFile)}`);
+    console.log(`  ${rel(resultsFile)}  (filled in by your coding agent, then: codiedev traces report ${rel(resultsFile)})`);
+    console.log(`\nNext: ask your coding agent to "run the test cases in ${rel(briefFile)}"`);
+}
+async function runReport(args, config) {
+    let file;
+    let harness;
+    for (let i = 0; i < args.length; i++) {
+        const f = flag(args, i, "--harness");
+        if (f.skip >= 0) {
+            harness = f.value;
+            i += f.skip;
+            continue;
+        }
+        if (!args[i].startsWith("-") && !file)
+            file = args[i];
+    }
+    if (!file) {
+        console.error("Usage: codiedev traces report <results.json> [--harness name]");
+        process.exit(1);
+    }
+    let body;
+    try {
+        body = JSON.parse(fs.readFileSync(path.resolve(process.cwd(), file), "utf8"));
+    }
+    catch (err) {
+        console.error(`Couldn't read ${file}: ${err.message}`);
+        process.exit(1);
+    }
+    const missing = body.results.filter((r) => typeof r.passes !== "number");
+    if (missing.length) {
+        console.error(`${plural(missing.length, "case")} in ${file} ${missing.length === 1 ? "has" : "have"} no "passes" yet: ${missing.slice(0, 5).map((r) => r.name).join(", ")}. Run them first.`);
+        process.exit(1);
+    }
+    const start = Date.now();
+    try {
+        const res = await (0, shared_1.apiRequest)("POST", "/api/cli/traces/results", {
+            config,
+            body: { ...body, harness: harness ?? body.harness ?? undefined },
+        });
+        (0, shared_1.recordAgentEvent)(config, { tool: "codiedev_traces_report", ok: true, latencyMs: Date.now() - start });
+        const passed = body.results.filter((r) => r.passes === r.tries).length;
+        console.log(`✓ Reported ${body.agent}${body.suite ? ` · ${body.suite}` : ""} on ${body.model}: ${Math.round(res.passRate * 100)}% of tries passed, ${passed}/${body.results.length} cases passed every try.`);
+        console.log("  See it next to other models in Codiedev → Traces → Test cases.");
+    }
+    catch (err) {
+        const e = err;
+        (0, shared_1.recordAgentEvent)(config, { tool: "codiedev_traces_report", ok: false, latencyMs: Date.now() - start, error: e.message });
+        console.error(e.status === 403 ? `Only ${body.agent}'s maintainers can report its results.` : `Couldn't report: ${e.message}`);
+        process.exit(1);
+    }
+}
+async function runTraces(args, configOverride) {
+    const [sub, ...rest] = args;
+    if (sub === "agents")
+        return runAgents(configOverride ?? (0, shared_1.requireConfig)());
+    if (sub === "cases")
+        return runCases(rest, configOverride ?? (0, shared_1.requireConfig)());
+    if (sub === "report")
+        return runReport(rest, configOverride ?? (0, shared_1.requireConfig)());
+    console.log(exports.TRACES_HELP);
+    if (sub && sub !== "help")
+        process.exit(1);
+}

package/dist/configDir.js

@@ -34,16 +34,6 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.codiedevStateDir = codiedevStateDir;
-// Single source of truth for where the CLI's config/state lives on disk.
-//
-// Defaults to ~/.codiedev. The desktop app sets CODIEDEV_CONFIG_DIR to
-// ~/.codiedev-desktop so a desktop session never touches the user's real
-// prod config — env-based (not a flag) so detached capture-finish/upload
-// children inherit the override automatically.
-//
-// Deliberately dependency-free (only node:path/os) so it can be imported
-// by both utils.ts and modules utils.ts itself imports (e.g. captureLog.ts)
-// without creating a circular import.
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const CONFIG_DIR = process.env.CODIEDEV_CONFIG_DIR?.trim()