@ouro.bot/cli 0.1.0-alpha.66 → 0.1.0-alpha.661

package/dist/mind/friends/resolver.js

@@ -1,13 +1,48 @@
 "use strict";
 // FriendResolver -- resolves external identity into a FriendRecord + channel capabilities.
 // Created per-request (per-incoming-message), per-friend.
-// Replaces the old ContextResolver: no authority checker, no separate memory resolution.
+// Replaces the old ContextResolver: no authority checker, no separate note resolution.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FriendResolver = void 0;
+exports._setMachineOwnerUsernameForTest = _setMachineOwnerUsernameForTest;
+exports.machineOwnerUsername = machineOwnerUsername;
+exports.isLocalMachineOwnerIdentity = isLocalMachineOwnerIdentity;
 const crypto_1 = require("crypto");
+const os_1 = require("os");
 const channel_1 = require("./channel");
 const runtime_1 = require("../../nerves/runtime");
 const CURRENT_SCHEMA_VERSION = 1;
+// Test seam: when set (including to null), overrides OS detection of the
+// machine-owner username so resolver tests are deterministic.
+let machineOwnerOverride;
+function _setMachineOwnerUsernameForTest(value) {
+    machineOwnerOverride = value;
+}
+/**
+ * The OS username that owns this daemon process, or null if undetectable. The
+ * person running the daemon owns this agent + its bundle, so the local friend
+ * that names them is the machine owner (family), not a stranger.
+ */
+function machineOwnerUsername() {
+    if (machineOwnerOverride !== undefined)
+        return machineOwnerOverride;
+    try {
+        return (0, os_1.userInfo)().username;
+    }
+    catch {
+        /* v8 ignore next -- defensive: userInfo() only throws when the running user has no passwd entry @preserve */
+        return null;
+    }
+}
+/**
+ * True when (provider, externalId) names the local machine owner — the OS user
+ * running the daemon. Matches the bare username or a `user@host` external id.
+ */
+function isLocalMachineOwnerIdentity(provider, externalId, ownerUsername) {
+    if (provider !== "local" || !ownerUsername)
+        return false;
+    return externalId === ownerUsername || externalId.startsWith(`${ownerUsername}@`);
+}
 class FriendResolver {
     store;
     params;
@@ -31,6 +66,43 @@ class FriendResolver {
         }
         if (existing)
             return existing;
+        // Migration: local provider previously used "${username}@${hostname}" format.
+        // If no exact match, try finding a friend with old-format external ID.
+        /* v8 ignore start -- migration path: only fires when legacy hostname-format friend exists @preserve */
+        if (this.params.provider === "local" && !this.params.externalId.includes("@")) {
+            try {
+                const all = typeof this.store.listAll === "function" ? await this.store.listAll() : [];
+                /* v8 ignore start -- migration path: only fires when legacy hostname-format friend exists @preserve */
+                const migrationMatch = all.find((f) => f.externalIds.some((eid) => eid.provider === "local" && eid.externalId.startsWith(this.params.externalId + "@")));
+                if (migrationMatch) {
+                    const now = new Date().toISOString();
+                    migrationMatch.externalIds.push({
+                        provider: this.params.provider,
+                        externalId: this.params.externalId,
+                        linkedAt: now,
+                    });
+                    migrationMatch.updatedAt = now;
+                    try {
+                        await this.store.put(migrationMatch.id, migrationMatch);
+                    }
+                    catch {
+                        // best-effort persist
+                    }
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "friends",
+                        event: "friends.local_id_migrated",
+                        message: `migrated local friend identity from hostname format to username-only`,
+                        meta: { friendId: migrationMatch.id, newExternalId: this.params.externalId },
+                    });
+                    return migrationMatch;
+                }
+                /* v8 ignore stop */
+            }
+            catch {
+                // fall through to create new
+            }
+        }
+        /* v8 ignore stop */
         // First encounter -- create new FriendRecord
         const now = new Date().toISOString();
         const externalId = {
@@ -50,20 +122,51 @@ class FriendResolver {
             hasAnyFriends = false;
         }
         const isFirstImprint = !hasAnyFriends;
+        const isA2AAgent = this.params.provider === "a2a-agent";
+        // The local friend that names the OS user running the daemon is the machine
+        // owner (family) — they own the agent + its bundle. Usually this friend already
+        // exists as a family/primary hatch imprint; this covers the un-imprinted boss
+        // path (e.g. a Workbench boss check-in on a bundle that skipped imprint).
+        const isLocalMachineOwner = isLocalMachineOwnerIdentity(this.params.provider, this.params.externalId, machineOwnerUsername());
+        // BlueBubbles group chats route through here as `imessage-handle` with an
+        // externalId of the form `group:any;+;<chatHash>`. When the harness auto-
+        // creates the group friend at stranger trust, we mark the record so that
+        // the trust gate can surface the relationship for explicit acknowledgment
+        // later instead of letting messages accumulate silently.
+        const isImessageGroup = this.params.provider === "imessage-handle" &&
+            typeof this.params.externalId === "string" &&
+            this.params.externalId.startsWith("group:");
+        const notes = {};
+        if (this.params.displayName !== "Unknown") {
+            notes.name = { value: this.params.displayName, savedAt: now };
+        }
+        if (isImessageGroup && !isFirstImprint) {
+            notes.autoCreatedGroup = { value: "true", savedAt: now };
+        }
         const friend = {
             id: (0, crypto_1.randomUUID)(),
             name: this.params.displayName,
-            role: isFirstImprint ? "primary" : "stranger",
-            trustLevel: isFirstImprint ? "family" : "stranger",
+            role: isA2AAgent ? "agent-peer" : isFirstImprint ? "primary" : isLocalMachineOwner ? "family" : "stranger",
+            trustLevel: isA2AAgent ? "stranger" : (isFirstImprint || isLocalMachineOwner) ? "family" : "stranger",
             connections: [],
             externalIds: [externalId],
             tenantMemberships,
             toolPreferences: {},
-            notes: this.params.displayName !== "Unknown" ? { name: { value: this.params.displayName, savedAt: now } } : {},
+            notes,
             totalTokens: 0,
             createdAt: now,
             updatedAt: now,
             schemaVersion: CURRENT_SCHEMA_VERSION,
+            kind: isA2AAgent ? "agent" : "human",
+            ...(isA2AAgent ? {
+                agentMeta: {
+                    bundleName: this.params.displayName,
+                    familiarity: 0,
+                    sharedMissions: [],
+                    outcomes: [],
+                    a2a: { agentId: this.params.externalId },
+                },
+            } : {}),
         };
         // Persist -- log and continue on failure (D16)
         try {

package/dist/mind/friends/store-file.js

@@ -39,6 +39,7 @@ exports.FileFriendStore = void 0;
 const fs = __importStar(require("fs"));
 const fsPromises = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
+const session_events_1 = require("../../heart/session-events");
 const runtime_1 = require("../../nerves/runtime");
 const DEFAULT_ROLE = "friend";
 const DEFAULT_TRUST_LEVEL = "friend";
@@ -55,10 +56,29 @@ class FileFriendStore {
         });
     }
     async get(id) {
+        // Direct UUID lookup
         const record = await this.readJson(path.join(this.friendsPath, `${id}.json`));
-        if (!record)
-            return null;
-        return this.normalize(record);
+        if (record)
+            return this.normalize(record);
+        // Fallback: if id is a name (not UUID), scan for matching friend
+        /* v8 ignore start -- name fallback: exercised by live proactive sends @preserve */
+        try {
+            const entries = await fsPromises.readdir(this.friendsPath);
+            for (const entry of entries) {
+                if (!entry.endsWith(".json"))
+                    continue;
+                const raw = await this.readJson(path.join(this.friendsPath, entry));
+                if (!raw)
+                    continue;
+                const normalized = this.normalize(raw);
+                if (normalized.name?.toLowerCase() === id.toLowerCase()) {
+                    return normalized;
+                }
+            }
+        }
+        catch { /* directory unreadable — return null */ }
+        /* v8 ignore stop */
+        return null;
     }
     async put(id, record) {
         await this.writeJson(path.join(this.friendsPath, `${id}.json`), this.normalize(record));
@@ -127,6 +147,8 @@ class FileFriendStore {
             trustLevel === "stranger"
             ? trustLevel
             : DEFAULT_TRUST_LEVEL;
+        const kind = raw.kind === "human" || raw.kind === "agent" ? raw.kind : "human";
+        const agentMeta = kind === "agent" ? this.normalizeAgentMeta(raw.agentMeta) : undefined;
         return {
             id: raw.id,
             name: raw.name,
@@ -153,7 +175,35 @@ class FileFriendStore {
             createdAt: typeof raw.createdAt === "string" ? raw.createdAt : new Date().toISOString(),
             updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : new Date().toISOString(),
             schemaVersion: typeof raw.schemaVersion === "number" ? raw.schemaVersion : 1,
+            kind,
+            agentMeta,
+        };
+    }
+    normalizeAgentMeta(raw) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const meta = raw;
+        if (typeof meta.bundleName !== "string")
+            return undefined;
+        return {
+            bundleName: meta.bundleName,
+            familiarity: typeof meta.familiarity === "number" ? meta.familiarity : 0,
+            sharedMissions: Array.isArray(meta.sharedMissions) ? meta.sharedMissions : [],
+            outcomes: Array.isArray(meta.outcomes) ? meta.outcomes : [],
+            ...(this.normalizeA2AMeta(meta.a2a) ? { a2a: this.normalizeA2AMeta(meta.a2a) } : {}),
+        };
+    }
+    normalizeA2AMeta(raw) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return undefined;
+        const meta = raw;
+        const a2a = {
+            ...(typeof meta.cardUrl === "string" ? { cardUrl: meta.cardUrl } : {}),
+            ...(typeof meta.endpointUrl === "string" ? { endpointUrl: meta.endpointUrl } : {}),
+            ...(typeof meta.agentId === "string" ? { agentId: meta.agentId } : {}),
+            ...(typeof meta.protocolVersion === "string" ? { protocolVersion: meta.protocolVersion } : {}),
         };
+        return Object.keys(a2a).length > 0 ? a2a : undefined;
     }
     async readJson(filePath) {
         try {
@@ -174,7 +224,14 @@ class FileFriendStore {
         }
     }
     async writeJson(filePath, data) {
-        await fsPromises.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+        const notes = Object.fromEntries(Object.entries(data.notes).map(([key, note]) => [
+            key,
+            {
+                ...note,
+                value: (0, session_events_1.capStructuredRecordString)(note.value),
+            },
+        ]));
+        await fsPromises.writeFile(filePath, JSON.stringify({ ...data, notes }, null, 2), "utf-8");
     }
     async removeFile(filePath) {
         try {

package/dist/mind/friends/types.js

@@ -1,13 +1,13 @@
 "use strict";
 // Context kernel type definitions.
-// FriendRecord (merged identity + memory), channel capabilities, and resolved context.
+// FriendRecord (merged identity + notes), channel capabilities, and resolved context.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRUSTED_LEVELS = void 0;
 exports.isIdentityProvider = isIdentityProvider;
 exports.isIntegration = isIntegration;
 exports.isTrustedLevel = isTrustedLevel;
 const runtime_1 = require("../../nerves/runtime");
-const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle"]);
+const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle", "email-address", "a2a-agent"]);
 function isIdentityProvider(value) {
     (0, runtime_1.emitNervesEvent)({
         component: "friends",

package/dist/mind/{associative-recall.js → note-search.js}

@@ -34,54 +34,25 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cosineSimilarity = cosineSimilarity;
-exports.recallFactsForQuery = recallFactsForQuery;
-exports.injectAssociativeRecall = injectAssociativeRecall;
+exports.searchDiaryFactsForQuery = searchDiaryFactsForQuery;
+exports.injectNoteSearchContext = injectNoteSearchContext;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const config_1 = require("../heart/config");
-const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
-const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+const diary_1 = require("./diary");
+const provenance_trust_1 = require("./provenance-trust");
+const embedding_provider_1 = require("./embedding-provider");
 const DEFAULT_MIN_SCORE = 0.5;
 const DEFAULT_TOP_K = 3;
-class OpenAIEmbeddingProvider {
-    apiKey;
-    model;
-    constructor(apiKey, model = DEFAULT_EMBEDDING_MODEL) {
-        this.apiKey = apiKey;
-        this.model = model;
-    }
-    async embed(texts) {
-        const response = await fetch("https://api.openai.com/v1/embeddings", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                model: this.model,
-                input: texts,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`embedding request failed: ${response.status} ${response.statusText}`);
-        }
-        const payload = (await response.json());
-        if (!payload.data || payload.data.length !== texts.length) {
-            throw new Error("embedding response missing expected vectors");
-        }
-        return payload.data.map((entry) => entry.embedding);
-    }
-}
 function createDefaultProvider() {
-    const apiKey = (0, config_1.getOpenAIEmbeddingsApiKey)();
-    if (!apiKey) {
+    const provider = (0, embedding_provider_1.createDefaultEmbeddingProvider)();
+    if (!provider) {
         throw new Error("openaiEmbeddingsApiKey not configured");
     }
-    return new OpenAIEmbeddingProvider(apiKey);
+    return provider;
 }
-function readFacts(memoryRoot) {
-    const factsPath = path.join(memoryRoot, "facts.jsonl");
+function readFacts(diaryRoot) {
+    const factsPath = path.join(diaryRoot, "facts.jsonl");
     if (!fs.existsSync(factsPath))
         return [];
     const raw = fs.readFileSync(factsPath, "utf8").trim();
@@ -129,7 +100,7 @@ function cosineSimilarity(left, right) {
         return 0;
     return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
 }
-async function recallFactsForQuery(query, facts, provider, options) {
+async function searchDiaryFactsForQuery(query, facts, provider, options) {
     const trimmed = query.trim();
     if (!trimmed)
         return [];
@@ -145,62 +116,80 @@ async function recallFactsForQuery(query, facts, provider, options) {
         .sort((left, right) => right.score - left.score)
         .slice(0, topK);
 }
-async function injectAssociativeRecall(messages, options) {
+async function injectNoteSearchContext(messages, options) {
     try {
         if (messages[0]?.role !== "system" || typeof messages[0].content !== "string")
             return;
         const query = getLatestUserText(messages);
         if (!query)
             return;
-        const memoryRoot = options?.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
-        const facts = readFacts(memoryRoot);
+        const diaryRoot = options?.diaryRoot ?? (0, diary_1.resolveDiaryRoot)();
+        const facts = readFacts(diaryRoot);
         if (facts.length === 0)
             return;
-        let recalled;
+        const resultLines = [];
+        let found;
         try {
             const provider = options?.provider ?? createDefaultProvider();
-            recalled = await recallFactsForQuery(query, facts, provider, options);
+            found = await searchDiaryFactsForQuery(query, facts, provider, options);
         }
         catch {
             // Embeddings unavailable — fall back to substring matching
             const lowerQuery = query.toLowerCase();
             const topK = options?.topK ?? DEFAULT_TOP_K;
-            recalled = facts
+            found = facts
                 .filter((fact) => fact.text.toLowerCase().includes(lowerQuery))
                 .slice(0, topK)
                 .map((fact) => ({ ...fact, score: 1 }));
-            if (recalled.length > 0) {
+            if (found.length > 0) {
                 (0, runtime_1.emitNervesEvent)({
                     level: "warn",
                     component: "mind",
-                    event: "mind.associative_recall_fallback",
+                    event: "mind.note_search_fallback",
                     message: "embeddings unavailable, used substring fallback",
-                    meta: { matchCount: recalled.length },
+                    meta: { matchCount: found.length },
                 });
             }
         }
-        if (recalled.length === 0)
+        for (const fact of found) {
+            let meta = `score=${fact.score.toFixed(3)} source=${fact.source}`;
+            if (fact.provenance) {
+                if (fact.provenance.channel)
+                    meta += ` channel=${fact.provenance.channel}`;
+                if (fact.provenance.friendName)
+                    meta += ` friend=${fact.provenance.friendName}`;
+                if (fact.provenance.trust)
+                    meta += ` trust=${fact.provenance.trust}`;
+            }
+            const tag = (0, provenance_trust_1.classifyProvenanceTrust)(fact.provenance) === "external" ? "diary/external" : "diary";
+            resultLines.push({
+                text: `[${tag}] ${fact.text} [${meta}]`,
+                score: fact.score,
+            });
+        }
+        if (resultLines.length === 0)
             return;
-        const recallSection = recalled
-            .map((fact, index) => `${index + 1}. ${fact.text} [score=${fact.score.toFixed(3)} source=${fact.source}]`)
+        resultLines.sort((left, right) => right.score - left.score);
+        const noteSection = resultLines
+            .map((entry, index) => `${index + 1}. ${entry.text}`)
             .join("\n");
         messages[0] = {
             role: "system",
-            content: `${messages[0].content}\n\n## recalled context\n${recallSection}`,
+            content: `${messages[0].content}\n\n## retrieved from my Desk record diary\n${noteSection}`,
         };
         (0, runtime_1.emitNervesEvent)({
             component: "mind",
-            event: "mind.associative_recall",
-            message: "associative recall injected",
-            meta: { count: recalled.length },
+            event: "mind.note_search_context",
+            message: "note search injected",
+            meta: { count: resultLines.length },
         });
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             component: "mind",
-            event: "mind.associative_recall_error",
-            message: "associative recall failed",
+            event: "mind.note_search_context_error",
+            message: "note search failed",
             meta: {
                 reason: error instanceof Error ? error.message : /* v8 ignore start -- defensive: non-Error catch branch @preserve */ String(error) /* v8 ignore stop */,
             },

package/dist/mind/obligation-steering.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findActivePersistentObligation = findActivePersistentObligation;
+exports.findStatusObligation = findStatusObligation;
+exports.renderActiveObligationSteering = renderActiveObligationSteering;
+exports.renderConcreteStatusGuidance = renderConcreteStatusGuidance;
+exports.renderLiveThreadStatusShape = renderLiveThreadStatusShape;
+exports.buildExactStatusReply = buildExactStatusReply;
+exports.renderExactStatusReplyContract = renderExactStatusReplyContract;
+const config_1 = require("../heart/config");
+const active_work_1 = require("../heart/active-work");
+const runtime_1 = require("../nerves/runtime");
+function findActivePersistentObligation(frame) {
+    if (!frame)
+        return null;
+    return (frame.pendingObligations ?? []).find((ob) => ob.status !== "pending" && ob.status !== "fulfilled") ?? null;
+}
+function obligationTimestampMs(obligation) {
+    return Date.parse(obligation.updatedAt ?? obligation.createdAt);
+}
+function newestObligationFirst(left, right) {
+    return obligationTimestampMs(right) - obligationTimestampMs(left);
+}
+function matchesCurrentSession(frame, obligation) {
+    return matchesSessionOrigin(frame, obligation.origin);
+}
+function matchesSessionOrigin(frame, origin) {
+    return Boolean(frame.currentSession
+        && origin.friendId === frame.currentSession.friendId
+        && origin.channel === frame.currentSession.channel
+        && (0, config_1.sanitizeKey)(origin.key) === (0, config_1.sanitizeKey)(frame.currentSession.key));
+}
+function findStatusObligation(frame) {
+    if (!frame)
+        return null;
+    const openObligations = [...(frame.pendingObligations ?? [])]
+        .filter((obligation) => obligation.status !== "fulfilled")
+        .sort(newestObligationFirst);
+    const sameSession = openObligations.find((obligation) => matchesCurrentSession(frame, obligation));
+    if (sameSession)
+        return sameSession;
+    return openObligations[0] ?? null;
+}
+function findCurrentSessionStatusObligation(frame) {
+    const openObligations = [...(frame.pendingObligations ?? [])]
+        .filter((obligation) => obligation.status !== "fulfilled")
+        .sort(newestObligationFirst);
+    return openObligations.find((obligation) => matchesCurrentSession(frame, obligation)) ?? null;
+}
+function renderActiveObligationSteering(obligation) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.obligation_steering_rendered",
+        message: "rendered active obligation steering",
+        meta: {
+            hasObligation: Boolean(obligation),
+            hasSurface: Boolean(obligation?.currentSurface?.label),
+        },
+    });
+    if (!obligation)
+        return "";
+    const name = obligation.origin.friendId;
+    const surfaceLine = obligation.currentSurface?.label
+        ? `\nright now that work is happening in ${obligation.currentSurface.label}.`
+        : "";
+    return `## where my attention is
+i'm already working on something i owe ${name}.${surfaceLine}
+
+i should close that loop before i act like this is a fresh blank turn.`;
+}
+function mergeArtifactFallback(obligation) {
+    const trimmed = obligation.content.trim();
+    if (!trimmed)
+        return "the fix";
+    const stripped = trimmed.replace(/^merge(?:\s+|$)/i, "").trim();
+    return stripped || "the fix";
+}
+function formatMergeArtifact(obligation) {
+    const currentArtifact = obligation.currentArtifact?.trim();
+    if (currentArtifact)
+        return currentArtifact;
+    if (obligation.currentSurface?.kind === "merge") {
+        const surfaceLabel = obligation.currentSurface.label.trim();
+        if (surfaceLabel)
+            return surfaceLabel;
+    }
+    return mergeArtifactFallback(obligation);
+}
+function formatActiveLane(frame, obligation) {
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession) {
+        const sameThread = frame.currentSession
+            && liveCodingSession.originSession
+            && liveCodingSession.originSession.friendId === frame.currentSession.friendId
+            && liveCodingSession.originSession.channel === frame.currentSession.channel
+            && liveCodingSession.originSession.key === frame.currentSession.key;
+        return sameThread
+            ? `${liveCodingSession.runner} ${liveCodingSession.id} for this same thread`
+            : liveCodingSession.originSession
+                ? `${liveCodingSession.runner} ${liveCodingSession.id} for ${liveCodingSession.originSession.channel}/${liveCodingSession.originSession.key}`
+                : `${liveCodingSession.runner} ${liveCodingSession.id}`;
+    }
+    return obligation.currentSurface?.label
+        || (matchesCurrentSession(frame, obligation) ? "this same thread" : "this live loop");
+}
+function formatCurrentArtifact(frame, obligation) {
+    if (obligation?.currentArtifact)
+        return obligation.currentArtifact;
+    if (obligation?.currentSurface?.kind === "merge")
+        return obligation.currentSurface.label;
+    if ((frame.codingSessions ?? []).length > 0)
+        return "no PR or merge artifact yet";
+    return obligation ? "no artifact yet" : "";
+}
+function formatNextAction(frame, obligation) {
+    const obligationHasConcreteArtifact = Boolean(obligation?.currentArtifact?.trim())
+        || obligation?.currentSurface?.kind === "merge";
+    if (obligation?.status === "waiting_for_merge") {
+        return obligation.nextAction?.trim() || `wait for checks, merge ${formatMergeArtifact(obligation)}, then update runtime`;
+    }
+    if (obligation?.status === "updating_runtime") {
+        return obligation.nextAction?.trim() || "update runtime, verify version/changelog, then re-observe";
+    }
+    if (obligationHasConcreteArtifact && obligation?.nextAction?.trim()) {
+        return obligation.nextAction.trim();
+    }
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession?.status === "waiting_input") {
+        return `answer ${liveCodingSession.runner} ${liveCodingSession.id} and continue`;
+    }
+    if (liveCodingSession?.status === "stalled") {
+        return `unstick ${liveCodingSession.runner} ${liveCodingSession.id} and continue`;
+    }
+    if (liveCodingSession) {
+        return "finish the coding pass and bring the result back here";
+    }
+    if (obligation?.nextAction?.trim())
+        return obligation.nextAction.trim();
+    if (obligation?.content?.trim()) {
+        return `work on "${obligation.content.trim()}" and bring back a concrete artifact`;
+    }
+    return obligation ? "continue the active loop and bring the result back here" : "";
+}
+function renderConcreteStatusGuidance(frame, obligation) {
+    const activeLane = obligation ? formatActiveLane(frame, obligation) : "";
+    const currentArtifact = formatCurrentArtifact(frame, obligation);
+    const nextAction = formatNextAction(frame, obligation);
+    const liveConversation = frame.currentSession
+        ? `${frame.currentSession.channel}/${frame.currentSession.key}`
+        : "";
+    if (!activeLane && !currentArtifact && !nextAction)
+        return "";
+    return `if someone asks what i'm doing or for status mid-task, i answer from these live facts instead of copying a canned block.
+the live conversation is ${liveConversation || "not in a live conversation"}.
+the active lane is ${activeLane}.
+the current artifact is ${currentArtifact}.
+if i just finished or verified something concrete in this live lane, i name that as the latest checkpoint.
+the next action is ${nextAction}.
+
+i answer naturally from those facts instead of forcing a canned status block.`;
+}
+function renderLiveThreadStatusShape(frame) {
+    if (!frame.currentSession)
+        return "";
+    return `if someone asks what i'm doing or for status mid-task in this live thread, i answer in these exact lines, in order, with no intro paragraph:
+live conversation: ${frame.currentSession.channel}/${frame.currentSession.key}
+active lane: this same thread
+current artifact: <actual artifact or "no artifact yet">
+latest checkpoint: <freshest concrete thing i just finished or verified>
+next action: <smallest concrete next step i'm taking now>
+
+no recap paragraph before those lines.
+no option list.
+present tense only.
+if a finished step matters, i label it "just finished" instead of presenting it as current work.`;
+}
+function buildExactStatusReply(frame, obligation, latestCheckpoint, statusCheckScope) {
+    const headerObligation = statusCheckScope === "all-sessions-family"
+        ? findCurrentSessionStatusObligation(frame)
+        : obligation;
+    const liveConversation = frame.currentSession
+        ? `${frame.currentSession.channel}/${frame.currentSession.key}`
+        : "not in a live conversation";
+    const activeLane = headerObligation
+        ? formatActiveLane(frame, headerObligation)
+        : (frame.currentSession ? "this same thread" : "this live loop");
+    const currentArtifact = formatCurrentArtifact(frame, headerObligation) || "no artifact yet";
+    const nextAction = formatNextAction(frame, headerObligation) || "continue the active loop and bring the result back here";
+    const latest = latestCheckpoint.trim() || "<freshest concrete thing i just finished or verified>";
+    const lines = [
+        `live conversation: ${liveConversation}`,
+        `active lane: ${activeLane}`,
+        `current artifact: ${currentArtifact}`,
+        `latest checkpoint: ${latest}`,
+        `next action: ${nextAction}`,
+    ];
+    if (statusCheckScope === "all-sessions-family") {
+        lines.push("other active sessions:");
+        const summaries = (0, active_work_1.formatOtherActiveSessionSummaries)(frame);
+        lines.push(...(summaries.length > 0 ? summaries : ["- none"]));
+    }
+    return lines.join("\n");
+}
+function renderExactStatusReplyContract(frame, obligation, statusCheckScope) {
+    const headerObligation = statusCheckScope === "all-sessions-family"
+        ? findCurrentSessionStatusObligation(frame)
+        : obligation;
+    if (statusCheckScope === "all-sessions-family") {
+        return `reply using exactly this status shape and nothing else:
+live conversation: ${frame.currentSession ? `${frame.currentSession.channel}/${frame.currentSession.key}` : "not in a live conversation"}
+active lane: ${headerObligation ? formatActiveLane(frame, headerObligation) : (frame.currentSession ? "this same thread" : "this live loop")}
+current artifact: ${formatCurrentArtifact(frame, headerObligation) || "no artifact yet"}
+latest checkpoint: <freshest concrete thing i just finished or verified>
+next action: ${formatNextAction(frame, headerObligation) || "continue the active loop and bring the result back here"}
+other active sessions:
+- <session label>: <what i'm doing there right now>`;
+    }
+    return `reply using exactly these five lines and nothing else:
+${buildExactStatusReply(frame, obligation, "<freshest concrete thing i just finished or verified>")}
+`;
+}