@ouro.bot/cli 0.1.0-alpha.281 → 0.1.0-alpha.283

package/changelog.json

@@ -1,17 +1,32 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.283",
+      "changes": [
+        "chore(housekeeping): clean up ~3600 leaked test secret dirs in `~/.agentsecrets/`. The auth CLI test suite was creating ephemeral agent secret dirs (auth-local-*, auth-store-*, auth-no-switch-*, etc.) without cleaning them up, accreting over weeks into thousands of orphaned entries. Also purged three non-test orphans (`testagent`, `model-reviews`, `config-model-facing-*`) that were leftovers from manual probe sessions. Only `slugger` and `ouroboros` — the two real agents on this machine — remain.",
+        "chore(housekeeping): remove orphan bundle stubs from `~/AgentBundles/` (default.ouro, thoughts-test-*, an empty `friends/` dir, and a .DS_Store). These were skeletal test leftovers with no real identity — the daemon was already filtering them out of `listEnabledBundleAgents`, so deletion is invisible to the runtime but stops confusing anyone inspecting the bundles directory.",
+        "chore(tests): replace the `outlookServer.stop` v8 ignore band-aid in `daemon.ts` with a proper test. `OuroDaemonOptions` gains an `outlookServerFactory` seam that lets tests inject an in-memory stub handle instead of binding port 6876 (which a running production daemon holds on dev machines, causing EADDRINUSE flakes). New `daemon-outlook-lifecycle.test.ts` covers the happy path (factory runs, stop is called), the error path (factory throws, daemon logs warn and keeps going, stop is a no-op), and the double-start guard. The default production factory path (`createDefaultOutlookServer` — wires the real `startOutlookHttpServer` with bundlesRoot + view builders) is v8-ignored because it only runs under real bind on port 6876; `startOutlookHttpServer` itself has full coverage in `outlook-http.test.ts`. Removed the redundant `if (!this.outlookServer)` wrapper in `startInner()` that was guarding against an unreachable retry scenario. `daemon.ts` now hits 100% statements / branches / functions / lines with zero port binding in the test suite.",
+        "chore(ci): tighten the wrapper publish-sync check timing. The version-bump check and wrapper-publish-sync check now run BEFORE the ~2+ minute coverage gate, not after. Previously, a contributor would wait for the full test suite to pass only to then see a 'version already published' error. Now the fast checks surface in under a minute, and coverage only runs once version/wrapper gates have cleared. Same checks, same logic — just reordered steps in `.github/workflows/coverage.yml`."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.282",
+      "changes": [
+        "feat(cli): crash-resilient sessions \u2014 saves after each tool result, repairs orphaned tool calls on resume."
+      ]
+    },
     {
       "version": "0.1.0-alpha.281",
       "changes": [
-        "feat(bundle): new `src/heart/bundle-state.ts` module exports `detectBundleState(agentRoot)` which returns a structured `BundleStateIssue[]` describing git-level problems the agent can remediate. Enum cases: `not_a_git_repo`, `no_remote_configured`, `first_commit_never_happened`, `pending_sync_exists`. Detection never throws — every git call is wrapped in try/catch so a broken bundle degrades to a clear signal rather than crashing the turn pipeline. Also exports `renderBundleStateHint(issues)` which produces first-person remediation guidance (per the memory rule) that tells the agent to call `bundle_check_sync_status` and the `bundle_*` tools shipping in a follow-up PR.",
-        "feat(bundle): `StartOfTurnPacket` gains an optional `bundleState?: BundleStateIssue[]` field, populated by the senses pipeline in `handleInboundTurn` at packet assembly time. Renders via a new `case \"bundleState\":` branch in `formatSections` with the `**Bundle:**` prefix, at the same priority tier as the legacy `syncFailure` free-form string (priority 7, truncated last). The two signals coexist during the transition — `syncFailure` is still emitted by sync.ts for humans, while `bundleState` is the structured form the agent pattern-matches on. Deferred to follow-up: `pending-sync.json` schema extension with `classification` / `conflictFiles` so sync.ts can distinguish push-rejected from pull-rebase-conflict."
+        "feat(bundle): new `src/heart/bundle-state.ts` module exports `detectBundleState(agentRoot)` which returns a structured `BundleStateIssue[]` describing git-level problems the agent can remediate. Enum cases: `not_a_git_repo`, `no_remote_configured`, `first_commit_never_happened`, `pending_sync_exists`. Detection never throws \u2014 every git call is wrapped in try/catch so a broken bundle degrades to a clear signal rather than crashing the turn pipeline. Also exports `renderBundleStateHint(issues)` which produces first-person remediation guidance (per the memory rule) that tells the agent to call `bundle_check_sync_status` and the `bundle_*` tools shipping in a follow-up PR.",
+        "feat(bundle): `StartOfTurnPacket` gains an optional `bundleState?: BundleStateIssue[]` field, populated by the senses pipeline in `handleInboundTurn` at packet assembly time. Renders via a new `case \"bundleState\":` branch in `formatSections` with the `**Bundle:**` prefix, at the same priority tier as the legacy `syncFailure` free-form string (priority 7, truncated last). The two signals coexist during the transition \u2014 `syncFailure` is still emitted by sync.ts for humans, while `bundleState` is the structured form the agent pattern-matches on. Deferred to follow-up: `pending-sync.json` schema extension with `classification` / `conflictFiles` so sync.ts can distinguish push-rejected from pull-rebase-conflict."
       ]
     },
     {
       "version": "0.1.0-alpha.280",
       "changes": [
-        "chore(tests): prod-path isolation ratchet + tmpBundle leak guard + no-rm-rf contract. Extends `src/__tests__/heart/daemon/test-isolation.contract.test.ts` with three new rules and adds a runtime leak guard. (1) Three new prod-path block rules mirror the existing ~/AgentBundles check: no test file may construct a write path under `~/.ouro-cli`, `~/.agentsecrets`, or `~/.claude` without mocking fs. Each rule has its own empty-seeded ratchet allowlist (except `.ouro-cli` and `.agentsecrets` which are seeded with the pre-existing offenders that this rule newly catches — follow-up PRs can convert those to mocked-fs and ratchet down). The path-scan loop is factored into a shared `runProdPathCheck` helper. (2) New Directive-A contract rule: agent-callable production code under `src/` (excluding `src/__tests__/`) must not call `fs.rmSync(..., { recursive: true })` or shell out to `rm -rf` / `rm -fr` / `rm --recursive --force`. The rule is about making deletion auditable and interruptible: an agent should enumerate the files it wants to delete instead of recursively blasting a directory. Four legitimate infrastructure callsites are on `RM_RECURSIVE_ALLOWLIST` with explicit justifications: specialist-tools.ts (adoption rollback), ouro-version-manager.ts (CLI version pruning), ouro-uti.ts (macOS icon pipeline), cli-defaults.ts (self-setup temp dir). Three files that are themselves the rm-rf enforcement layer (guardrails.ts, shell-sessions.ts, prompt.ts) are in `RM_RULE_ENFORCEMENT_FILES` and skipped by the scan since they contain the literal \"rm -rf\" only as regex patterns or prompt strings designed to BLOCK the call. (3) `createTmpBundle` in `src/__tests__/test-helpers/tmpdir-bundle.ts` now tracks live handles in a module-level `_liveHandles: Set<TmpBundleHandle>`. `cleanup()` removes the handle from the set; a new `__getLiveTmpBundleHandles()` export returns a readonly view. (4) `src/__tests__/nerves/global-capture.ts` adds a global vitest `afterEach` leak guard that iterates `__getLiveTmpBundleHandles` and calls `cleanup()` on any remaining handles, logging a `console.warn` naming the test that leaked them. Runs AFTER the pairing guard from alpha.276 so pairing failures surface first. Both guards co-exist cleanly."
+        "chore(tests): prod-path isolation ratchet + tmpBundle leak guard + no-rm-rf contract. Extends `src/__tests__/heart/daemon/test-isolation.contract.test.ts` with three new rules and adds a runtime leak guard. (1) Three new prod-path block rules mirror the existing ~/AgentBundles check: no test file may construct a write path under `~/.ouro-cli`, `~/.agentsecrets`, or `~/.claude` without mocking fs. Each rule has its own empty-seeded ratchet allowlist (except `.ouro-cli` and `.agentsecrets` which are seeded with the pre-existing offenders that this rule newly catches \u2014 follow-up PRs can convert those to mocked-fs and ratchet down). The path-scan loop is factored into a shared `runProdPathCheck` helper. (2) New Directive-A contract rule: agent-callable production code under `src/` (excluding `src/__tests__/`) must not call `fs.rmSync(..., { recursive: true })` or shell out to `rm -rf` / `rm -fr` / `rm --recursive --force`. The rule is about making deletion auditable and interruptible: an agent should enumerate the files it wants to delete instead of recursively blasting a directory. Four legitimate infrastructure callsites are on `RM_RECURSIVE_ALLOWLIST` with explicit justifications: specialist-tools.ts (adoption rollback), ouro-version-manager.ts (CLI version pruning), ouro-uti.ts (macOS icon pipeline), cli-defaults.ts (self-setup temp dir). Three files that are themselves the rm-rf enforcement layer (guardrails.ts, shell-sessions.ts, prompt.ts) are in `RM_RULE_ENFORCEMENT_FILES` and skipped by the scan since they contain the literal \"rm -rf\" only as regex patterns or prompt strings designed to BLOCK the call. (3) `createTmpBundle` in `src/__tests__/test-helpers/tmpdir-bundle.ts` now tracks live handles in a module-level `_liveHandles: Set<TmpBundleHandle>`. `cleanup()` removes the handle from the set; a new `__getLiveTmpBundleHandles()` export returns a readonly view. (4) `src/__tests__/nerves/global-capture.ts` adds a global vitest `afterEach` leak guard that iterates `__getLiveTmpBundleHandles` and calls `cleanup()` on any remaining handles, logging a `console.warn` naming the test that leaked them. Runs AFTER the pairing guard from alpha.276 so pairing failures surface first. Both guards co-exist cleanly."
       ]
     },
     {

package/dist/heart/core.js

@@ -911,6 +911,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     callbacks.onToolEnd(tc.name, (0, tools_1.buildToolResultSummary)(tc.name, args, toolResult, success), success);
                     messages.push({ role: "tool", tool_call_id: tc.id, content: toolResult });
                     providerRuntime.appendToolOutput(tc.id, toolResult);
+                    callbacks.onToolResult?.(messages);
                 }
             }
         }

package/dist/heart/daemon/daemon.js

@@ -353,6 +353,7 @@ class OuroDaemon {
     mode;
     server = null;
     outlookServer = null;
+    outlookServerFactory;
     constructor(options) {
         this.socketPath = options.socketPath;
         this.processManager = options.processManager;
@@ -362,7 +363,42 @@ class OuroDaemon {
         this.senseManager = options.senseManager ?? null;
         this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
         this.mode = options.mode ?? "production";
+        this.outlookServerFactory = options.outlookServerFactory ?? this.createDefaultOutlookServer.bind(this);
     }
+    /* v8 ignore start -- default outlook server wiring: production-only path, tests inject outlookServerFactory stub instead. startOutlookHttpServer itself has full coverage in outlook-http.test.ts @preserve */
+    createDefaultOutlookServer() {
+        return (0, outlook_http_1.startOutlookHttpServer)({
+            host: "127.0.0.1",
+            port: outlook_types_1.OUTLOOK_DEFAULT_PORT,
+            bundlesRoot: this.bundlesRoot,
+            readMachineState: () => (0, outlook_read_1.readOutlookMachineState)({ bundlesRoot: this.bundlesRoot }),
+            readMachineView: ({ machine }) => {
+                const overview = this.buildStatusPayload().overview;
+                return (0, outlook_view_1.buildOutlookMachineView)({
+                    machine,
+                    daemon: {
+                        status: overview.daemon,
+                        health: overview.health,
+                        mode: overview.mode,
+                        socketPath: overview.socketPath,
+                        outlookUrl: overview.outlookUrl,
+                        entryPath: overview.entryPath,
+                        workerCount: overview.workerCount,
+                        senseCount: overview.senseCount,
+                    },
+                });
+            },
+            readAgentState: (agentName) => (0, outlook_read_1.readOutlookAgentState)(agentName, { bundlesRoot: this.bundlesRoot }),
+            readAgentView: (agentName) => {
+                const agent = (0, outlook_read_1.readOutlookAgentState)(agentName, { bundlesRoot: this.bundlesRoot });
+                return (0, outlook_view_1.buildOutlookAgentView)({
+                    agent,
+                    viewer: { kind: "human" },
+                });
+            },
+        });
+    }
+    /* v8 ignore stop */
     buildStatusPayload() {
         const snapshots = this.processManager.listAgentSnapshots();
         const workers = buildWorkerRows(snapshots);
@@ -513,51 +549,21 @@ class OuroDaemon {
         await this.scheduler.reconcile?.();
         await this.drainPendingBundleMessages();
         await this.drainPendingSenseMessages();
-        /* v8 ignore start — Outlook server startup, tested via outlook-http.test.ts */
-        if (!this.outlookServer) {
-            try {
-                this.outlookServer = await (0, outlook_http_1.startOutlookHttpServer)({
-                    host: "127.0.0.1",
-                    port: outlook_types_1.OUTLOOK_DEFAULT_PORT,
-                    bundlesRoot: this.bundlesRoot,
-                    readMachineState: () => (0, outlook_read_1.readOutlookMachineState)({ bundlesRoot: this.bundlesRoot }),
-                    readMachineView: ({ machine }) => {
-                        const overview = this.buildStatusPayload().overview;
-                        return (0, outlook_view_1.buildOutlookMachineView)({
-                            machine,
-                            daemon: {
-                                status: overview.daemon,
-                                health: overview.health,
-                                mode: overview.mode,
-                                socketPath: overview.socketPath,
-                                outlookUrl: overview.outlookUrl,
-                                entryPath: overview.entryPath,
-                                workerCount: overview.workerCount,
-                                senseCount: overview.senseCount,
-                            },
-                        });
-                    },
-                    readAgentState: (agentName) => (0, outlook_read_1.readOutlookAgentState)(agentName, { bundlesRoot: this.bundlesRoot }),
-                    readAgentView: (agentName) => {
-                        const agent = (0, outlook_read_1.readOutlookAgentState)(agentName, { bundlesRoot: this.bundlesRoot });
-                        return (0, outlook_view_1.buildOutlookAgentView)({
-                            agent,
-                            viewer: { kind: "human" },
-                        });
-                    },
-                });
-            }
-            catch (error) {
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "daemon",
-                    event: "daemon.outlook_start_failed",
-                    message: `Outlook server failed to start: ${String(error)}`,
-                    meta: { port: outlook_types_1.OUTLOOK_DEFAULT_PORT },
-                });
-            }
+        // startInner is only reachable when this.server is null (guarded in
+        // start()), and stop() nulls out this.outlookServer alongside this.server,
+        // so outlookServer is guaranteed unset here — no need for a guard.
+        try {
+            this.outlookServer = await this.outlookServerFactory();
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.outlook_start_failed",
+                message: `Outlook server failed to start: ${String(error)}`,
+                meta: { port: outlook_types_1.OUTLOOK_DEFAULT_PORT },
+            });
         }
-        /* v8 ignore stop */
         if (fs.existsSync(this.socketPath)) {
             fs.unlinkSync(this.socketPath);
         }
@@ -815,12 +821,10 @@ class OuroDaemon {
             this.server.close();
             this.server = null;
         }
-        /* v8 ignore start -- outlookServer stop: only reachable when the outlook HTTP server successfully bound to port 6876 during start(). Coverage fluctuates locally because a running production daemon holds the port and tests get EADDRINUSE, leaving outlookServer null. In CI the port is free and this block runs. Not worth fighting port contention to cover two trivial lines. @preserve */
         if (this.outlookServer) {
             await this.outlookServer.stop();
             this.outlookServer = null;
         }
-        /* v8 ignore stop */
         if (fs.existsSync(this.socketPath)) {
             fs.unlinkSync(this.socketPath);
         }

package/dist/senses/cli.js

@@ -976,6 +976,8 @@ async function main(agentName, options) {
     const sessionMessages = existing?.messages && existing.messages.length > 0
         ? existing.messages
         : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", {}, resolvedContext) }];
+    // Repair any orphaned tool calls from a crash mid-turn
+    (0, core_1.repairOrphanedToolCalls)(sessionMessages);
     // Per-turn pipeline input: CLI capabilities and pending dir
     const cliCapabilities = (0, channel_1.getChannelCapabilities)("cli");
     const currentAgentName = (0, identity_1.getAgentName)();
@@ -1002,6 +1004,10 @@ async function main(agentName, options) {
                 /* v8 ignore start -- failover-aware callback wrapper: tested via pipeline integration @preserve */
                 const failoverAwareCallbacks = {
                     ...callbacks,
+                    // Save session after each tool result for crash recovery
+                    onToolResult: (turnMessages) => {
+                        (0, context_1.postTurn)(turnMessages, sessPath, undefined, undefined, sessionState);
+                    },
                     onError: (error, severity) => {
                         if (severity === "terminal" && failoverState) {
                             capturedTerminalError = error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.281",
+  "version": "0.1.0-alpha.283",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",