@ouro.bot/cli 0.1.0-alpha.16 → 0.1.0-alpha.160

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/cli-logging.js

@@ -5,20 +5,33 @@ const config_1 = require("../heart/config");
 const nerves_1 = require("../nerves");
 const runtime_1 = require("./runtime");
 const runtime_2 = require("./runtime");
+const LEVEL_PRIORITY = { debug: 10, info: 20, warn: 30, error: 40 };
+/** Wrap a sink so it only receives events at or above the given level. */
+/* v8 ignore start -- internal filter plumbing, exercised via integration @preserve */
+function filterSink(sink, minLevel) {
+    const minPriority = LEVEL_PRIORITY[minLevel] ?? 0;
+    return (entry) => {
+        if ((LEVEL_PRIORITY[entry.level] ?? 0) >= minPriority)
+            sink(entry);
+    };
+}
 function resolveCliSinks(sinks) {
     const requested = sinks && sinks.length > 0 ? sinks : ["terminal", "ndjson"];
     return [...new Set(requested)];
 }
 function configureCliRuntimeLogger(_friendId, options = {}) {
     const sinkKinds = resolveCliSinks(options.sinks);
+    const level = options.level ?? "info";
     const sinks = sinkKinds.map((sinkKind) => {
         if (sinkKind === "terminal") {
-            return (0, nerves_1.createTerminalSink)();
+            // Terminal only shows warnings and errors — INFO is too noisy
+            // for an interactive session. Full detail goes to the ndjson file.
+            return filterSink((0, nerves_1.createTerminalSink)(), "warn");
         }
         return (0, nerves_1.createNdjsonFileSink)((0, config_1.logPath)("cli", "runtime"));
     });
     const logger = (0, nerves_1.createLogger)({
-        level: options.level ?? "info",
+        level,
         sinks,
     });
     (0, runtime_2.setRuntimeLogger)(logger);

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)) {
     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;
 }

package/dist/repertoire/ado-semantic.js

@@ -279,6 +279,7 @@ exports.adoSemanticToolDefinitions = [
             return formatForChannel(items, ctx, organization, project);
         },
         integration: "ado",
+        summaryKeys: ["organization", "project"],
     },
     // -- ado_create_epic --
     {
@@ -318,6 +319,7 @@ exports.adoSemanticToolDefinitions = [
         },
         integration: "ado",
         confirmationRequired: true,
+        summaryKeys: ["organization", "project", "title"],
     },
     // -- ado_create_issue --
     {
@@ -359,6 +361,7 @@ exports.adoSemanticToolDefinitions = [
         },
         integration: "ado",
         confirmationRequired: true,
+        summaryKeys: ["organization", "project", "title"],
     },
     // -- ado_move_items --
     {
@@ -413,6 +416,7 @@ exports.adoSemanticToolDefinitions = [
         },
         integration: "ado",
         confirmationRequired: true,
+        summaryKeys: ["organization", "project", "workItemIds"],
     },
     // -- ado_restructure_backlog --
     {
@@ -471,6 +475,7 @@ exports.adoSemanticToolDefinitions = [
         },
         integration: "ado",
         confirmationRequired: true,
+        summaryKeys: ["organization", "project"],
     },
     // -- ado_validate_structure --
     {
@@ -672,6 +677,7 @@ exports.adoSemanticToolDefinitions = [
         },
         integration: "ado",
         confirmationRequired: true,
+        summaryKeys: ["organization", "project"],
     },
     // -- ado_detect_orphans --
     {

package/dist/repertoire/coding/codex-jsonl.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Codex JSONL event parser.
+ * Parses typed events from Codex --json output:
+ * thread.started, turn.started, turn.completed, item.completed.
+ * Maps events to coding session status transitions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCodexJsonlEvent = parseCodexJsonlEvent;
+const runtime_1 = require("../../nerves/runtime");
+const KNOWN_TYPES = new Set(["thread.started", "turn.started", "turn.completed", "item.completed"]);
+/**
+ * Parse a single JSONL line from Codex --json output.
+ * Returns null for invalid JSON, empty strings, or unknown event types.
+ */
+function parseCodexJsonlEvent(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.codex_jsonl_parse_error",
+            message: "failed to parse codex JSONL line",
+            meta: { line: trimmed.slice(0, 100) },
+        });
+        return null;
+    }
+    const type = parsed.type;
+    if (!type || !KNOWN_TYPES.has(type))
+        return null;
+    const event = {
+        type: type,
+        threadId: typeof parsed.thread_id === "string" ? parsed.thread_id : undefined,
+        turnId: typeof parsed.turn_id === "string" ? parsed.turn_id : undefined,
+        item: typeof parsed.item === "object" && parsed.item !== null ? parsed.item : undefined,
+        raw: parsed,
+        statusHint: mapStatusHint(type),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.codex_jsonl_event",
+        message: "parsed codex JSONL event",
+        meta: { type, threadId: event.threadId ?? null },
+    });
+    return event;
+}
+function mapStatusHint(type) {
+    switch (type) {
+        case "thread.started":
+        case "turn.started":
+            return "running";
+        case "turn.completed":
+        case "item.completed":
+            return null; // No automatic status change for completion events
+        /* v8 ignore next -- defensive default for unknown event types */
+        default:
+            return null;
+    }
+}