@ouro.bot/cli 0.1.0-alpha.5 → 0.1.0-alpha.500

package/dist/heart/bridges/state-machine.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBridgeState = createBridgeState;
+exports.bridgeStateLabel = bridgeStateLabel;
+exports.activateBridge = activateBridge;
+exports.beginBridgeProcessing = beginBridgeProcessing;
+exports.queueBridgeFollowUp = queueBridgeFollowUp;
+exports.advanceBridgeAfterTurn = advanceBridgeAfterTurn;
+exports.suspendBridge = suspendBridge;
+exports.completeBridge = completeBridge;
+exports.cancelBridge = cancelBridge;
+exports.reconcileBridgeState = reconcileBridgeState;
+const runtime_1 = require("../../nerves/runtime");
+function transition(state, next, action) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.bridge_state_transition",
+        message: "bridge state transitioned",
+        meta: {
+            action,
+            from: bridgeStateLabel(state),
+            to: bridgeStateLabel(next),
+        },
+    });
+    return next;
+}
+function assertNonTerminal(state, action) {
+    if (state.lifecycle === "completed" || state.lifecycle === "cancelled") {
+        throw new Error(`cannot ${action} a terminal bridge`);
+    }
+}
+function createBridgeState() {
+    return {
+        lifecycle: "forming",
+        runtime: "idle",
+    };
+}
+function bridgeStateLabel(state) {
+    switch (state.lifecycle) {
+        case "forming":
+            return "forming";
+        case "suspended":
+            return "suspended";
+        case "completed":
+            return "completed";
+        case "cancelled":
+            return "cancelled";
+        case "active":
+            if (state.runtime === "processing")
+                return "active-processing";
+            if (state.runtime === "awaiting-follow-up")
+                return "awaiting-follow-up";
+            return "active-idle";
+    }
+}
+function activateBridge(state) {
+    assertNonTerminal(state, "activate");
+    if (state.lifecycle !== "forming" && state.lifecycle !== "suspended") {
+        throw new Error("cannot activate bridge from current state");
+    }
+    return transition(state, { lifecycle: "active", runtime: "idle" }, "activate");
+}
+function beginBridgeProcessing(state) {
+    assertNonTerminal(state, "process");
+    if (state.lifecycle !== "active" || state.runtime !== "idle") {
+        throw new Error("cannot process bridge from current state");
+    }
+    return transition(state, { lifecycle: "active", runtime: "processing" }, "begin-processing");
+}
+function queueBridgeFollowUp(state) {
+    assertNonTerminal(state, "queue");
+    if (state.lifecycle !== "active") {
+        throw new Error("cannot queue follow-up for non-active bridge");
+    }
+    if (state.runtime === "processing") {
+        return transition(state, { lifecycle: "active", runtime: "awaiting-follow-up" }, "queue-follow-up");
+    }
+    if (state.runtime === "awaiting-follow-up") {
+        return state;
+    }
+    throw new Error("cannot queue follow-up when bridge is not processing");
+}
+function advanceBridgeAfterTurn(state) {
+    assertNonTerminal(state, "advance");
+    if (state.lifecycle !== "active") {
+        throw new Error("cannot advance non-active bridge");
+    }
+    if (state.runtime === "processing") {
+        return transition(state, { lifecycle: "active", runtime: "idle" }, "finish-processing");
+    }
+    if (state.runtime === "awaiting-follow-up") {
+        return transition(state, { lifecycle: "active", runtime: "processing" }, "resume-follow-up");
+    }
+    throw new Error("cannot advance an idle bridge");
+}
+function suspendBridge(state) {
+    assertNonTerminal(state, "suspend");
+    if ((state.lifecycle !== "forming" && state.lifecycle !== "active") || state.runtime !== "idle") {
+        throw new Error("cannot suspend bridge from current state");
+    }
+    return transition(state, { lifecycle: "suspended", runtime: "idle" }, "suspend");
+}
+function completeBridge(state) {
+    assertNonTerminal(state, "complete");
+    if (state.runtime !== "idle") {
+        throw new Error("cannot complete a bridge mid-turn");
+    }
+    return transition(state, { lifecycle: "completed", runtime: "idle" }, "complete");
+}
+function cancelBridge(state) {
+    assertNonTerminal(state, "cancel");
+    if (state.runtime !== "idle") {
+        throw new Error("cannot cancel a bridge mid-turn");
+    }
+    return transition(state, { lifecycle: "cancelled", runtime: "idle" }, "cancel");
+}
+function reconcileBridgeState(state, input) {
+    if (state.lifecycle === "completed" || state.lifecycle === "cancelled") {
+        return state;
+    }
+    if (state.runtime !== "idle") {
+        return state;
+    }
+    const hasLiveSignal = input.hasAttachedSessionActivity || input.hasLiveTask || input.currentSessionAttached;
+    if (state.lifecycle === "suspended") {
+        return hasLiveSignal ? activateBridge(state) : state;
+    }
+    if (state.lifecycle === "forming") {
+        return hasLiveSignal ? activateBridge(state) : suspendBridge(state);
+    }
+    if (state.lifecycle === "active") {
+        return hasLiveSignal ? state : suspendBridge(state);
+    }
+    return state;
+}

package/dist/heart/bridges/store.js

@@ -0,0 +1,123 @@
+"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.getBridgeStateRoot = getBridgeStateRoot;
+exports.createBridgeStore = createBridgeStore;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function sessionIdentityMatches(session, candidate) {
+    return (session.friendId === candidate.friendId
+        && session.channel === candidate.channel
+        && session.key === candidate.key);
+}
+function bridgeFilePath(rootDir, id) {
+    return path.join(rootDir, `${id}.json`);
+}
+function getBridgeStateRoot() {
+    return path.join((0, identity_1.getAgentStateRoot)(), "bridges");
+}
+function createBridgeStore(options = {}) {
+    const rootDir = options.rootDir ?? getBridgeStateRoot();
+    function ensureRoot() {
+        fs.mkdirSync(rootDir, { recursive: true });
+    }
+    return {
+        save(bridge) {
+            ensureRoot();
+            fs.writeFileSync(bridgeFilePath(rootDir, bridge.id), JSON.stringify(bridge, null, 2), "utf-8");
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_store_save",
+                message: "saved bridge record",
+                meta: {
+                    bridgeId: bridge.id,
+                    rootDir,
+                },
+            });
+            return bridge;
+        },
+        get(id) {
+            const filePath = bridgeFilePath(rootDir, id);
+            try {
+                const raw = fs.readFileSync(filePath, "utf-8");
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        },
+        list() {
+            ensureRoot();
+            const files = fs.readdirSync(rootDir).filter((entry) => entry.endsWith(".json")).sort();
+            const bridges = files
+                .map((fileName) => {
+                try {
+                    return JSON.parse(fs.readFileSync(path.join(rootDir, fileName), "utf-8"));
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((bridge) => bridge !== null);
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_store_list",
+                message: "listed bridge records",
+                meta: {
+                    rootDir,
+                    count: bridges.length,
+                },
+            });
+            return bridges;
+        },
+        findBySession(session) {
+            const matches = this.list().filter((bridge) => bridge.attachedSessions.some((candidate) => sessionIdentityMatches(session, candidate)));
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.bridge_store_find_by_session",
+                message: "located bridges for canonical session",
+                meta: {
+                    friendId: session.friendId,
+                    channel: session.channel,
+                    key: session.key,
+                    count: matches.length,
+                },
+            });
+            return matches;
+        },
+    };
+}

package/dist/heart/bundle-state.js

@@ -0,0 +1,168 @@
+"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.detectBundleState = detectBundleState;
+exports.renderBundleStateHint = renderBundleStateHint;
+/**
+ * Bundle state detection: inspects an agent bundle's git + pending-sync
+ * state and returns a structured list of issues the agent needs to remediate
+ * via its `bundle_*` tools.
+ *
+ * Previously the sync pipeline surfaced a single free-form `syncFailure`
+ * string that was good for humans but hard for the agent to act on. The
+ * new `BundleStateIssue` enum lets the agent pattern-match on discrete
+ * cases and pick the correct remediation tool (shipping in PR 6).
+ *
+ * Detection never throws: every git call is wrapped in try/catch so a
+ * broken bundle or a missing git binary degrades to an empty array or a
+ * `not_a_git_repo` signal rather than exploding the turn pipeline.
+ *
+ * The classification returned here is detected from bundle state +
+ * the `classification` field of `state/pending-sync.json` (written by
+ * `postTurnPush` in sync.ts when it writes the pending-sync record).
+ *
+ *   - `not_a_git_repo`: `.git` directory missing.
+ *   - `no_remote_configured`: `git remote` returns empty.
+ *   - `first_commit_never_happened`: `.git` exists but `git rev-parse HEAD`
+ *     fails (fresh `git init` with nothing committed).
+ *   - `pending_sync_exists`: `state/pending-sync.json` exists — the agent
+ *     should inspect it and clear the pending state.
+ *   - `remote_push_failed`: pending-sync classified as `push_rejected` —
+ *     the remote advanced and a simple retry won't work.
+ *   - `pull_rebase_conflict`: pending-sync classified as
+ *     `pull_rebase_conflict` — the rebase left conflicted files the agent
+ *     has to walk the user through resolving.
+ */
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function detectBundleState(agentRoot, deps = {}) {
+    const exec = deps.execFileSync ?? child_process_1.execFileSync;
+    const exists = deps.existsSync ?? fs.existsSync;
+    const readFile = deps.readFileSync ?? ((p, enc) => fs.readFileSync(p, enc));
+    const issues = [];
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.bundle_state_detect_start",
+        message: "detecting bundle state",
+        meta: { agentRoot },
+    });
+    const gitDir = path.join(agentRoot, ".git");
+    const isGitRepo = exists(gitDir);
+    if (!isGitRepo) {
+        issues.push("not_a_git_repo");
+    }
+    else {
+        // Check remote presence
+        try {
+            const remoteOutput = exec("git", ["remote"], {
+                cwd: agentRoot,
+                stdio: "pipe",
+                timeout: 5000,
+            }).toString().trim();
+            if (remoteOutput.length === 0) {
+                issues.push("no_remote_configured");
+            }
+        }
+        catch {
+            // Git missing or broken — treat as no_remote_configured so the
+            // agent surfaces a "fix git" signal rather than a silent pass.
+            issues.push("no_remote_configured");
+        }
+        // Check for initial commit
+        try {
+            exec("git", ["rev-parse", "HEAD"], {
+                cwd: agentRoot,
+                stdio: "pipe",
+                timeout: 5000,
+            });
+        }
+        catch {
+            issues.push("first_commit_never_happened");
+        }
+    }
+    // Pending-sync file — independent of git state (could exist on a bundle
+    // that was a repo and then had its .git deleted). When present, also
+    // inspect the classification field to surface the specific failure
+    // mode as an additional issue.
+    const pendingSyncPath = path.join(agentRoot, "state", "pending-sync.json");
+    if (exists(pendingSyncPath)) {
+        issues.push("pending_sync_exists");
+        try {
+            const raw = readFile(pendingSyncPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.classification === "push_rejected") {
+                issues.push("remote_push_failed");
+            }
+            else if (parsed.classification === "pull_rebase_conflict") {
+                issues.push("pull_rebase_conflict");
+            }
+        }
+        catch {
+            // Malformed or unreadable pending-sync.json — pending_sync_exists
+            // alone is enough signal for the agent to investigate.
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.bundle_state_detect_end",
+        message: `bundle state detected: ${issues.length} issue(s)`,
+        meta: { agentRoot, issues },
+    });
+    return issues;
+}
+/**
+ * First-person remediation hint text for the start-of-turn packet. Reads
+ * as the agent's own voice per the declarative first-person note rule.
+ * Returns empty string when there are no issues (so the packet renderer
+ * can skip the section entirely).
+ */
+function renderBundleStateHint(issues) {
+    if (issues.length === 0)
+        return "";
+    const labels = {
+        not_a_git_repo: "not a git repo",
+        no_remote_configured: "no remote configured",
+        first_commit_never_happened: "first commit never happened",
+        pending_sync_exists: "pending sync from a prior turn",
+        remote_push_failed: "remote push rejected (remote advanced)",
+        pull_rebase_conflict: "pull-rebase left conflicts i need to walk the user through",
+    };
+    const list = issues.map((issue) => labels[issue]).join(", ");
+    return (`my bundle has unresolved git state: ${list}. ` +
+        `i have the bundle_* tools available to fix this — i should run ` +
+        `bundle_check_sync_status first, then use the appropriate remediation tool.`);
+}

package/dist/heart/commitments.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveCommitments = deriveCommitments;
+exports.formatCommitments = formatCommitments;
+const obligations_1 = require("../arc/obligations");
+const runtime_1 = require("../nerves/runtime");
+function describeActiveObligation(obligation) {
+    if (obligation.status === "pending") {
+        return `i owe ${obligation.origin.friendId}: ${obligation.content}`;
+    }
+    const surface = obligation.currentSurface?.label;
+    const statusText = obligation.status.replaceAll("_", " ");
+    if (surface) {
+        return `i owe ${obligation.origin.friendId}: ${obligation.content} (${statusText} in ${surface})`;
+    }
+    return `i owe ${obligation.origin.friendId}: ${obligation.content} (${statusText})`;
+}
+function deriveCommitments(activeWorkFrame, innerJob, pendingObligations) {
+    const committedTo = [];
+    const completionCriteria = [];
+    const safeToIgnore = [];
+    // Persistent obligations from the obligation store
+    // Sort by status priority: investigating/waiting/updating before pending
+    if (pendingObligations && pendingObligations.length > 0) {
+        const sorted = [...pendingObligations].sort((a, b) => {
+            const advancedA = a.status !== "pending" && a.status !== "fulfilled" ? 0 : 1;
+            const advancedB = b.status !== "pending" && b.status !== "fulfilled" ? 0 : 1;
+            return advancedA - advancedB;
+        });
+        let hasAdvancedObligation = false;
+        for (const ob of sorted) {
+            if (!(0, obligations_1.isOpenObligationStatus)(ob.status))
+                continue;
+            committedTo.push(describeActiveObligation(ob));
+            if (ob.status !== "pending")
+                hasAdvancedObligation = true;
+        }
+        completionCriteria.push("fulfill my outstanding obligations");
+        if (hasAdvancedObligation) {
+            completionCriteria.push("close my active obligation loops");
+        }
+    }
+    // Inner job
+    if (innerJob.status === "queued" || innerJob.status === "running") {
+        const contentSuffix = innerJob.content ? ` -- ${innerJob.content.slice(0, 60)}` : "";
+        committedTo.push(`i'm thinking through something privately${contentSuffix}`);
+    }
+    else if (innerJob.status === "surfaced") {
+        committedTo.push("i finished thinking about something and need to bring it back");
+    }
+    // mustResolveBeforeHandoff
+    if (activeWorkFrame.mustResolveBeforeHandoff) {
+        committedTo.push("i need to finish what i started before moving on");
+        completionCriteria.push("resolve the current thread before moving on");
+    }
+    // Bridges
+    for (const bridge of activeWorkFrame.bridges) {
+        committedTo.push(`i have shared work: ${bridge.summary || bridge.objective}`);
+    }
+    if (activeWorkFrame.bridges.length > 0) {
+        completionCriteria.push("keep shared work aligned across sessions");
+    }
+    // Tasks
+    for (const taskName of activeWorkFrame.taskPressure?.liveTaskNames ?? []) {
+        committedTo.push(`i'm tracking: ${taskName}`);
+    }
+    // Obligation completion criteria
+    if (innerJob.obligationStatus === "pending") {
+        const name = innerJob.origin?.friendName ?? innerJob.origin?.friendId ?? "them";
+        completionCriteria.push(`bring my answer back to ${name}`);
+    }
+    // Default completion criteria
+    if (completionCriteria.length === 0) {
+        completionCriteria.push("just be present in this conversation");
+    }
+    // Safe to ignore
+    if (innerJob.status === "idle" && !(activeWorkFrame.inner?.hasPending)) {
+        safeToIgnore.push("no private thinking in progress");
+    }
+    if (activeWorkFrame.bridges.length === 0) {
+        safeToIgnore.push("no shared work to coordinate");
+    }
+    if ((activeWorkFrame.taskPressure?.liveTaskNames ?? []).length === 0) {
+        safeToIgnore.push("no active tasks to track");
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.commitments_derive",
+        message: "derived commitments frame",
+        meta: { committedCount: committedTo.length, criteriaCount: completionCriteria.length },
+    });
+    return { committedTo, completionCriteria, safeToIgnore };
+}
+function formatCommitments(commitments) {
+    const sections = [];
+    if (commitments.committedTo.length === 0) {
+        sections.push("i'm not holding anything specific right now. i'm free to be present.");
+    }
+    else {
+        sections.push("## what i'm holding right now");
+        sections.push("");
+        sections.push(commitments.committedTo.map((c) => `- ${c}`).join("\n"));
+    }
+    sections.push("");
+    sections.push("## what \"done\" looks like");
+    sections.push(commitments.completionCriteria.map((c) => `- ${c}`).join("\n"));
+    sections.push("");
+    sections.push("## what i can let go of");
+    sections.push(commitments.safeToIgnore.map((c) => `- ${c}`).join("\n"));
+    return sections.join("\n");
+}