@ouro.bot/cli 0.1.0-alpha.86 → 0.1.0-alpha.88

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_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.88",
+      "changes": [
+        "CLI session repair now strips orphaned tool-result messages when a saved chat history lost the matching assistant tool call, so a broken prior turn no longer bricks every future `ouro chat` message with a tool-call replay error.",
+        "Recovered sessions keep valid tool call/result pairs intact while dropping only the stale outputs, which lets live operator chats resume from repaired history instead of forcing a brand-new thread."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.87",
+      "changes": [
+        "CLI chat now keeps model reasoning private again. The visible surface stays on spinners, tool updates, and actual replies instead of dim internal-thinking text leaking into the operator conversation.",
+        "Safe workspace selection now persists across daemon restarts and `ouro up`, so repo-local reads, edits, and shell commands keep targeting the same acquired scratch clone or worktree after a runtime update."
+      ]
+    },
     {
       "version": "0.1.0-alpha.86",
       "changes": [

package/dist/heart/safe-workspace.js

@@ -45,6 +45,75 @@ const identity_1 = require("./identity");
 const runtime_1 = require("../nerves/runtime");
 let activeSelection = null;
 let cleanupHookRegistered = false;
+function workspaceSelectionStateFile(workspaceBase) {
+    return path.join(workspaceBase, ".active-safe-workspace.json");
+}
+function getOptionalFsFn(name) {
+    try {
+        return fs[name];
+    }
+    catch {
+        return undefined;
+    }
+}
+function shouldPersistSelection(options) {
+    return options.persistSelection ?? options.workspaceRoot === undefined;
+}
+function isPersistedSelectionShape(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (typeof candidate.runtimeKind === "string"
+        && typeof candidate.repoRoot === "string"
+        && typeof candidate.workspaceRoot === "string"
+        && typeof candidate.workspaceBranch === "string"
+        && (candidate.sourceBranch === null || typeof candidate.sourceBranch === "string")
+        && typeof candidate.sourceCloneUrl === "string"
+        && typeof candidate.cleanupAfterMerge === "boolean"
+        && typeof candidate.created === "boolean"
+        && typeof candidate.note === "string");
+}
+function loadPersistedSelection(workspaceBase, options) {
+    const existsSync = options.existsSync ?? fs.existsSync;
+    const readFileSync = options.readFileSync ?? getOptionalFsFn("readFileSync");
+    const unlinkSync = options.unlinkSync ?? getOptionalFsFn("unlinkSync");
+    const stateFile = workspaceSelectionStateFile(workspaceBase);
+    if (!existsSync(stateFile))
+        return null;
+    if (!readFileSync)
+        return null;
+    try {
+        const raw = readFileSync(stateFile, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!isPersistedSelectionShape(parsed) || !existsSync(parsed.workspaceRoot)) {
+            try {
+                unlinkSync?.(stateFile);
+            }
+            catch {
+                // best effort
+            }
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        try {
+            unlinkSync?.(stateFile);
+        }
+        catch {
+            // best effort
+        }
+        return null;
+    }
+}
+function persistSelectionState(workspaceBase, selection, options) {
+    const mkdirSync = options.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = options.writeFileSync ?? getOptionalFsFn("writeFileSync");
+    if (!writeFileSync)
+        return;
+    mkdirSync(workspaceBase, { recursive: true });
+    writeFileSync(workspaceSelectionStateFile(workspaceBase), JSON.stringify(selection, null, 2), "utf-8");
+}
 function defaultNow() {
     return Date.now();
 }
@@ -146,6 +215,7 @@ function ensureSafeRepoWorkspace(options = {}) {
     const agentName = resolveAgentName(options.agentName);
     const canonicalRepoUrl = options.canonicalRepoUrl ?? identity_1.HARNESS_CANONICAL_REPO_URL;
     const workspaceBase = options.workspaceRoot ?? (0, identity_1.getAgentRepoWorkspacesRoot)(agentName);
+    const persistSelection = shouldPersistSelection(options);
     const spawnSync = options.spawnSync ?? child_process_1.spawnSync;
     const existsSync = options.existsSync ?? fs.existsSync;
     const mkdirSync = options.mkdirSync ?? fs.mkdirSync;
@@ -153,6 +223,26 @@ function ensureSafeRepoWorkspace(options = {}) {
     const now = options.now ?? defaultNow;
     const stamp = String(now());
     registerCleanupHook({ rmSync });
+    if (persistSelection) {
+        const restored = loadPersistedSelection(workspaceBase, options);
+        if (restored) {
+            activeSelection = restored;
+            (0, runtime_1.emitNervesEvent)({
+                component: "workspace",
+                event: "workspace.safe_repo_restored",
+                message: "restored safe repo workspace after runtime restart",
+                meta: {
+                    runtimeKind: restored.runtimeKind,
+                    repoRoot: restored.repoRoot,
+                    workspaceRoot: restored.workspaceRoot,
+                    workspaceBranch: restored.workspaceBranch,
+                    sourceBranch: restored.sourceBranch,
+                    cleanupAfterMerge: restored.cleanupAfterMerge,
+                },
+            });
+            return restored;
+        }
+    }
     let selection;
     if (isGitClone(repoRoot, spawnSync)) {
         const branch = readCurrentBranch(repoRoot, spawnSync);
@@ -205,6 +295,9 @@ function ensureSafeRepoWorkspace(options = {}) {
         };
     }
     activeSelection = selection;
+    if (persistSelection) {
+        persistSelectionState(workspaceBase, selection, options);
+    }
     (0, runtime_1.emitNervesEvent)({
         component: "workspace",
         event: "workspace.safe_repo_acquired",

package/dist/mind/context.js

@@ -227,6 +227,34 @@ function repairSessionMessages(messages) {
     });
     return result;
 }
+function stripOrphanedToolResults(messages) {
+    const validCallIds = new Set();
+    for (const msg of messages) {
+        if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls))
+            continue;
+        for (const toolCall of msg.tool_calls)
+            validCallIds.add(toolCall.id);
+    }
+    let removed = 0;
+    const repaired = messages.filter((msg) => {
+        if (msg.role !== "tool")
+            return true;
+        const keep = validCallIds.has(msg.tool_call_id);
+        if (!keep)
+            removed++;
+        return keep;
+    });
+    if (removed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "mind.session_orphan_tool_result_repair",
+            component: "mind",
+            message: "removed orphaned tool results from session history",
+            meta: { removed },
+        });
+    }
+    return repaired;
+}
 function saveSession(filePath, messages, lastUsage, state) {
     const violations = validateSessionMessages(messages);
     if (violations.length > 0) {
@@ -239,6 +267,7 @@ function saveSession(filePath, messages, lastUsage, state) {
         });
         messages = repairSessionMessages(messages);
     }
+    messages = stripOrphanedToolResults(messages);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const envelope = { version: 1, messages };
     if (lastUsage)
@@ -269,6 +298,7 @@ function loadSession(filePath) {
             });
             messages = repairSessionMessages(messages);
         }
+        messages = stripOrphanedToolResults(messages);
         const rawState = data?.state && typeof data.state === "object" && data.state !== null
             ? data.state
             : undefined;

package/dist/senses/cli.js

@@ -346,7 +346,6 @@ function createCliCallbacks() {
     });
     let currentSpinner = null;
     function setSpinner(s) { currentSpinner = s; setActiveSpinner(s); }
-    let hadReasoning = false;
     let hadToolRun = false;
     let textDirty = false; // true when text/reasoning was written without a trailing newline
     const streamer = new MarkdownStreamer();
@@ -355,7 +354,6 @@ function createCliCallbacks() {
         onModelStart: () => {
             currentSpinner?.stop();
             setSpinner(null);
-            hadReasoning = false;
             textDirty = false;
             streamer.reset();
             wrapper.reset();
@@ -382,12 +380,6 @@ function createCliCallbacks() {
                 currentSpinner.stop();
                 setSpinner(null);
             }
-            if (hadReasoning) {
-                // Single newline to separate reasoning from reply — reasoning
-                // output often ends with its own trailing newline(s)
-                process.stdout.write("\n");
-                hadReasoning = false;
-            }
             const rendered = streamer.push(text);
             /* v8 ignore start -- wrapper integration: tested via cli.test.ts onTextChunk tests @preserve */
             if (rendered) {
@@ -398,14 +390,9 @@ function createCliCallbacks() {
             /* v8 ignore stop */
             textDirty = text.length > 0 && !text.endsWith("\n");
         },
-        onReasoningChunk: (text) => {
-            if (currentSpinner) {
-                currentSpinner.stop();
-                setSpinner(null);
-            }
-            hadReasoning = true;
-            process.stdout.write(`\x1b[2m${text}\x1b[0m`);
-            textDirty = text.length > 0 && !text.endsWith("\n");
+        onReasoningChunk: (_text) => {
+            // Keep reasoning private in the CLI surface. The spinner continues to
+            // represent active thinking until actual tool or answer output arrives.
         },
         onToolStart: (_name, _args) => {
             // Stop the model-start spinner: when the model returns only tool calls

package/package.json

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