@ouro.bot/cli 0.1.0-alpha.990 → 0.1.0-alpha.992

package/dist/repertoire/tools-bundle.js

@@ -35,13 +35,14 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bundleToolDefinitions = void 0;
 exports.__getConfirmationTokenStore = __getConfirmationTokenStore;
-exports.isFirstPushToRemote = isFirstPushToRemote;
+exports.probeFirstPush = probeFirstPush;
 /**
  * Agent-callable bundle management tools.
  *
  * These tools let the agent fix its own git state — initializing the
- * bundle as a repo, adding a remote, making the first commit, pushing,
- * and recovering from push rejections. The `bundleState` field in the
+ * bundle as a repo, adding a remote, making the first commit, and syncing
+ * with the remote (bundle_push and bundle_pull_rebase both run the shared
+ * merge-only `syncNow`; neither ever leaves a rebase, a merge or a stash). The `bundleState` field in the
  * start-of-turn packet (PR 5) points the agent at these tools whenever
  * it detects an unresolved git issue.
  *
@@ -57,8 +58,7 @@ exports.isFirstPushToRemote = isFirstPushToRemote;
  * ## Destructive-op refusal pattern (Directive B)
  *
  * Tools that could lose work (bundle_init_git on an existing repo,
- * bundle_add_remote on a configured remote, bundle_pull_rebase with
- * dirty tree, etc.) refuse by default and require an explicit `force`
+ * bundle_add_remote on a configured remote, etc.) refuse by default and require an explicit `force`
  * flag — mirroring Claude Code's `ExitWorktreeTool` safety pattern. The
  * refusal surface is the LLM's responsibility to bridge with the human:
  * when a tool refuses, the agent should ask the user for permission
@@ -169,19 +169,16 @@ const checkSyncStatusHandler = () => {
                 .map((l) => l.trim())
                 .filter((l) => l.length > 0).length;
         }
-        /* v8 ignore start -- upstream tracking ahead/behind requires a live remote, not practical to cover in unit tests @preserve */
         if (hasRemote && firstCommitExists) {
-            // Best-effort ahead/behind from git rev-list if an upstream is tracked.
-            const counts = gitExec(bundleRoot, ["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]);
+            // Against the last fetched sync branch, named explicitly; no upstream config is assumed.
+            const config = bundleSyncConfig(bundleRoot);
+            const counts = gitExec(bundleRoot, ["rev-list", "--left-right", "--count", `HEAD...refs/remotes/${config.remote}/${config.branch}`]);
             if (counts.code === 0) {
                 const [a, b] = counts.stdout.trim().split("\t").map((n) => parseInt(n, 10));
-                if (!Number.isNaN(a) && !Number.isNaN(b)) {
-                    ahead = a;
-                    behind = b;
-                }
+                ahead = a;
+                behind = b;
             }
         }
-        /* v8 ignore stop */
     }
     const pendingSyncExists = fs.existsSync(path.join(bundleRoot, "state", "pending-sync.json"));
     const bundleStateIssues = (0, bundle_state_1.detectBundleState)(bundleRoot);
@@ -645,69 +642,78 @@ function makeFirstPushReviewHandler(deps = {}) {
     };
 }
 const firstPushReviewHandler = makeFirstPushReviewHandler();
-// ─── tool: bundle_push ─────────────────────────────────────────────────
-/* v8 ignore start -- push error classification branches require mocking git stderr from each failure mode; covered by a single network-failure integration test in the suite @preserve */
-function classifyPushError(stderr) {
-    const lower = stderr.toLowerCase();
-    if (lower.includes("rejected") || lower.includes("non-fast-forward") || lower.includes("fetch first"))
-        return "rejected";
-    if (lower.includes("could not resolve") || lower.includes("network") || lower.includes("connection") || lower.includes("timeout"))
-        return "network";
-    if (lower.includes("authentication") || lower.includes("permission denied") || lower.includes("unauthorized") || lower.includes("403"))
-        return "auth";
-    return "unknown";
-}
-/* v8 ignore stop */
 /**
- * Detect whether this is a first push to the remote.
+ * Whether a push to `remote` would be the first push of `branch`: "first" when
+ * the remote has no such branch, "pushed" when it has. The remote is asked
+ * through sync's own ls-remote (the same flags and environment as sync's push,
+ * so in the container it goes through the ouro-sync ssh). A failed ls-remote
+ * is "unreachable", never taken for a first push or for a pushed one.
  *
- * Returns true if the remote branch does not yet exist (bundle has local
- * commits but has never been pushed). Also returns true — conservatively —
- * when git fails to probe the remote (network unreachable, git error).
- * The token requirement is a security gate; if we can't verify the remote
- * state, we assume the worst and force the agent to get confirmation. An
- * unreachable remote should NOT be a bypass vector.
- */
-/**
  * Exported for direct unit testing in bundle-push-first-push.test.ts.
- * The integration tests use unreachable remotes so they always hit the
- * network-failure branch. The unit tests mock child_process to exercise
- * the successful-probe branches (empty stdout = first push, non-empty
- * = subsequent push, symbolic-ref failure = conservative true).
  */
-function isFirstPushToRemote(bundleRoot, remote) {
-    const branchResult = gitExec(bundleRoot, ["symbolic-ref", "--short", "HEAD"]);
-    if (branchResult.code !== 0)
-        return true;
-    const branch = branchResult.stdout.trim();
-    const lsRemote = gitExec(bundleRoot, ["ls-remote", "--heads", remote, branch], 10000);
-    if (lsRemote.code !== 0)
-        return true;
-    return lsRemote.stdout.trim().length === 0;
+async function probeFirstPush(bundleRoot, remote, branch) {
+    const listed = await (0, sync_1.listRemoteRefs)(bundleRoot, remote, [`refs/heads/${branch}`]);
+    if (!listed.ok)
+        return { kind: "unreachable", error: listed.error };
+    return listed.refs.length === 0 ? { kind: "first" } : { kind: "pushed" };
 }
-function makePushHandler(deps = {}) {
-    return (args) => {
+/** How long a bundle tool waits for the bundle sync lock before reporting busy. */
+const BUNDLE_TOOL_SYNC_WAIT_MS = 10_000;
+/** The bundle's sync remote and branch from agent.json: the agent cannot name another remote. */
+function bundleSyncConfig(bundleRoot) {
+    let remote = "origin";
+    let branch = "main";
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(bundleRoot, "agent.json"), "utf-8"));
+        if (typeof parsed.sync?.remote === "string" && parsed.sync.remote.length > 0)
+            remote = parsed.sync.remote;
+        if (typeof parsed.sync?.branch === "string" && parsed.sync.branch.length > 0)
+            branch = parsed.sync.branch;
+    }
+    catch {
+        // No readable agent.json: the defaults.
+    }
+    return { enabled: true, remote, branch };
+}
+/**
+ * Both tools sync the bundle through `syncNow`: commit, fetch, merge, push,
+ * under the bundle lock. A conflict is aborted and recorded by sync itself,
+ * so no tool call leaves a merge, a rebase or a stash behind.
+ */
+function makeSyncHandler(toolName, deps = {}) {
+    return async (args) => {
         const bundleRoot = (0, identity_1.getAgentRoot)();
-        const remote = typeof args.remote === "string" && args.remote.length > 0 ? args.remote : "origin";
         const confirmationToken = typeof args.confirmation_token === "string"
             ? args.confirmation_token
             : undefined;
         const now = deps.now ?? Date.now;
+        const config = bundleSyncConfig(bundleRoot);
+        const remote = config.remote;
         (0, runtime_1.emitNervesEvent)({
             component: "repertoire",
-            event: "repertoire.bundle_push_start",
-            message: "pushing bundle to remote",
-            meta: { bundleRoot, remote },
+            event: "repertoire.bundle_sync_tool_start",
+            message: "syncing bundle from a tool",
+            meta: { bundleRoot, tool: toolName, remote },
         });
         const finish = (ok, payload) => {
             (0, runtime_1.emitNervesEvent)({
                 component: "repertoire",
-                event: "repertoire.bundle_push_end",
-                message: "bundle_push finished",
-                meta: { bundleRoot, ok, ...payload },
+                event: "repertoire.bundle_sync_tool_end",
+                message: "bundle sync tool finished",
+                meta: { bundleRoot, tool: toolName, ok, ...payload },
             });
             return json({ ok, ...payload });
         };
+        const refuse = (message, error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "repertoire",
+                event: "repertoire.bundle_push_refused",
+                message,
+                meta: { bundleRoot, tool: toolName },
+            });
+            return finish(false, { error, kind: "confirmation_required" });
+        };
         if (!isGitRepo(bundleRoot)) {
             return finish(false, { error: "bundle is not a git repo" });
         }
@@ -722,50 +728,22 @@ function makePushHandler(deps = {}) {
         // previously called bundle_first_push_review and obtained a
         // confirmation token. This forces a PII-review gate between
         // "bundle built locally" and "bundle contents on the internet".
-        const isFirstPush = isFirstPushToRemote(bundleRoot, remote);
-        /* v8 ignore next -- the !isFirstPush branch (subsequent push path) requires a reachable remote to test end-to-end; the path itself falls through to the git push below which is covered by the network-failure test @preserve */
+        const probe = await probeFirstPush(bundleRoot, remote, config.branch);
+        if (probe.kind === "unreachable") {
+            return finish(false, { error: `I couldn't reach GitHub to check whether this would be my first push, so I didn't sync: ${probe.error}`, kind: "remote_unreachable" });
+        }
+        const isFirstPush = probe.kind === "first";
         if (isFirstPush) {
             if (!confirmationToken) {
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "repertoire",
-                    event: "repertoire.bundle_push_refused",
-                    message: "bundle_push refused: first push requires confirmation token",
-                    meta: { bundleRoot },
-                });
-                return finish(false, {
-                    error: "refused: first push requires a confirmation token — call bundle_first_push_review, show the warning to the user, and pass the returned confirmationToken to bundle_push",
-                    kind: "confirmation_required",
-                });
+                return refuse(`${toolName} refused: first push requires confirmation token`, `refused: first push requires a confirmation token — call bundle_first_push_review, show the warning to the user, and pass the returned confirmationToken to ${toolName}`);
             }
-            const currentTime = now();
-            pruneExpiredTokens(currentTime);
+            pruneExpiredTokens(now());
             const entry = _confirmationTokens.get(confirmationToken);
             if (!entry) {
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "repertoire",
-                    event: "repertoire.bundle_push_refused",
-                    message: "bundle_push refused: confirmation token invalid or expired",
-                    meta: { bundleRoot },
-                });
-                return finish(false, {
-                    error: "refused: confirmation token invalid or expired — call bundle_first_push_review again",
-                    kind: "confirmation_required",
-                });
+                return refuse(`${toolName} refused: confirmation token invalid or expired`, "refused: confirmation token invalid or expired — call bundle_first_push_review again");
             }
             if (entry.bundleRoot !== bundleRoot) {
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "repertoire",
-                    event: "repertoire.bundle_push_refused",
-                    message: "bundle_push refused: confirmation token bound to a different bundle",
-                    meta: { bundleRoot, tokenBundleRoot: entry.bundleRoot },
-                });
-                return finish(false, {
-                    error: "refused: confirmation token was issued for a different bundle",
-                    kind: "confirmation_required",
-                });
+                return refuse(`${toolName} refused: confirmation token bound to a different bundle`, "refused: confirmation token was issued for a different bundle");
             }
             (0, runtime_1.emitNervesEvent)({
                 component: "repertoire",
@@ -773,95 +751,41 @@ function makePushHandler(deps = {}) {
                 message: "first push confirmed by valid token",
                 meta: { bundleRoot },
             });
-            // One-shot: consume the token on successful validation.
-            _confirmationTokens.delete(confirmationToken);
         }
-        const push = gitExec(bundleRoot, ["push", remote, "HEAD"], 30000);
-        /* v8 ignore start -- push success branch requires a reachable remote, not practical to cover in unit tests; failure branch covered by network-failure test @preserve */
-        if (push.code === 0) {
-            (0, sync_1.clearPendingSync)(bundleRoot);
-            return finish(true, { remote, firstPush: isFirstPush });
+        const agentName = path.basename(bundleRoot).replace(/\.ouro$/, "");
+        // The valid token is the owner's recorded yes, which sync needs before a first push to an empty remote.
+        const result = await (0, sync_1.syncNow)(bundleRoot, config, agentName, BUNDLE_TOOL_SYNC_WAIT_MS, { firstPushApproved: isFirstPush });
+        const where = { remote, branch: config.branch, firstPush: isFirstPush };
+        if (result.paused)
+            return finish(false, { ...where, paused: true, pausedUntil: result.pausedUntil, error: `sync paused until ${result.pausedUntil}` });
+        if (result.busy)
+            return finish(false, { ...where, busy: true, holderPid: result.holderPid, error: result.error });
+        // One-shot: the token is spent once sync actually ran, not on a busy or paused refusal.
+        if (confirmationToken !== undefined && isFirstPush)
+            _confirmationTokens.delete(confirmationToken);
+        if (!result.ok) {
+            const failure = readPendingFailure(bundleRoot);
+            return finish(false, {
+                ...where,
+                error: result.error,
+                ...(failure?.classification ? { kind: failure.classification } : {}),
+                ...(failure?.conflictFiles && failure.conflictFiles.length > 0 ? { conflictFiles: failure.conflictFiles } : {}),
+            });
         }
-        /* v8 ignore stop */
-        const kind = classifyPushError(push.stderr);
-        return finish(false, { error: push.stderr.trim(), kind });
+        return finish(true, where);
     };
 }
-const pushHandler = makePushHandler();
-// ─── tool: bundle_pull_rebase ──────────────────────────────────────────
-const pullRebaseHandler = (args) => {
-    const bundleRoot = (0, identity_1.getAgentRoot)();
-    const remote = typeof args.remote === "string" && args.remote.length > 0 ? args.remote : "origin";
-    const discardChanges = args.discard_changes === "true" || args.discard_changes === true;
-    (0, runtime_1.emitNervesEvent)({
-        component: "repertoire",
-        event: "repertoire.bundle_pull_rebase_start",
-        message: "pulling with rebase",
-        meta: { bundleRoot, remote, discardChanges },
-    });
-    const finish = (ok, payload) => {
-        (0, runtime_1.emitNervesEvent)({
-            component: "repertoire",
-            event: "repertoire.bundle_pull_rebase_end",
-            message: "bundle_pull_rebase finished",
-            meta: { bundleRoot, ok, ...payload },
-        });
-        return json({ ok, ...payload });
-    };
-    if (!isGitRepo(bundleRoot)) {
-        return finish(false, { error: "bundle is not a git repo" });
-    }
-    const remotes = listRemotes(bundleRoot);
-    if (!remotes.includes(remote)) {
-        return finish(false, { error: `remote "${remote}" not configured` });
-    }
-    // Uncommitted changes: refuse unless discard_changes was explicitly set.
-    // Even with discard_changes, we stash+rebase+pop rather than nuke — the
-    // user can manually `git stash drop` if they really want to discard.
-    const status = gitExec(bundleRoot, ["status", "--porcelain"]);
-    const isDirty = status.stdout.trim().length > 0;
-    const stashed = { value: false };
-    if (isDirty) {
-        if (!discardChanges) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                component: "repertoire",
-                event: "repertoire.bundle_pull_rebase_refused",
-                message: "bundle_pull_rebase refused: uncommitted changes",
-                meta: { bundleRoot },
-            });
-            return finish(false, { error: "refused: bundle has uncommitted changes — commit them or pass discard_changes: true (stash+rebase+pop)" });
-        }
-        /* v8 ignore start -- discardChanges=true stash path exercised in a dirty-tree test below but full rebase+pop requires reachable remote @preserve */
-        const stash = gitExec(bundleRoot, ["stash", "push", "-u", "-m", "bundle_pull_rebase stash"]);
-        if (stash.code !== 0) {
-            return finish(false, { error: `git stash failed: ${stash.stderr}` });
-        }
-        stashed.value = true;
-        /* v8 ignore stop */
+/** The pending-sync record sync wrote for this failure, when readable. */
+function readPendingFailure(bundleRoot) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(bundleRoot, "state", "pending-sync.json"), "utf-8"));
     }
-    const rebase = gitExec(bundleRoot, ["pull", "--rebase", remote], 30000);
-    /* v8 ignore start -- rebase success branch requires a reachable remote @preserve */
-    if (rebase.code === 0) {
-        if (stashed.value) {
-            const pop = gitExec(bundleRoot, ["stash", "pop"]);
-            if (pop.code !== 0) {
-                return finish(false, { error: `git stash pop failed after successful rebase: ${pop.stderr}`, kind: "stash_conflict" });
-            }
-        }
-        return finish(true, { remote, stashed: stashed.value });
-    }
-    /* v8 ignore stop */
-    // Capture conflict files if the rebase left us mid-conflict.
-    const conflictStatus = gitExec(bundleRoot, ["status", "--porcelain=v1"]);
-    const conflictFiles = [];
-    for (const line of conflictStatus.stdout.split("\n")) {
-        /* v8 ignore next -- conflict marker extraction requires a real merge conflict, covered indirectly via the network-failure test which returns empty conflictStatus @preserve */
-        if (/^(UU|AA|DD|AU|UA|DU|UD) /.test(line))
-            conflictFiles.push(line.slice(3).trim());
-    }
-    return finish(false, { error: rebase.stderr.trim(), kind: "conflict", conflictFiles });
-};
+    catch {
+        return null;
+    }
+}
+const pushHandler = makeSyncHandler("bundle_push");
+const pullRebaseHandler = makeSyncHandler("bundle_pull_rebase");
 // ─── registry ──────────────────────────────────────────────────────────
 exports.bundleToolDefinitions = [
     {
@@ -946,7 +870,7 @@ exports.bundleToolDefinitions = [
             type: "function",
             function: {
                 name: "bundle_first_push_review",
-                description: "Review my bundle for PII exposure before the first push to a new remote. Enumerates PII-bearing directories (friends, Desk record, Arc, etc.) with per-directory counts, probes the remote URL for GitHub public/private visibility, and returns a first-person warning text I must show the human plus a confirmationToken I must pass to bundle_push on first push. Required before the first push to any new remote.",
+                description: "Review my bundle for PII exposure before the first push to a new remote. Enumerates PII-bearing directories (friends, Desk record, Arc, etc.) with per-directory counts, probes the remote URL for GitHub public/private visibility, and returns a first-person warning text I must show the human plus a confirmationToken I must pass to bundle_push or bundle_pull_rebase on first push. Required before the first push to any new remote.",
                 parameters: { type: "object", properties: {} },
             },
         },
@@ -957,11 +881,10 @@ exports.bundleToolDefinitions = [
             type: "function",
             function: {
                 name: "bundle_push",
-                description: "Push my bundle's HEAD to the configured remote. On first push to a new remote, requires a confirmation_token from bundle_first_push_review (Directive D: human must acknowledge PII exposure before the bundle goes over the wire). Subsequent pushes ignore the token. Returns a structured error with kind: 'rejected' | 'network' | 'auth' | 'unknown' | 'confirmation_required' on failure. Does NOT auto-rebase on rejection — use bundle_pull_rebase explicitly when needed.",
+                description: "Sync my bundle with its remote now.",
                 parameters: {
                     type: "object",
                     properties: {
-                        remote: { type: "string", description: "Remote name. Defaults to 'origin'." },
                         confirmation_token: { type: "string", description: "Opaque token from bundle_first_push_review. Required on the first push to a new remote; ignored on subsequent pushes." },
                     },
                 },
@@ -975,12 +898,11 @@ exports.bundleToolDefinitions = [
             type: "function",
             function: {
                 name: "bundle_pull_rebase",
-                description: "Pull from the remote with --rebase. Refuses on uncommitted changes unless I pass discard_changes: true (stash + rebase + pop, NOT a hard discard). On conflict, returns conflictFiles so I can walk the user through resolution.",
+                description: "Sync my bundle with its remote now.",
                 parameters: {
                     type: "object",
                     properties: {
-                        remote: { type: "string", description: "Remote name. Defaults to 'origin'." },
-                        discard_changes: { type: "boolean", description: "Stash + rebase + pop even if the working tree is dirty. Default false." },
+                        confirmation_token: { type: "string", description: "Opaque token from bundle_first_push_review. Required on the first push to a new remote; ignored on subsequent pushes." },
                     },
                 },
             },
@@ -989,7 +911,7 @@ exports.bundleToolDefinitions = [
         riskProfile: {
             mutates: ["durable_state_write", "external_side_effect"],
             risk: "high",
-            reason: "rebases bundle state from a remote",
+            reason: "syncs bundle state with a remote",
         },
     },
 ];

package/dist/repertoire/tools.js

@@ -86,6 +86,8 @@ exports.SANCTUARY_OWNER_ADDITIONS = new Set([
     "web_search", "search_facts", "consult_diary", "consult_notes", "get_friend_note",
     "session_summary", "query_session", "set_reasoning_effort", "restart_runtime", "revive_sense",
 ]);
+/** The bundle sync tools, granted to the Sanctuary owner alone. */
+const SANCTUARY_OWNER_SYNC_TOOLS = new Set(["bundle_push", "bundle_pull_rebase"]);
 // Re-export types and constants used by the rest of the codebase
 var tools_base_2 = require("./tools-base");
 Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_base_2.tools; } });
@@ -158,7 +160,9 @@ function selectToolsForChannel(capabilities, toolPreferences, _context, provider
             ? [
                 ...tools_base_1.baseToolDefinitions.filter((definition) => SANCTUARY_RELATIONSHIP_BASE_TOOLS.has(definition.tool.function.name)
                     || (ownerLike && exports.SANCTUARY_OWNER_ADDITIONS.has(definition.tool.function.name))),
-                ...tools_unraid_1.unraidToolDefinitions, tools_steward_policy_1.stewardPolicyToolDefinition, ...(ownerLike ? tools_house_care_1.houseCareToolDefinitions : []), ...(ownerLike ? mcp : []),
+                ...tools_unraid_1.unraidToolDefinitions, tools_steward_policy_1.stewardPolicyToolDefinition, ...(ownerLike ? tools_house_care_1.houseCareToolDefinitions : []),
+                ...(owner ? tools_bundle_1.bundleToolDefinitions.filter((definition) => SANCTUARY_OWNER_SYNC_TOOLS.has(definition.tool.function.name)) : []),
+                ...(ownerLike ? mcp : []),
             ]
             : [];
     }

package/dist/senses/pipeline.js

@@ -40,6 +40,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitObligationTransitionEpisodes = emitObligationTransitionEpisodes;
 exports.selectCheckpointCurrentAsk = selectCheckpointCurrentAsk;
+exports.startPostTurnSync = startPostTurnSync;
 exports.handleInboundTurn = handleInboundTurn;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -500,6 +501,37 @@ function prepareInboundRunLedger(input) {
         return null;
     }
 }
+/**
+ * Commit the turn's edits now, then let the push run without awaiting it, so
+ * the reply is not held for the network. A later edit is not in this commit;
+ * the next turn commits it whole.
+ */
+function startPostTurnSync(agentRoot, config) {
+    let result;
+    try {
+        result = (0, sync_1.postTurnPush)(agentRoot, config);
+    }
+    catch (err) {
+        // In the turn's `finally`: a throw here would replace the turn's result.
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.post_turn_sync_error",
+            message: "post-turn sync threw",
+            meta: { agentRoot, error: err instanceof Error ? err.message : String(err) },
+        });
+        return;
+    }
+    result.push?.catch((err) => {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.post_turn_push_rejected",
+            message: "post-turn push rejected",
+            meta: { agentRoot, error: err instanceof Error ? err.message : String(err) },
+        });
+    });
+}
 async function handleInboundTurn(input) {
     return (0, turn_execution_lease_1.withTurnExecutionLease)(() => handleInboundTurnExclusive(input));
 }
@@ -773,7 +805,7 @@ async function handleInboundTurnExclusive(input) {
     try {
         /* v8 ignore start -- sync-enabled branches tested in sync.test.ts, pipeline tests mock at module boundary @preserve */
         if (syncConfig.enabled && !liveLatencyMode) {
-            const pullResult = (0, sync_1.preTurnPull)((0, identity_1.getAgentRoot)(), syncConfig);
+            const pullResult = await (0, sync_1.preTurnPull)((0, identity_1.getAgentRoot)(), syncConfig);
             if (!pullResult.ok) {
                 syncFailure = pullResult.error;
             }
@@ -1253,9 +1285,11 @@ async function handleInboundTurnExclusive(input) {
         };
     }
     finally {
-        // Step 6b: Post-turn sync push (opt-in, git-status-based discovery).
+        // Step 6b: Post-turn sync (opt-in). The commit is synchronous, so the
+        // turn's edits are recorded before the reply goes out; the push runs on
+        // without being awaited, holding the lock, and records its own failure.
         if (syncConfig.enabled && !liveLatencyMode && !declinedForHome) {
-            (0, sync_1.postTurnPush)((0, identity_1.getAgentRoot)(), syncConfig);
+            startPostTurnSync((0, identity_1.getAgentRoot)(), syncConfig);
         }
     }
 }

package/dist/senses/private-runtime.js

@@ -224,12 +224,7 @@ async function resolveRelationshipAwaitAuthority(agentRoot, store, registry, coo
     return { authorization, friend };
 }
 function readAspirations(agentRoot) {
-    try {
-        return fs.readFileSync(path.join(agentRoot, "psyche", "ASPIRATIONS.md"), "utf8").trim();
-    }
-    catch {
-        return "";
-    }
+    return (0, prompt_1.loadPsycheAt)(agentRoot).aspirations;
 }
 function loadPrivateRuntimeInstincts() {
     return [...DEFAULT_PRIVATE_RUNTIME_INSTINCTS];

package/dist/senses/voice/twilio-phone.js

@@ -52,6 +52,7 @@ exports.computeOpenAIWebhookSignature = computeOpenAIWebhookSignature;
 exports.validateOpenAIWebhookSignature = validateOpenAIWebhookSignature;
 exports.tonesOnly = tonesOnly;
 exports.parseToolArguments = parseToolArguments;
+exports.voicePsycheExcerpts = voicePsycheExcerpts;
 exports.computeTwilioSignature = computeTwilioSignature;
 exports.validateTwilioSignature = validateTwilioSignature;
 exports.twilioRecordingMediaUrl = twilioRecordingMediaUrl;
@@ -69,6 +70,7 @@ const http = __importStar(require("http"));
 const path = __importStar(require("path"));
 const ws_1 = require("ws");
 const context_1 = require("../../mind/context");
+const prompt_1 = require("../../mind/prompt");
 const friends_1 = require("@ouro.bot/friends");
 const identity_1 = require("../../heart/identity");
 const mcp_manager_1 = require("../../repertoire/mcp-manager");
@@ -1601,24 +1603,22 @@ function looksLikeShortHumanPhoneGreeting(transcript) {
         return false;
     return /^(hi|hello|hey|yo|yes|yeah|yep)(\b|$)/.test(text);
 }
-async function readOptionalText(filePath, maxChars) {
-    try {
-        const text = (await fs.readFile(filePath, "utf8")).trim();
-        if (text.length <= maxChars)
-            return text;
-        return `${text.slice(0, maxChars).trim()}\n[truncated for low-latency voice]`;
-    }
-    catch {
-        return "";
-    }
+function capVoiceText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars).trim()}\n[truncated for low-latency voice]`;
+}
+/** The psyche excerpts the live voice prompt carries, read through the shared psyche loader and capped for latency. */
+function voicePsycheExcerpts(agentRoot) {
+    const psyche = (0, prompt_1.loadPsycheAt)(agentRoot);
+    return {
+        soul: capVoiceText(psyche.soul, 1_600),
+        identity: capVoiceText(psyche.identity, 3_200),
+        tacit: capVoiceText(psyche.tacitKnowledge, 1_400),
+    };
 }
 async function buildRealtimeVoiceInstructions(options) {
-    const psycheDir = path.join(options.agentRoot, "psyche");
-    const [soul, identity, tacit] = await Promise.all([
-        readOptionalText(path.join(psycheDir, "SOUL.md"), 1_600),
-        readOptionalText(path.join(psycheDir, "IDENTITY.md"), 3_200),
-        readOptionalText(path.join(psycheDir, "TACIT.md"), 1_400),
-    ]);
+    const { soul, identity, tacit } = voicePsycheExcerpts(options.agentRoot);
     return [
         `You are ${options.agentName} in the live Voice sense.`,
         "This is the same agent identity as every other Ouro surface. Voice is not a reduced or alternate self.",

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.990",
+  "version": "0.1.0-alpha.992",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.990",
+      "version": "0.1.0-alpha.992",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.990",
+  "version": "0.1.0-alpha.992",
   "engines": {
     "node": ">=22"
   },