@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/senses/cli.js

@@ -48,6 +48,8 @@ const phrases_1 = require("../mind/phrases");
 const format_1 = require("../mind/format");
 const config_1 = require("../heart/config");
 const context_1 = require("../mind/context");
+const pending_1 = require("../mind/pending");
+const prompt_refresh_1 = require("../mind/prompt-refresh");
 const commands_1 = require("./commands");
 const identity_1 = require("../heart/identity");
 const nerves_1 = require("../nerves");
@@ -57,6 +59,7 @@ const tokens_1 = require("../mind/friends/tokens");
 const cli_logging_1 = require("../nerves/cli-logging");
 const runtime_1 = require("../nerves/runtime");
 const trust_gate_1 = require("./trust-gate");
+const session_lock_1 = require("./session-lock");
 // spinner that only touches stderr, cleans up after itself
 // exported for direct testability (stop-without-start branch)
 class Spinner {
@@ -365,7 +368,10 @@ function createCliCallbacks() {
         },
     };
 }
-async function main() {
+async function main(agentName, options) {
+    if (agentName)
+        (0, identity_1.setAgentName)(agentName);
+    const pasteDebounceMs = options?.pasteDebounceMs ?? 50;
     // Fail fast if provider is misconfigured (triggers human-readable error + exit)
     (0, core_1.getProvider)();
     const registry = (0, commands_1.createCommandRegistry)();
@@ -388,15 +394,50 @@ async function main() {
         signin: async () => undefined,
         context: resolvedContext,
         friendStore,
+        summarize: (0, core_1.createSummarize)(),
     };
     const friendId = resolvedContext.friend.id;
-    (0, cli_logging_1.configureCliRuntimeLogger)(friendId);
+    const agentConfig = (0, identity_1.loadAgentConfig)();
+    (0, cli_logging_1.configureCliRuntimeLogger)(friendId, {
+        level: agentConfig.logging?.level,
+        sinks: agentConfig.logging?.sinks,
+    });
     const sessPath = (0, config_1.sessionPath)(friendId, "cli", "session");
+    let sessionLock = null;
+    try {
+        sessionLock = (0, session_lock_1.acquireSessionLock)(`${sessPath}.lock`, (0, identity_1.getAgentName)());
+    }
+    catch (error) {
+        /* v8 ignore start -- integration: main() is interactive, lock tested in session-lock.test.ts @preserve */
+        if (error instanceof session_lock_1.SessionLockError) {
+            process.stderr.write(`${error.message}\n`);
+            return;
+        }
+        throw error;
+        /* v8 ignore stop */
+    }
     // Load existing session or start fresh
     const existing = (0, context_1.loadSession)(sessPath);
     const messages = existing?.messages && existing.messages.length > 0
         ? existing.messages
         : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", undefined, resolvedContext) }];
+    // Pending queue drain: inject pending messages as harness-context + assistant-content pairs
+    const pendingDir = (0, pending_1.getPendingDir)((0, identity_1.getAgentName)(), friendId, "cli", "session");
+    const drainToMessages = () => {
+        const pending = (0, pending_1.drainPending)(pendingDir);
+        if (pending.length === 0)
+            return 0;
+        for (const msg of pending) {
+            messages.push({ role: "user", name: "harness", content: `[proactive message from ${msg.from}]` });
+            messages.push({ role: "assistant", content: msg.content });
+        }
+        return pending.length;
+    };
+    // Startup drain: deliver offline messages
+    const startupCount = drainToMessages();
+    if (startupCount > 0) {
+        (0, context_1.saveSession)(sessPath, messages);
+    }
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
     const ctrl = new InputController(rl);
     let currentAbort = null;
@@ -429,8 +470,40 @@ async function main() {
             rl.close();
         }
     });
+    // Debounced line iterator: collects rapid-fire lines (paste) into a single input
+    async function* debouncedLines(source) {
+        if (pasteDebounceMs <= 0) {
+            yield* source;
+            return;
+        }
+        const iter = source[Symbol.asyncIterator]();
+        while (true) {
+            const first = await iter.next();
+            if (first.done)
+                break;
+            // Collect any lines that arrive within the debounce window (paste detection)
+            const lines = [first.value];
+            let more = true;
+            while (more) {
+                const raced = await Promise.race([
+                    iter.next().then((r) => ({ kind: "line", result: r })),
+                    new Promise((r) => setTimeout(() => r({ kind: "timeout" }), pasteDebounceMs)),
+                ]);
+                if (raced.kind === "timeout") {
+                    more = false;
+                }
+                else if (raced.result.done) {
+                    more = false;
+                }
+                else {
+                    lines.push(raced.result.value);
+                }
+            }
+            yield lines.join("\n");
+        }
+    }
     try {
-        for await (const input of rl) {
+        for await (const input of debouncedLines(rl)) {
             if (closed)
                 break;
             if (!input.trim()) {
@@ -477,12 +550,15 @@ async function main() {
                     }
                 }
             }
-            // Re-style the echoed input line (readline terminal:true echoes it as "> input")
-            // Calculate terminal rows the echo occupied (prompt "> " + input, wrapped)
+            // Re-style the echoed input lines (readline terminal:true echoes each line)
+            // For multiline paste, each line was echoed separately — erase them all
             const cols = process.stdout.columns || 80;
-            const echoLen = 2 + input.length; // "> " prefix + input
-            const rows = Math.ceil(echoLen / cols);
-            process.stdout.write(`\x1b[${rows}A\x1b[K` + `\x1b[1m> ${input}\x1b[0m\n\n`);
+            const inputLines = input.split("\n");
+            let echoRows = 0;
+            for (const line of inputLines) {
+                echoRows += Math.ceil((2 + line.length) / cols); // "> " prefix + line content
+            }
+            process.stdout.write(`\x1b[${echoRows}A\x1b[K` + `\x1b[1m> ${inputLines[0]}${inputLines.length > 1 ? ` (+${inputLines.length - 1} lines)` : ""}\x1b[0m\n\n`);
             messages.push({ role: "user", content: input });
             addHistory(history, input);
             currentAbort = new AbortController();
@@ -510,12 +586,17 @@ async function main() {
             process.stdout.write("\n\n");
             (0, context_1.postTurn)(messages, sessPath, result?.usage);
             await (0, tokens_1.accumulateFriendTokens)(friendStore, resolvedContext.friend.id, result?.usage);
+            // Post-turn: drain any pending messages that arrived during runAgent
+            drainToMessages();
+            // Post-turn: refresh system prompt so active sessions metadata is current
+            await (0, prompt_refresh_1.refreshSystemPrompt)(messages, "cli", undefined, resolvedContext);
             if (closed)
                 break;
             process.stdout.write("\x1b[36m> \x1b[0m");
         }
     }
     finally {
+        sessionLock?.release();
         rl.close();
         // eslint-disable-next-line no-console -- terminal UX: goodbye
         console.log("bye");

package/dist/senses/inner-dialog.js

@@ -194,6 +194,21 @@ async function runInnerDialogTurn(options) {
         const instinctPrompt = buildInstinctUserMessage(instincts, reason, state);
         messages.push({ role: "user", content: instinctPrompt });
     }
+    const inboxMessages = options?.drainInbox?.() ?? [];
+    if (inboxMessages.length > 0) {
+        const lastUserIdx = messages.length - 1;
+        const lastUser = messages[lastUserIdx];
+        /* v8 ignore next -- defensive: all code paths push a user message before here @preserve */
+        if (lastUser?.role === "user" && typeof lastUser.content === "string") {
+            const section = inboxMessages
+                .map((msg) => `- **${msg.from}**: ${msg.content}`)
+                .join("\n");
+            messages[lastUserIdx] = {
+                ...lastUser,
+                content: `${lastUser.content}\n\n## incoming messages\n${section}`,
+            };
+        }
+    }
     const callbacks = createInnerDialogCallbacks();
     const traceId = (0, nerves_1.createTraceId)();
     const result = await (0, core_1.runAgent)(messages, callbacks, "cli", options?.signal, {

package/dist/senses/session-lock.js

@@ -0,0 +1,119 @@
+"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.SessionLockError = void 0;
+exports.acquireSessionLock = acquireSessionLock;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+class SessionLockError extends Error {
+    agentName;
+    constructor(agentName) {
+        super(`already chatting with ${agentName} in another terminal`);
+        this.name = "SessionLockError";
+        this.agentName = agentName;
+    }
+}
+exports.SessionLockError = SessionLockError;
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const defaultDeps = {
+    writeFileSync: (p, d, o) => fs.writeFileSync(p, d, o),
+    readFileSync: (p, e) => fs.readFileSync(p, e),
+    unlinkSync: (p) => fs.unlinkSync(p),
+    pid: process.pid,
+    isProcessAlive: defaultIsProcessAlive,
+};
+function acquireSessionLock(lockPath, agentName, deps = defaultDeps) {
+    const tryWrite = () => {
+        try {
+            deps.writeFileSync(lockPath, String(deps.pid), { flag: "wx" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (!tryWrite()) {
+        // Lock file exists — check if stale
+        let existingPid;
+        try {
+            existingPid = parseInt(deps.readFileSync(lockPath, "utf-8").trim(), 10);
+        }
+        catch {
+            // Can't read lock file — try removing and retrying
+            try {
+                deps.unlinkSync(lockPath);
+            }
+            catch { /* ignore */ }
+            if (!tryWrite())
+                throw new SessionLockError(agentName);
+            return makeRelease(lockPath, deps);
+        }
+        if (Number.isNaN(existingPid) || !deps.isProcessAlive(existingPid)) {
+            // Stale lock — remove and retry
+            try {
+                deps.unlinkSync(lockPath);
+            }
+            catch { /* ignore */ }
+            if (!tryWrite())
+                throw new SessionLockError(agentName);
+            (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.session_lock_stolen", message: "stole stale session lock from dead process", meta: { agentName, existingPid } });
+            return makeRelease(lockPath, deps);
+        }
+        throw new SessionLockError(agentName);
+    }
+    return makeRelease(lockPath, deps);
+}
+function makeRelease(lockPath, deps) {
+    let released = false;
+    return {
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            try {
+                deps.unlinkSync(lockPath);
+            }
+            catch { /* ignore */ }
+        },
+    };
+}

package/dist/senses/teams.js

@@ -444,6 +444,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
         githubToken: teamsContext.githubToken,
         signin: teamsContext.signin,
         friendStore: store,
+        summarize: (0, core_1.createSummarize)(),
     } : undefined;
     if (toolContext) {
         const resolver = new resolver_1.FriendResolver(store, {

package/package.json

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

package/subagents/README.md

@@ -22,12 +22,14 @@ For tools that support skills but not Claude sub-agents, install these as skills
 ```bash
 mkdir -p ~/.codex/skills/work-planner ~/.codex/skills/work-doer ~/.codex/skills/work-merger
 
-# Recommended: hard-link to keep one source of truth and avoid stale copies
+# Hard-link to keep one source of truth
 ln -f "$(pwd)/subagents/work-planner.md" ~/.codex/skills/work-planner/SKILL.md
 ln -f "$(pwd)/subagents/work-doer.md" ~/.codex/skills/work-doer/SKILL.md
 ln -f "$(pwd)/subagents/work-merger.md" ~/.codex/skills/work-merger/SKILL.md
 ```
 
+**Important:** Hard-links break when editors save by replacing the file (new inode). After editing any `subagents/*.md` file, re-run the `ln -f` command for that file to restore the link. You can verify with `stat -f '%i'` — both files should share the same inode.
+
 Optional UI metadata:
 
 ```bash

package/subagents/work-merger.md

@@ -327,12 +327,43 @@ done
 ### Step 4: Handle CI result
 
 **CI passes:**
-- Proceed to Step 5 (merge).
+- Proceed to Step 5 (pre-merge sanity check).
 
 **CI fails:**
 - Proceed to **CI Failure Self-Repair**.
 
-### Step 5: Merge the PR
+### Step 5: Pre-merge sanity check
+
+Before merging, verify the PR delivers what the planning/doing doc intended. This is a lightweight review, not a full audit.
+
+1. Re-read the doing doc (already available from On Startup)
+2. Review the PR diff: `gh pr diff "${BRANCH}"`
+3. Check that:
+   - All completion criteria from the doing doc are addressed
+   - No unrelated changes slipped in
+   - The PR title and body accurately describe what shipped
+4. Post findings as a PR comment:
+
+```bash
+gh pr comment "${BRANCH}" --body "$(cat <<'REVIEW'
+## Pre-merge sanity check
+
+Checked PR against doing doc: `<doing-doc-path>`
+
+- [ ] All completion criteria addressed
+- [ ] No unrelated changes
+- [ ] PR description accurate
+
+<any notes or concerns>
+
+Proceeding to merge.
+REVIEW
+)"
+```
+
+If the check reveals a genuine gap (missing criteria, wrong files included), fix it before merging. If everything looks good, proceed to Step 6.
+
+### Step 6: Merge the PR
 
 ```bash
 gh pr merge "${BRANCH}" --merge --delete-branch