@ouro.bot/cli 0.1.0-alpha.15 → 0.1.0-alpha.151

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/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,91 @@ function formatTerminalEntry(entry) {
     const level = entry.level.toUpperCase();
     return `${formatTerminalTime(entry.ts)} ${level} [${entry.component}] ${entry.message}${formatTerminalMeta(entry.meta)}`;
 }
+// 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) => process.stderr.write(chunk), 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/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-client.js

@@ -28,8 +28,10 @@ function resolveContentType(method, path) {
         : "application/json";
 }
 // Generic ADO API request. Returns response body as pretty-printed JSON string.
-async function adoRequest(token, method, org, path, body) {
+// `host` overrides the base URL for non-standard APIs (e.g. "vsapm.dev.azure.com", "vssps.dev.azure.com").
+async function adoRequest(token, method, org, path, body, host) {
     try {
+        const base = host ? `https://${host}/${org}` : `${ADO_BASE}/${org}`;
         (0, runtime_1.emitNervesEvent)({
             event: "client.request_start",
             component: "clients",
@@ -37,7 +39,7 @@ async function adoRequest(token, method, org, path, body) {
             meta: { client: "ado", method, org, path },
         });
         const fullPath = ensureApiVersion(path);
-        const url = `${ADO_BASE}/${org}${fullPath}`;
+        const url = `${base}${fullPath}`;
         const contentType = resolveContentType(method, path);
         const opts = {
             method,

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;
+    }
+}

package/dist/repertoire/coding/context-pack.js

@@ -0,0 +1,254 @@
+"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.prepareCodingContextPack = prepareCodingContextPack;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const active_work_1 = require("../../heart/active-work");
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+const skills_1 = require("../skills");
+const CONTEXT_FILENAMES = ["AGENTS.md", "CLAUDE.md"];
+function defaultRunCommand(command, args, cwd) {
+    const result = (0, child_process_1.spawnSync)(command, args, {
+        cwd,
+        encoding: "utf-8",
+    });
+    return {
+        status: result.status ?? 1,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.stderr : "",
+    };
+}
+function stableContextKey(request) {
+    const payload = JSON.stringify({
+        runner: request.runner,
+        workdir: request.workdir,
+        taskRef: request.taskRef ?? "",
+        parentAgent: request.parentAgent ?? "",
+        obligationId: request.obligationId ?? "",
+        originSession: request.originSession ?? null,
+    });
+    return crypto.createHash("sha1").update(payload).digest("hex").slice(0, 12);
+}
+function collectProjectContextFiles(workdir, deps) {
+    const files = [];
+    const seen = new Set();
+    let current = path.resolve(workdir);
+    const root = path.parse(current).root;
+    while (true) {
+        for (const filename of CONTEXT_FILENAMES) {
+            const candidate = path.join(current, filename);
+            if (!deps.existsSync(candidate) || seen.has(candidate))
+                continue;
+            try {
+                const content = deps.readFileSync(candidate, "utf-8").trim();
+                if (content.length > 0) {
+                    files.unshift({ path: candidate, content });
+                    seen.add(candidate);
+                }
+            }
+            catch {
+                // Best-effort loading only.
+            }
+        }
+        if (current === root)
+            break;
+        current = path.dirname(current);
+    }
+    return files;
+}
+function captureRepoSnapshot(workdir, runCommand) {
+    const repoRoot = runCommand("git", ["rev-parse", "--show-toplevel"], workdir);
+    if (repoRoot.status !== 0) {
+        return {
+            available: false,
+            repoRoot: null,
+            branch: null,
+            head: null,
+            statusLines: [],
+        };
+    }
+    const branch = runCommand("git", ["rev-parse", "--abbrev-ref", "HEAD"], workdir);
+    const head = runCommand("git", ["rev-parse", "--short", "HEAD"], workdir);
+    const status = runCommand("git", ["status", "--short"], workdir);
+    return {
+        available: true,
+        repoRoot: repoRoot.stdout.trim() || null,
+        branch: branch.status === 0 ? branch.stdout.trim() || null : null,
+        head: head.status === 0 ? head.stdout.trim() || null : null,
+        statusLines: status.status === 0
+            ? status.stdout.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean)
+            : [],
+    };
+}
+function formatContextFiles(files) {
+    if (files.length === 0)
+        return "(none found)";
+    return files.map((file) => `### ${file.path}\n${file.content}`).join("\n\n");
+}
+function formatSkills(skills) {
+    return skills.length > 0 ? skills.join(", ") : "(none found)";
+}
+function formatExistingSessions(sessions) {
+    if (sessions.length === 0)
+        return "activeSessions: none";
+    return sessions
+        .map((session) => {
+        return [
+            `- ${session.id}`,
+            `status=${session.status}`,
+            `lastActivityAt=${session.lastActivityAt}`,
+            session.taskRef ? `taskRef=${session.taskRef}` : null,
+            session.checkpoint ? `checkpoint=${session.checkpoint}` : null,
+            session.artifactPath ? `artifact=${session.artifactPath}` : null,
+        ].filter(Boolean).join(" ");
+    })
+        .join("\n");
+}
+function formatOrigin(request) {
+    if (!request.originSession)
+        return "originSession: none";
+    return `originSession: ${request.originSession.channel}/${request.originSession.key} (${request.originSession.friendId})`;
+}
+function buildScopeContent(request, contextFiles, skills, agentName) {
+    return [
+        "# Coding Session Scope",
+        "",
+        "## Request",
+        `runner: ${request.runner}`,
+        `taskRef: ${request.taskRef ?? "unassigned"}`,
+        `parentAgent: ${request.parentAgent ?? agentName}`,
+        `workdir: ${request.workdir}`,
+        formatOrigin(request),
+        `obligationId: ${request.obligationId ?? "none"}`,
+        "",
+        "## Prompt",
+        request.prompt,
+        "",
+        "## Session Contract",
+        "- This is a focused coding lane opened by the parent Ouro agent.",
+        "- Execute the concrete prompt in the supplied workdir directly.",
+        "- Do not switch into planning/doing workflows or approval gates unless the prompt explicitly asks for them.",
+        "- Treat the current prompt, scope file, and live world-state checkpoint in the state file as the authoritative briefing for this lane.",
+        "",
+        "## Project Context Files",
+        formatContextFiles(contextFiles),
+        "",
+        "## Available Bundle Skills",
+        formatSkills(skills),
+    ].join("\n");
+}
+function buildStateContent(request, contextKey, generatedAt, snapshot, existingSessions, agentName, activeWorkFrame) {
+    const gitSection = snapshot.available
+        ? [
+            `repoRoot: ${snapshot.repoRoot ?? "unknown"}`,
+            `branch: ${snapshot.branch ?? "unknown"}`,
+            `head: ${snapshot.head ?? "unknown"}`,
+            "status:",
+            snapshot.statusLines.length > 0 ? snapshot.statusLines.join("\n") : "(clean)",
+        ].join("\n")
+        : "git: unavailable";
+    return [
+        "# Coding Session State",
+        `generatedAt: ${generatedAt}`,
+        `contextKey: ${contextKey}`,
+        `agent: ${request.parentAgent ?? agentName}`,
+        formatOrigin(request),
+        `obligationId: ${request.obligationId ?? "none"}`,
+        "",
+        "## Workspace Snapshot",
+        gitSection,
+        ...(activeWorkFrame ? ["", (0, active_work_1.formatLiveWorldStateCheckpoint)(activeWorkFrame)] : []),
+        "",
+        "## Related Coding Sessions",
+        formatExistingSessions(existingSessions),
+    ].join("\n");
+}
+function relatedSessions(request, existingSessions) {
+    return existingSessions.filter((session) => {
+        return session.runner === request.runner
+            && session.workdir === request.workdir
+            && session.taskRef === request.taskRef;
+    });
+}
+function prepareCodingContextPack(input, deps = {}) {
+    const agentRoot = deps.agentRoot ?? (0, identity_1.getAgentRoot)();
+    const agentName = deps.agentName ?? (0, identity_1.getAgentName)();
+    const nowIso = deps.nowIso ?? (() => new Date().toISOString());
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const readFileSync = deps.readFileSync ?? fs.readFileSync;
+    const writeFileSync = deps.writeFileSync ?? fs.writeFileSync;
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const listAvailableSkills = deps.listSkills ?? skills_1.listSkills;
+    const runCommand = deps.runCommand ?? defaultRunCommand;
+    const contextKey = stableContextKey(input.request);
+    const contextDir = path.join(agentRoot, "state", "coding", "context");
+    const scopeFile = path.join(contextDir, `${contextKey}-scope.md`);
+    const stateFile = path.join(contextDir, `${contextKey}-state.md`);
+    const contextFiles = collectProjectContextFiles(input.request.workdir, { existsSync, readFileSync });
+    const skills = listAvailableSkills();
+    const existingSessions = relatedSessions(input.request, input.existingSessions ?? []);
+    const snapshot = captureRepoSnapshot(input.request.workdir, runCommand);
+    const generatedAt = nowIso();
+    const scopeContent = buildScopeContent(input.request, contextFiles, skills, agentName);
+    const stateContent = buildStateContent(input.request, contextKey, generatedAt, snapshot, existingSessions, agentName, input.activeWorkFrame);
+    mkdirSync(contextDir, { recursive: true });
+    writeFileSync(scopeFile, `${scopeContent}\n`, "utf-8");
+    writeFileSync(stateFile, `${stateContent}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.coding_context_pack_written",
+        message: "prepared coding session context pack",
+        meta: {
+            contextKey,
+            workdir: input.request.workdir,
+            taskRef: input.request.taskRef ?? null,
+            contextFiles: contextFiles.length,
+            skills: skills.length,
+            relatedSessions: existingSessions.length,
+            gitAvailable: snapshot.available,
+        },
+    });
+    return {
+        contextKey,
+        scopeFile,
+        stateFile,
+        scopeContent,
+        stateContent,
+    };
+}