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

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_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.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."
+      ]
+    },
     {
       "version": "0.1.0-alpha.280",
       "changes": [

package/dist/heart/bundle-state.js

@@ -0,0 +1,147 @@
+"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 the subset that's detectable purely
+ * from bundle state:
+ *
+ *   - `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.
+ *
+ * Future extensions (deferred to a follow-up PR):
+ *   - `remote_push_failed` / `pull_rebase_conflict`: derived from the
+ *     `classification` field of pending-sync.json once sync.ts writes it.
+ */
+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 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).
+    const pendingSyncPath = path.join(agentRoot, "state", "pending-sync.json");
+    if (exists(pendingSyncPath)) {
+        issues.push("pending_sync_exists");
+    }
+    (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" memory 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",
+    };
+    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/start-of-turn-packet.js

@@ -40,6 +40,7 @@ exports.renderCompactStartOfTurnPacket = renderCompactStartOfTurnPacket;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
+const bundle_state_1 = require("./bundle-state");
 const tempo_1 = require("./tempo");
 function estimateTokens(text) {
     return Math.ceil(text.length / 4);
@@ -222,6 +223,11 @@ function renderStartOfTurnPacket(packet) {
     // Assemble sections in priority order (highest priority first for budget allocation)
     // Each section is { label, content, priority } where lower priority number = truncated first
     const sections = [
+        // bundleState and syncFailure share the top remediation tier — both
+        // are actionable "fix your git" signals. bundleState is preferred
+        // because it's structured (array of enum values) while syncFailure is
+        // a legacy free-form string; both render when populated.
+        { label: "bundleState", content: (0, bundle_state_1.renderBundleStateHint)(packet.bundleState ?? []), priority: 7 },
         { label: "syncFailure", content: packet.syncFailure ?? "", priority: 7 },
         { label: "resume", content: packet.resumeHint, priority: 6 },
         { label: "obligations", content: packet.obligations, priority: 5 },
@@ -294,6 +300,9 @@ function formatSections(sections) {
             case "syncFailure":
                 parts.push(`**Sync warning:** ${section.content}`);
                 break;
+            case "bundleState":
+                parts.push(`**Bundle:** ${section.content}`);
+                break;
         }
     }
     return parts.join("\n\n");

package/dist/senses/pipeline.js

@@ -57,6 +57,7 @@ const auth_flow_1 = require("../heart/auth/auth-flow");
 const tempo_1 = require("../heart/tempo");
 const temporal_view_1 = require("../heart/temporal-view");
 const start_of_turn_packet_1 = require("../heart/start-of-turn-packet");
+const bundle_state_1 = require("../heart/bundle-state");
 const sync_1 = require("../heart/sync");
 const config_1 = require("../heart/config");
 const presence_1 = require("../arc/presence");
@@ -388,6 +389,13 @@ async function handleInboundTurn(input) {
             if (syncFailure) {
                 startOfTurnPacket.syncFailure = syncFailure;
             }
+            // Structured bundle state detection — surfaces discrete issues the
+            // agent can remediate via the bundle_* tools. Runs independently of
+            // syncFailure so the two signals coexist during the transition away
+            // from the legacy free-form syncFailure string. Always assigned; the
+            // packet renderer's empty-filter handles the empty-array case without
+            // a separate branch here.
+            startOfTurnPacket.bundleState = (0, bundle_state_1.detectBundleState)(agentRoot);
             const capabilities = (0, start_of_turn_packet_1.buildCapabilitiesSection)(agentRoot);
             if (capabilities) {
                 startOfTurnPacket.capabilities = capabilities;

package/package.json

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