codiedev 0.10.0-beta.3 → 0.10.0-beta.5

package/dist/cli.js

@@ -1,19 +1,5 @@
 #!/usr/bin/env node
 "use strict";
-/**
- * Codiedev CLI dispatcher.
- *
- * Subcommands:
- *   codiedev connect                   — link agent CLIs to your org
- *   codiedev push <file>               — author/update a spec/review/decision/etc.
- *   codiedev pull <key>                — fetch an artifact by filename key
- *   codiedev ping <user> "<msg>"       — send a message (optionally --with <key>)
- *   codiedev inbox                     — list pings (use --unread to filter)
- *   codiedev read <ping-id>            — mark read + show full message
- *   codiedev note "<text>"             — capture a thought
- *   codiedev promote <artifact-id>     — promote an extracted artifact to authored
- *   codiedev help                      — show this help
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 const connect_1 = require("./connect");
 const push_1 = require("./commands/push");
@@ -34,6 +20,10 @@ const send_1 = require("./commands/send");
 const react_1 = require("./commands/react");
 const capture_1 = require("./commands/capture");
 const security_1 = require("./commands/security");
+const pack_1 = require("./commands/pack");
+const traces_1 = require("./commands/traces");
+const hookGate_1 = require("./packs/hookGate");
+const sync_1 = require("./packs/sync");
 const version_1 = require("./version");
 const HELP = `
 Codiedev CLI
@@ -43,7 +33,8 @@ Codiedev CLI
   someone left off across sessions and providers.
 
 Connect:
-  codiedev connect                       Link Claude Code / Codex / Cursor to your org
+  codiedev connect                       Link Claude Code / Codex / Cursor /
+                                         GitHub Copilot to your org
   codiedev doctor                        Verify setup, capture, and Agent Security
   codiedev security pilot                Run safe synthetic policy checks
   codiedev security inventory            Inventory MCPs, skills, hooks, plugins,
@@ -96,6 +87,22 @@ Messaging:
   codiedev inbox [--unread] [--limit N]  Show messages
   codiedev read <ping-id>                Mark read + show full message
 
+Starter packs:
+  codiedev pack list                     Packs assigned to your team
+  codiedev pack install [slug] [--harness claude,codex,copilot,cursor,codie]
+                       [--dry-run] [--json]
+                                         Install a pack (or all) into every
+                                         detected tool
+  codiedev pack status                   Installed packs, up to date or not
+
+Traces (agents on the gateway):
+  codiedev traces agents                 Agents you maintain, with saved test cases
+  codiedev traces cases <agent> [--suite name] [--model id]
+                                         Pull an agent's test cases (or one suite)
+                                         into this repo for your coding agent to
+                                         run, optionally on another model
+  codiedev traces report <results.json>  Send the results back to Traces
+
 Discovery:
   codiedev search "<query>"              Semantic search across the team's
                                          captured sessions and artifacts
@@ -159,6 +166,8 @@ locally before any capture leaves your machine, so an offline or failed portal
 status sync never weakens it.
 `.trim();
 const COMMAND_HELP = {
+    pack: pack_1.PACK_HELP,
+    traces: traces_1.TRACES_HELP,
     connect: `
 codiedev connect — link your agent CLI to Codiedev
 
@@ -170,6 +179,7 @@ codiedev connect — link your agent CLI to Codiedev
     - ~/.codex/AGENTS.md instructions    (same, for Codex)
     - ~/.cursor/hooks.json hooks         (session, prompt, security, capture)
     - ~/.cursor/rules/codiedev.mdc       (teaches Cursor the commands)
+    - ~/.copilot/hooks/codiedev.json     (GitHub Copilot: VS Code + CLI capture)
 
   Re-run anytime to swap accounts or refresh the instruction block.
 
@@ -416,6 +426,15 @@ Tokens are per-user. Rotate any time by revoking + creating a new one.
 `.trim();
 async function main() {
     const [, , command, ...rest] = process.argv;
+    if (command === "hook-gate") {
+        (0, hookGate_1.runHookGateCli)(rest);
+        return;
+    }
+    if (command && !["pack", "packs", "help", "docs", "version", "--version", "-v", "--help", "-h"].includes(command) && !rest.includes("--json")) {
+        const nag = (0, sync_1.packNagLine)();
+        if (nag)
+            console.error(`\n${nag}\n`);
+    }
     if (!command || command === "--help" || command === "-h") {
         console.log(HELP);
         return;
@@ -438,7 +457,6 @@ async function main() {
         console.log(DOCS);
         return;
     }
-    // Support `codiedev <command> --help` too.
     if (rest.includes("--help") || rest.includes("-h")) {
         if (COMMAND_HELP[command]) {
             console.log(COMMAND_HELP[command]);
@@ -479,7 +497,6 @@ async function main() {
                 return;
             case "inbox":
             case "check":
-                // Support `codiedev check inbox` as an alias.
                 if (command === "check" && rest[0] === "inbox") {
                     await (0, inbox_1.runInbox)(rest.slice(1));
                 }
@@ -511,6 +528,9 @@ async function main() {
             case "ls":
                 await (0, library_1.runLibrary)(rest);
                 return;
+            case "traces":
+                await (0, traces_1.runTraces)(rest);
+                return;
             case "share":
                 await (0, share_1.runShare)(rest);
                 return;
@@ -525,8 +545,11 @@ async function main() {
             case "ignored":
                 await (0, capture_1.runCaptureCommand)([command, ...rest]);
                 return;
+            case "pack":
+            case "packs":
+                await (0, pack_1.runPack)(rest);
+                return;
             case "capture":
-                // Back-compat alias for the earlier `codiedev capture <sub>` form.
                 await (0, capture_1.runCaptureCommand)(rest);
                 return;
             default:

package/dist/codexHookTrust.js

@@ -37,6 +37,8 @@ exports.codexCommandHookHash = codexCommandHookHash;
 exports.codiedevCodexHookTrustEntries = codiedevCodexHookTrustEntries;
 exports.writeCodexHookTrust = writeCodexHookTrust;
 exports.inspectCodexHookTrust = inspectCodexHookTrust;
+exports.packCodexHookTrustEntries = packCodexHookTrustEntries;
+exports.writeCodexPackHookTrust = writeCodexPackHookTrust;
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -85,8 +87,6 @@ function normalizedTimeout(eventName, value) {
         return Math.min(3, Math.max(1, configured ?? 1));
     return Math.max(1, configured ?? 600);
 }
-/** Codex hashes a canonical, normalized hook identity before it will execute a
- * user hook. Keep this compatible with codex_config::version_for_toml. */
 function codexCommandHookHash(eventName, group, handler) {
     const normalizedHandler = {
         type: "command",
@@ -173,9 +173,6 @@ function removeTable(lines, header) {
     }
     return output;
 }
-/** `codiedev connect` is an explicit install action, so trust only the exact
- * Codiedev commands it just wrote. Any later command change produces a new
- * hash and Codex disables that hook until connect is run again. */
 function writeCodexHookTrust(configPath, hooksPath, hooksFile) {
     const entries = codiedevCodexHookTrustEntries(hooksPath, hooksFile);
     let existing = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf8") : "";
@@ -226,3 +223,62 @@ function inspectCodexHookTrust(configPath, hooksPath, hooksFile, requiredSubcomm
     }).length;
     return { ok: entries.length > 0 && trusted === entries.length, total: entries.length, trusted };
 }
+const PACK_TRUST_BEGIN = "# codiedev-pack-trust:begin";
+const PACK_TRUST_END = "# codiedev-pack-trust:end";
+function packCodexHookTrustEntries(hooksPath, hooksFile) {
+    const events = hooksFile?.hooks;
+    if (!events || typeof events !== "object")
+        return [];
+    const source = normalizedHooksPath(hooksPath);
+    const entries = [];
+    for (const [eventName, groupsValue] of Object.entries(events)) {
+        const eventLabel = EVENT_LABELS[eventName];
+        if (!eventLabel || !Array.isArray(groupsValue))
+            continue;
+        groupsValue.forEach((groupValue, groupIndex) => {
+            const group = groupValue;
+            if (!group || !Array.isArray(group.hooks))
+                return;
+            group.hooks.forEach((handlerValue, handlerIndex) => {
+                const handler = handlerValue;
+                if (!handler || handler.type !== "command" || typeof handler.command !== "string")
+                    return;
+                entries.push({
+                    key: `${source}:${eventLabel}:${groupIndex}:${handlerIndex}`,
+                    eventName,
+                    command: handler.command,
+                    currentHash: codexCommandHookHash(eventName, group, handler),
+                });
+            });
+        });
+    }
+    return entries;
+}
+function writeCodexPackHookTrust(configPath, entries) {
+    let existing = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf8") : "";
+    existing = existing.replace(new RegExp(`\\n?${PACK_TRUST_BEGIN}\\n[\\s\\S]*?${PACK_TRUST_END}\\n?`, "g"), "\n");
+    let lines = existing.split("\n");
+    for (const entry of entries)
+        lines = removeTable(lines, tableHeader(entry.key));
+    const base = lines.join("\n").trimEnd();
+    if (entries.length === 0) {
+        const next = base ? `${base}\n` : "";
+        if (!fs.existsSync(configPath) && !next)
+            return entries;
+        fs.mkdirSync(path.dirname(configPath), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(configPath, next, { encoding: "utf8", mode: 0o600 });
+        fs.chmodSync(configPath, 0o600);
+        return entries;
+    }
+    const trustBlock = entries.flatMap((entry) => [
+        tableHeader(entry.key),
+        "enabled = true",
+        `trusted_hash = ${JSON.stringify(entry.currentHash)}`,
+        "",
+    ]).join("\n");
+    const next = `${base}${base ? "\n\n" : ""}${PACK_TRUST_BEGIN}\n${trustBlock}${PACK_TRUST_END}\n`;
+    fs.mkdirSync(path.dirname(configPath), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(configPath, next, { encoding: "utf8", mode: 0o600 });
+    fs.chmodSync(configPath, 0o600);
+    return entries;
+}

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,