@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.636

package/dist/heart/bridges/manager.js

@@ -1,13 +1,49 @@
 "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.formatBridgeStatus = formatBridgeStatus;
 exports.formatBridgeContext = formatBridgeContext;
 exports.createBridgeManager = createBridgeManager;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
+const config_1 = require("../config");
+const identity_1 = require("../identity");
 const state_machine_1 = require("./state-machine");
 const store_1 = require("./store");
 const turn_coordinator_1 = require("../turn-coordinator");
-const tasks_1 = require("../../repertoire/tasks");
 function defaultIdFactory() {
     return `bridge-${Date.now().toString(36)}`;
 }
@@ -81,23 +117,105 @@ function hasAttachedSessionActivity(bridge, sessionActivity) {
     return sessionActivity.some((activity) => activity.channel !== "inner"
         && bridge.attachedSessions.some((session) => sessionMatches(activity, session)));
 }
-function hasLiveTaskStatus(bridge, taskBoard) {
-    const taskName = bridge.task?.taskName;
-    if (!taskName)
-        return false;
-    return (taskBoard.byStatus.processing.includes(taskName)
-        || taskBoard.byStatus.collaborating.includes(taskName)
-        || taskBoard.byStatus.validating.includes(taskName));
-}
 function isCurrentSessionAttached(bridge, currentSession) {
     if (!currentSession)
         return false;
     return bridge.attachedSessions.some((session) => sessionMatches(session, currentSession));
 }
+// ──────────────────────────────────────────────────────────────────────────────
+// Desk task writer — bridge promotion durably writes a `task.md` under the
+// bundle's `desk/bridges/<slug>/` track so the desk substrate (W6) owns the
+// promoted task. This module deliberately does not depend on
+// `src/repertoire/tasks/` — the task module is being retired in Unit 8c.
+// ──────────────────────────────────────────────────────────────────────────────
+function formatStemTimestamp(now = new Date()) {
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const hours = String(now.getHours()).padStart(2, "0");
+    const minutes = String(now.getMinutes()).padStart(2, "0");
+    return `${year}-${month}-${day}-${hours}${minutes}`;
+}
+function formatDate(now = new Date()) {
+    return now.toISOString().slice(0, 10);
+}
+function formatFrontmatterValue(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return ["[]"];
+        return ["", ...value.map((entry) => `- ${String(entry)}`)];
+    }
+    if (value === null)
+        return ["null"];
+    return [String(value)];
+}
+function renderTaskMarkdown(frontmatter, body) {
+    const lines = ["---"];
+    for (const key of Object.keys(frontmatter)) {
+        const rendered = formatFrontmatterValue(frontmatter[key]);
+        if (rendered.length === 1) {
+            lines.push(`${key}: ${rendered[0]}`);
+        }
+        else {
+            lines.push(`${key}:`);
+            for (const entry of rendered.slice(1)) {
+                lines.push(entry);
+            }
+        }
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(body.trim());
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Default desk-task writer — writes a `task.md` under
+ * `<agentRoot>/desk/bridges/<stem>/task.md` and returns the slug + path.
+ *
+ * The "bridges" track is the home for promoted bridge work; the slug is
+ * `<YYYY-MM-DD-HHMM>-<slugified-title>` to match the timestamped shape used
+ * elsewhere in desk.
+ */
+function defaultWriteDeskTask(input) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "engine.bridge_desk_task_write",
+        component: "engine",
+        message: "writing desk task for promoted bridge",
+        meta: { activeBridge: input.activeBridge },
+    });
+    const now = new Date();
+    const stem = `${formatStemTimestamp(now)}-${(0, config_1.slugify)(input.title).slice(0, 64) || "bridge"}`;
+    const trackDir = path.join((0, identity_1.getAgentRoot)(), "desk", "bridges", stem);
+    const taskPath = path.join(trackDir, "task.md");
+    const today = formatDate(now);
+    const frontmatter = {
+        kind: "task",
+        schema_version: 1,
+        type: "ongoing",
+        category: input.category || "coordination",
+        title: input.title,
+        status: "processing",
+        validator: null,
+        requester: "agent",
+        cadence: null,
+        scheduledAt: null,
+        lastRun: null,
+        created: today,
+        updated: today,
+        artifacts: [],
+        active_bridge: input.activeBridge,
+        bridge_sessions: input.bridgeSessions.filter((value) => typeof value === "string" && value.trim().length > 0),
+    };
+    fs.mkdirSync(trackDir, { recursive: true });
+    fs.writeFileSync(taskPath, renderTaskMarkdown(frontmatter, input.body), "utf-8");
+    return { taskName: stem, path: taskPath };
+}
 function createBridgeManager(options = {}) {
     const store = options.store ?? (0, store_1.createBridgeStore)();
     const now = options.now ?? (() => new Date().toISOString());
     const idFactory = options.idFactory ?? defaultIdFactory;
+    const writeDeskTask = options.writeDeskTask ?? defaultWriteDeskTask;
     function requireBridge(bridgeId) {
         const bridge = store.get(bridgeId);
         if (!bridge) {
@@ -187,9 +305,14 @@ function createBridgeManager(options = {}) {
         },
         reconcileLifecycles(input) {
             return store.list().map((bridge) => {
+                // Unit 8a dropped the legacy task-board read from production callers,
+                // and Unit 8b drops it from the manager surface entirely. Bridges
+                // suspend when no attached session is active and the current session
+                // isn't attached — task-state cross-referencing is no longer part of
+                // the lifecycle reconciliation contract.
                 const nextState = (0, state_machine_1.reconcileBridgeState)(bridge, {
                     hasAttachedSessionActivity: hasAttachedSessionActivity(bridge, input.sessionActivity),
-                    hasLiveTask: hasLiveTaskStatus(bridge, input.taskBoard),
+                    hasLiveTask: false,
                     currentSessionAttached: isCurrentSessionAttached(bridge, input.currentSession),
                 });
                 if (nextState.lifecycle === bridge.lifecycle && nextState.runtime === bridge.runtime) {
@@ -207,21 +330,18 @@ function createBridgeManager(options = {}) {
             assertBridgeMutable(bridge, "promote");
             if (bridge.task)
                 return bridge;
-            const taskPath = (0, tasks_1.getTaskModule)().createTask({
+            const written = writeDeskTask({
                 title: input.title?.trim() || bridge.objective,
-                type: "ongoing",
                 category: input.category?.trim() || "coordination",
-                status: "processing",
                 body: input.body?.trim() || defaultTaskBody(bridge),
                 activeBridge: bridge.id,
                 bridgeSessions: bridge.attachedSessions.map((session) => sessionIdentityKey(session)),
             });
-            const taskName = taskPath.replace(/^.*\//, "").replace(/\.md$/, "");
             const updated = save({
                 ...bridge,
                 task: {
-                    taskName,
-                    path: taskPath,
+                    taskName: written.taskName,
+                    path: written.path,
                     mode: "promoted",
                     boundAt: now(),
                 },
@@ -233,7 +353,7 @@ function createBridgeManager(options = {}) {
                 message: "promoted bridge to task-backed work",
                 meta: {
                     bridgeId,
-                    taskName,
+                    taskName: written.taskName,
                 },
             });
             return updated;

package/dist/heart/bridges/store.js

@@ -38,6 +38,7 @@ exports.createBridgeStore = createBridgeStore;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
+const session_events_1 = require("../session-events");
 const runtime_1 = require("../../nerves/runtime");
 function sessionIdentityMatches(session, candidate) {
     return (session.friendId === candidate.friendId
@@ -58,7 +59,18 @@ function createBridgeStore(options = {}) {
     return {
         save(bridge) {
             ensureRoot();
-            fs.writeFileSync(bridgeFilePath(rootDir, bridge.id), JSON.stringify(bridge, null, 2), "utf-8");
+            const cappedBridge = {
+                ...bridge,
+                objective: (0, session_events_1.capStructuredRecordString)(bridge.objective),
+                summary: (0, session_events_1.capStructuredRecordString)(bridge.summary),
+                attachedSessions: bridge.attachedSessions.map((session) => ({
+                    ...session,
+                    snapshot: typeof session.snapshot === "string"
+                        ? (0, session_events_1.capStructuredRecordString)(session.snapshot)
+                        : session.snapshot,
+                })),
+            };
+            fs.writeFileSync(bridgeFilePath(rootDir, bridge.id), JSON.stringify(cappedBridge, null, 2), "utf-8");
             (0, runtime_1.emitNervesEvent)({
                 component: "engine",
                 event: "engine.bridge_store_save",
@@ -68,7 +80,7 @@ function createBridgeStore(options = {}) {
                     rootDir,
                 },
             });
-            return bridge;
+            return cappedBridge;
         },
         get(id) {
             const filePath = bridgeFilePath(rootDir, id);

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,135 @@
+"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, pendingAwaits) {
+    const committedTo = [];
+    const completionCriteria = [];
+    const safeToIgnore = [];
+    const awaiting = pendingAwaits ? [...pendingAwaits] : [];
+    // 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");
+    }
+    // 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");
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.commitments_derive",
+        message: "derived commitments frame",
+        meta: { committedCount: committedTo.length, criteriaCount: completionCriteria.length, awaitingCount: awaiting.length },
+    });
+    return { committedTo, completionCriteria, safeToIgnore, awaiting };
+}
+function formatRelativeAge(lastCheckedAt, now) {
+    if (!lastCheckedAt)
+        return "never checked";
+    const lastMs = new Date(lastCheckedAt).getTime();
+    if (!Number.isFinite(lastMs))
+        return "never checked";
+    const elapsedMs = now().getTime() - lastMs;
+    if (elapsedMs < 60_000)
+        return "<1m ago";
+    const minutes = Math.floor(elapsedMs / 60_000);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+function formatCommitments(commitments, now = () => new Date()) {
+    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"));
+    const awaiting = commitments.awaiting ?? [];
+    if (awaiting.length > 0) {
+        sections.push("");
+        sections.push("## what i'm waiting on");
+        for (const a of awaiting) {
+            sections.push(`- ${a.name}: ${a.condition}`);
+            const obs = a.lastObservation && a.lastObservation.trim().length > 0
+                ? `: "${a.lastObservation.trim()}"`
+                : "";
+            sections.push(`  (checked ${a.checkedCount}x, last ${formatRelativeAge(a.lastCheckedAt, now)}${obs})`);
+        }
+    }
+    return sections.join("\n");
+}