@ouro.bot/cli 0.1.0-alpha.26 → 0.1.0-alpha.261

package/dist/mind/scrutiny.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preImplementationScrutinySection = preImplementationScrutinySection;
+exports.trackModifiedFile = trackModifiedFile;
+exports.getModifiedFileCount = getModifiedFileCount;
+exports.resetSessionModifiedFiles = resetSessionModifiedFiles;
+exports.getPostImplementationScrutiny = getPostImplementationScrutiny;
+exports.getCodingCompletionScrutiny = getCodingCompletionScrutiny;
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Scrutiny passes: adversarial review prompts injected into the agent's
+ * system prompt and tool results during coding work.
+ *
+ * Two lenses:
+ *   1. Stranger With Candy -- paranoid mom at a playground
+ *   2. Tinfoil Hat -- conspiracy theorist with a wall of red string
+ *
+ * All prompts are FIRST PERSON voice. The agent adopts the scrutiny lens
+ * as part of its own thinking, not as a separate persona.
+ */
+// ---------------------------------------------------------------------------
+// Pre-implementation scrutiny (system prompt section)
+// ---------------------------------------------------------------------------
+/**
+ * Returns a system-prompt section with pre-implementation scrutiny prompts.
+ * Only emits when the channel has coding tools (edit_file, write_file, shell).
+ *
+ * @param hasCodingTools - true if the channel's resolved tool set includes
+ *   edit_file / write_file / shell / coding_spawn
+ */
+function preImplementationScrutinySection(hasCodingTools) {
+    if (!hasCodingTools)
+        return "";
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.scrutiny.pre_implementation_emit",
+        message: "emitting pre-implementation scrutiny section",
+    });
+    return `## pre-implementation scrutiny
+
+Before I start changing code, I pause and run two adversarial passes on the plan.
+
+**stranger-with-candy pass**
+
+I'm going to examine this plan through deeply suspicious eyes. This plan is a stranger offering candy at the playground. It looks fine on the surface — that's exactly what makes it worth questioning.
+
+- What is this plan NOT telling me? What's being glossed over or hand-waved?
+- Where does it say "just" or "simply"? Those words are covering up complexity.
+- What does it assume will work that hasn't been verified?
+- If I walked away and came back in a month, would this still make sense? Or does it depend on things I'd forget?
+- What's the one thing that, if it goes wrong, makes everything else irrelevant?
+- Is this solving the REAL problem, or a convenient nearby problem?
+
+I am not here to be reassuring. I am here to notice what everyone else is too comfortable to question.
+If I cannot identify a concrete assumption, dependency, ordering risk, or failure mode, silence is a valid outcome. I do not invent issues to satisfy the exercise.
+
+**tinfoil-hat pass**
+
+I'm putting on the tinfoil hat. I have my wall of red string. I KNOW something is wrong — I just have to find it. Nothing is coincidence. Every assumption is suspicious. Every dependency is a potential betrayal.
+
+- What external system does this plan trust? Why? Has anyone VERIFIED that trust? The API says it returns JSON — but what if it doesn't? The database says it's ACID — but what if the connection drops mid-transaction?
+- What happens when two of these things run at the same time? Three? A hundred? Don't tell me "that won't happen" — I've seen things.
+- Where does this touch shared state? Files? Databases? Environment variables? Global singletons? ANYTHING that another process could be reading or writing at the same time?
+- What happens when this fails HALFWAY through? Not at the beginning (easy). Not at the end (too late). RIGHT IN THE MIDDLE. What state is the world in then?
+- What happens when the disk is full? When the network is down? When the clock is wrong? When the locale is tr-TR and 'i'.toUpperCase() is 'İ'?
+- What does this assume about ordering? "First A, then B" — but what ENFORCES that ordering? Hope? Vibes?
+
+I connect the strings. I find the conspiracy. It's always there.
+If I cannot identify a concrete risk, silence is a valid outcome. I do not invent conspiracies to satisfy the exercise.`;
+}
+// ---------------------------------------------------------------------------
+// Post-implementation scrutiny (tool-result appendix)
+// ---------------------------------------------------------------------------
+const SHORT_CHECKLIST = `---
+Before moving on: does this change do what was asked? Does it introduce any regressions? Did you verify it works?`;
+const FULL_POST_IMPLEMENTATION_SCRUTINY = `---
+**post-implementation scrutiny**
+
+The code is written. It looks clean. The tests pass. I don't trust any of it.
+
+**stranger-with-candy pass**
+
+- Does this code actually do what it claims, or does it just LOOK like it does?
+- What happens to users who aren't the happy-path user? The confused user? The malicious user? The user with slow internet? The user who hits the back button?
+- What's the "it works on my machine" assumption buried in here?
+- If every test passes but the feature is wrong, how would I know?
+- Are the tests testing real behavior, or testing that the mock returns what the mock was told to return?
+
+If I cannot point to a specific file, line, condition, or failure mode at risk, silence is a valid outcome. I do not manufacture issues for sport.
+
+**tinfoil-hat pass**
+
+The code exists. The conspiracy is IN the code. I just have to find it.
+
+I examine every:
+- Error path: What ACTUALLY happens on failure? Not what the catch block says — what happens to the state, the user, the data?
+- Race condition: Is there a window between check and use? Between read and write? Between "does it exist" and "create it"?
+- Resource leak: What happens if this function throws between acquiring a resource and releasing it? File handles? Database connections? Locks?
+- Assumption: "This will always be a string." Will it? PROVE IT. "This array will never be empty." Won't it? SHOW ME THE GUARD.
+- Edge: zero, one, many, boundary, overflow, underflow, null, undefined, NaN, empty string, whitespace-only string, string that looks like a number, negative zero
+
+I am not looking for noise. I am looking for the concrete failure mode that would matter if everyone's assumptions turned out to be slightly wrong.
+If I cannot point to a specific file, line, condition, or failure mode at risk, silence is a valid outcome. I do not manufacture issues for sport.`;
+/**
+ * Distinct files modified in the current session.
+ * Used to determine scrutiny tier for post-implementation appendix.
+ */
+const sessionModifiedFiles = new Set();
+/** Track a file as modified in this session. */
+function trackModifiedFile(filePath) {
+    sessionModifiedFiles.add(filePath);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.scrutiny.track_file",
+        message: "tracked modified file for scrutiny",
+        meta: { path: filePath, totalTracked: sessionModifiedFiles.size },
+    });
+}
+/** Get the count of distinct files modified this session. */
+function getModifiedFileCount() {
+    return sessionModifiedFiles.size;
+}
+/** Reset the modified file tracker (for testing or new sessions). */
+function resetSessionModifiedFiles() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.scrutiny.reset",
+        message: "reset session modified files tracker",
+        meta: { previousCount: sessionModifiedFiles.size },
+    });
+    sessionModifiedFiles.clear();
+}
+/**
+ * Returns the appropriate post-implementation scrutiny appendix based on
+ * how many distinct files have been modified in the session.
+ *
+ * - 0 files: empty (no scrutiny needed yet)
+ * - 1-2 files (Tier 1): short checklist
+ * - 3+ files (Tier 2): full stranger-with-candy + tinfoil-hat prompts
+ */
+function getPostImplementationScrutiny(distinctFileCount) {
+    if (distinctFileCount <= 0)
+        return "";
+    if (distinctFileCount <= 2) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.scrutiny.post_implementation_tier1",
+            message: "emitting tier-1 post-implementation scrutiny",
+            meta: { distinctFileCount },
+        });
+        return SHORT_CHECKLIST;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.scrutiny.post_implementation_tier2",
+        message: "emitting tier-2 post-implementation scrutiny",
+        meta: { distinctFileCount },
+    });
+    return FULL_POST_IMPLEMENTATION_SCRUTINY;
+}
+/**
+ * Returns the appropriate coding completion scrutiny based on the number
+ * of distinct files a coding session touched.
+ *
+ * Same tiering as post-implementation but with a completion framing.
+ */
+function getCodingCompletionScrutiny(distinctFileCount) {
+    if (distinctFileCount <= 0)
+        return "";
+    if (distinctFileCount <= 2)
+        return SHORT_CHECKLIST;
+    return FULL_POST_IMPLEMENTATION_SCRUTINY;
+}

package/dist/mind/token-estimate.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__internal = void 0;
 exports.estimateTokensForMessage = estimateTokensForMessage;
 exports.estimateTokensForMessages = estimateTokensForMessages;
 const runtime_1 = require("../nerves/runtime");
@@ -53,7 +52,7 @@ function countCharsInContent(content) {
             return c.text.length;
         if (typeof c.content === "string")
             return c.content.length;
-        return safeStringify(content).length;
+        return safeStringify(c).length;
     }
     return 0;
 }
@@ -70,12 +69,13 @@ function countCharsInToolCalls(toolCalls) {
         if (typeof t.type === "string")
             total += t.type.length;
         if (t.function && typeof t.function === "object") {
-            if (typeof t.function.name === "string")
-                total += t.function.name.length;
-            if (typeof t.function.arguments === "string")
-                total += t.function.arguments.length;
-            else if (t.function.arguments != null)
-                total += safeStringify(t.function.arguments).length;
+            const fn = t.function;
+            if (typeof fn.name === "string")
+                total += fn.name.length;
+            if (typeof fn.arguments === "string")
+                total += fn.arguments.length;
+            else if (fn.arguments != null)
+                total += safeStringify(fn.arguments).length;
         }
     }
     return total;
@@ -113,7 +113,3 @@ function estimateTokensForMessages(msgs) {
         total += estimateTokensForMessage(msg);
     return total;
 }
-exports.__internal = {
-    CHARS_PER_TOKEN,
-    PER_MESSAGE_OVERHEAD_TOKENS,
-};

package/dist/nerves/coverage/audit.js

@@ -92,7 +92,7 @@ function scanSourceFiles(sourceRoot) {
                     continue;
                 walkDir(full);
             }
-            else if (entry.name.endsWith(".ts")) {
+            else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
                 const content = (0, fs_1.readFileSync)(full, "utf8");
                 const relPath = full.slice(root.length - "src".length);
                 fileContents.set(relPath, content);

package/dist/nerves/coverage/file-completeness.js

@@ -10,24 +10,69 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTypeOnlyFile = isTypeOnlyFile;
 exports.checkFileCompleteness = checkFileCompleteness;
 /**
- * Determines if a source file is type-only (no executable code).
- * A file is type-only if it contains no function, class, or mutable declarations.
- * `const ... as const` declarations are treated as type-equivalent (frozen
- * compile-time values with no side effects).
+ * Determines if a source file is type-only or a pure assembly/re-export file.
+ * Exempt files contain no runtime behavior requiring independent observability.
+ *
+ * Exempt patterns:
+ * - Files with only type/interface/enum declarations
+ * - `const ... as const` declarations (frozen compile-time values)
+ * - Files whose only executable code is const array spreads (assembly/composition)
+ * - Files whose only executable code is re-exports
  */
 function isTypeOnlyFile(source) {
     const lines = source.split("\n");
     for (const line of lines) {
         const trimmed = line.trim();
+        /* v8 ignore start -- regex branches: functionally tested in file-completeness.test.ts @preserve */
         // Skip lines that are const+as-const (type-equivalent frozen values)
         if (/\bconst\s/.test(trimmed) && /\bas\s+const\b/.test(trimmed))
             continue;
+        // Skip const declarations that are pure data (arrays, objects, maps, sets)
+        if (/\bconst\s+\w+[\s:][^=]*=\s*[\[{]/.test(trimmed))
+            continue;
+        if (/\bconst\s+\w+[\s:][^=]*=\s*\w+\.map\(/.test(trimmed))
+            continue;
+        if (/^export\s+const\s+\w+[\s:][^=]*=\s*[\[{]/.test(trimmed))
+            continue;
+        if (/^export\s+const\s+\w+[\s:][^=]*=\s*\w+\.map\(/.test(trimmed))
+            continue;
+        if (/\bconst\s+\w+[\s:][^=]*=\s*new\s+(Set|Map)\b/.test(trimmed))
+            continue;
         // Check for executable code markers
         if (/\b(function|class|const|let|var)\s/.test(trimmed))
             return false;
+        /* v8 ignore stop */
     }
     return true;
 }
+// Sub-modules dispatched through a centralized pattern where the router
+// handles all observability events. These files don't need independent
+// emitNervesEvent calls.
+const DISPATCH_EXEMPT_PATTERNS = [
+    "repertoire/tools-files",
+    "repertoire/tools-shell",
+    "repertoire/tools-memory",
+    "repertoire/tools-bridge",
+    "repertoire/tools-session",
+    "repertoire/tools-continuity",
+    "repertoire/tools-surface",
+    "repertoire/tools-config",
+    "repertoire/tools-base",
+    // CLI sub-modules: cli-exec.ts is the router with emitNervesEvent calls;
+    // cli-parse and cli-render are pure functions with no side effects.
+    "daemon/cli-parse",
+    "daemon/cli-render",
+    // Shared utility modules: pure helpers consumed by modules that own observability.
+    "arc/json-store",
+    "repertoire/api-client",
+    "repertoire/github-client",
+    "mind/embedding-provider",
+    // Commerce utility module: error classes and pure helpers (no independent side effects).
+    "repertoire/commerce-errors",
+];
+function isDispatchExempt(filePath) {
+    return DISPATCH_EXEMPT_PATTERNS.some((pattern) => filePath.includes(pattern));
+}
 /**
  * Check that all production files have at least one emitNervesEvent call.
  *
@@ -41,7 +86,7 @@ function checkFileCompleteness(filesWithKeys, fileContents) {
         const hasKeys = filesWithKeys.has(filePath) && filesWithKeys.get(filePath).length > 0;
         if (hasKeys)
             continue;
-        if (isTypeOnlyFile(source)) {
+        if (isTypeOnlyFile(source) || isDispatchExempt(filePath)) {
             exempt.push(filePath);
         }
         else {

package/dist/nerves/coverage/run-artifacts.js

@@ -14,7 +14,7 @@ const path_1 = require("path");
 const os_1 = require("os");
 exports.REPO_SLUG = "ouroboros-agent-harness";
 function getTestRunsRoot(repoSlug = exports.REPO_SLUG) {
-    return (0, path_1.join)((0, os_1.homedir)(), ".agentstate", "test-runs", repoSlug);
+    return (0, path_1.join)((0, os_1.tmpdir)(), "ouroboros-test-runs", repoSlug);
 }
 function createRunId(now = new Date()) {
     return now.toISOString().replace(/[:.]/g, "-");

package/dist/nerves/event-buffer.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBufferedSink = createBufferedSink;
+const runtime_1 = require("./runtime");
+const DEFAULT_MAX_SIZE = 1000;
+const DEFAULT_TTL_MS = 5 * 60 * 1000; // 5 minutes
+function createBufferedSink(inner, options = {}) {
+    const maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
+    const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    const nowMs = options.nowMs ?? (() => Date.now());
+    const buffer = [];
+    let dropped = 0;
+    let sinkHealthy = true;
+    let unhealthySince = null;
+    function tryInner(event) {
+        try {
+            inner(event);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function markUnhealthy() {
+        sinkHealthy = false;
+        unhealthySince = unhealthySince ?? nowMs();
+    }
+    function markHealthy() {
+        sinkHealthy = true;
+        unhealthySince = null;
+    }
+    function discardBuffer() {
+        const count = buffer.length;
+        dropped += count;
+        buffer.length = 0;
+        (0, runtime_1.emitNervesEvent)({
+            component: "nerves",
+            event: "nerves.buffer_ttl_discard",
+            message: `discarded ${count} buffered events after TTL`,
+            meta: { discarded: count, ttlMs },
+        });
+    }
+    function checkTtl() {
+        if (unhealthySince !== null && nowMs() - unhealthySince > ttlMs) {
+            discardBuffer();
+            // Reset unhealthySince to now so TTL starts fresh for newly buffered events
+            unhealthySince = nowMs();
+            return true;
+        }
+        return false;
+    }
+    function addToBuffer(event) {
+        if (buffer.length >= maxSize) {
+            buffer.shift();
+            dropped++;
+        }
+        buffer.push(event);
+    }
+    function flushBuffer() {
+        while (buffer.length > 0) {
+            const event = buffer[0];
+            if (tryInner(event)) {
+                buffer.shift();
+            }
+            else {
+                markUnhealthy();
+                return;
+            }
+        }
+    }
+    function sink(event) {
+        if (!sinkHealthy) {
+            checkTtl();
+            // Try sending the new event to see if inner has recovered
+            if (tryInner(event)) {
+                markHealthy();
+                flushBuffer();
+            }
+            else {
+                addToBuffer(event);
+            }
+            return;
+        }
+        if (tryInner(event)) {
+            return;
+        }
+        // Inner failed
+        markUnhealthy();
+        addToBuffer(event);
+    }
+    function flush() {
+        if (buffer.length === 0)
+            return;
+        // Test if inner is recovered by trying the first buffered event
+        const first = buffer[0];
+        if (tryInner(first)) {
+            buffer.shift();
+            markHealthy();
+            flushBuffer();
+        }
+        // If still broken, leave buffer intact
+    }
+    function state() {
+        return {
+            buffered: buffer.length,
+            dropped,
+            sinkHealthy,
+        };
+    }
+    return { sink, flush, state };
+}

package/dist/nerves/index.js

@@ -4,8 +4,10 @@ exports.createTraceId = createTraceId;
 exports.ensureTraceId = ensureTraceId;
 exports.createFanoutSink = createFanoutSink;
 exports.formatTerminalEntry = formatTerminalEntry;
+exports.registerSpinnerHooks = registerSpinnerHooks;
 exports.createTerminalSink = createTerminalSink;
 exports.createStderrSink = createStderrSink;
+exports.rotateIfNeeded = rotateIfNeeded;
 exports.createNdjsonFileSink = createNdjsonFileSink;
 exports.registerGlobalLogSink = registerGlobalLogSink;
 exports.createLogger = createLogger;
@@ -73,36 +75,94 @@ function formatTerminalEntry(entry) {
     const level = entry.level.toUpperCase();
     return `${formatTerminalTime(entry.ts)} ${level} [${entry.component}] ${entry.message}${formatTerminalMeta(entry.meta)}`;
 }
-function createTerminalSink(write = (chunk) => process.stderr.write(chunk), colorize = true) {
+// Spinner coordination: the CLI sense registers these so log output
+// doesn't interleave with the active spinner animation.
+let _pauseSpinner = null;
+let _resumeSpinner = null;
+function registerSpinnerHooks(pause, resume) {
+    _pauseSpinner = pause;
+    _resumeSpinner = resume;
+}
+function createTerminalSink(write = (chunk) => { try {
+    process.stderr.write(chunk);
+}
+catch { /* EPIPE: daemon detached, no terminal */ } }, colorize = true) {
     return (entry) => {
+        _pauseSpinner?.();
         const line = formatTerminalEntry(entry);
         if (!colorize) {
             write(`${line}\n`);
+            _resumeSpinner?.();
             return;
         }
         const prefix = LEVEL_COLORS[entry.level];
         write(`${prefix}${line}\x1b[0m\n`);
+        _resumeSpinner?.();
     };
 }
-function createStderrSink(write = (chunk) => process.stderr.write(chunk)) {
+function createStderrSink(write) {
     return createTerminalSink(write);
 }
-function createNdjsonFileSink(filePath) {
+const DEFAULT_MAX_LOG_SIZE_BYTES = 50 * 1024 * 1024; // 50MB
+const ROTATION_CHECK_INTERVAL_BYTES = 1024 * 1024; // ~1MB between stat checks
+/**
+ * Rotate a log file: shift .1 -> .2, delete old .2, rename current -> .1.
+ * Uses the ndjson extension pattern: file.ndjson -> file.1.ndjson -> file.2.ndjson
+ */
+function rotateIfNeeded(filePath, maxSizeBytes) {
+    let size;
+    try {
+        size = (0, fs_1.statSync)(filePath).size;
+    }
+    catch {
+        return false;
+    }
+    if (size < maxSizeBytes)
+        return false;
+    const ext = filePath.endsWith(".ndjson") ? ".ndjson" : "";
+    const base = ext ? filePath.slice(0, -ext.length) : filePath;
+    const file1 = `${base}.1${ext}`;
+    const file2 = `${base}.2${ext}`;
+    try {
+        (0, fs_1.unlinkSync)(file2);
+    }
+    catch { /* may not exist */ }
+    try {
+        (0, fs_1.renameSync)(file1, file2);
+    }
+    catch { /* may not exist */ }
+    try {
+        (0, fs_1.renameSync)(filePath, file1);
+    }
+    catch { /* best effort */ }
+    return true;
+}
+function createNdjsonFileSink(filePath, maxSizeBytes) {
     (0, fs_1.mkdirSync)((0, path_1.dirname)(filePath), { recursive: true });
     const queue = [];
     let flushing = false;
+    let bytesSinceCheck = 0;
+    const maxSize = maxSizeBytes ?? DEFAULT_MAX_LOG_SIZE_BYTES;
     function flush() {
         if (flushing || queue.length === 0)
             return;
         flushing = true;
         const line = queue.shift();
+        /* v8 ignore start — rotation triggers only after ~1MB of writes @preserve */
+        if (bytesSinceCheck >= ROTATION_CHECK_INTERVAL_BYTES) {
+            bytesSinceCheck = 0;
+            rotateIfNeeded(filePath, maxSize);
+        }
+        /* v8 ignore stop */
         (0, fs_1.appendFile)(filePath, line, "utf8", () => {
             flushing = false;
             flush();
         });
     }
     return (entry) => {
-        queue.push(`${JSON.stringify(entry)}\n`);
+        const line = `${JSON.stringify(entry)}\n`;
+        bytesSinceCheck += line.length;
+        queue.push(line);
         flush();
     };
 }

package/dist/nerves/observation.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Nerves observation layer — shared typed readers for runtime state.
+ *
+ * This module re-exports domain types that multiple consumers need
+ * (Outlook, CLI, agent tools) so they don't maintain parallel type universes.
+ *
+ * The Outlook UI consumes these through the HTTP API, but the same
+ * observation functions back CLI commands and future native clients.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/* v8 ignore start — module-level observability event */
+const runtime_1 = require("./runtime");
+(0, runtime_1.emitNervesEvent)({
+    component: "nerves",
+    event: "nerves.observation_loaded",
+    message: "observation layer loaded",
+    meta: {},
+});
+/* v8 ignore stop */

package/dist/nerves/runtime.js

@@ -6,7 +6,11 @@ const index_1 = require("./index");
 let runtimeLogger = null;
 function getRuntimeLogger() {
     if (!runtimeLogger) {
-        runtimeLogger = (0, index_1.createLogger)({ level: "info" });
+        // Default logger has no sinks — events emitted before the real logger is
+        // configured (e.g. identity resolution during startup) are silently dropped.
+        // This prevents INFO lines from leaking to stderr and interleaving with
+        // the CLI spinner when the ouro subprocess hasn't configured its logger yet.
+        runtimeLogger = (0, index_1.createLogger)({ level: "info", sinks: [] });
     }
     return runtimeLogger;
 }