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

package/dist/heart/active-work.js

@@ -1,11 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOtherActiveSessionSummaries = formatOtherActiveSessionSummaries;
 exports.suggestBridgeForActiveWork = suggestBridgeForActiveWork;
 exports.buildActiveWorkFrame = buildActiveWorkFrame;
 exports.formatActiveWorkFrame = formatActiveWorkFrame;
+exports.formatLiveWorldStateCheckpoint = formatLiveWorldStateCheckpoint;
+exports.snapshotActiveWork = snapshotActiveWork;
+exports.detectActiveWorkChanges = detectActiveWorkChanges;
+exports.formatActiveWorkChanges = formatActiveWorkChanges;
 const runtime_1 = require("../nerves/runtime");
 const state_machine_1 = require("./bridges/state-machine");
+const obligations_1 = require("../arc/obligations");
 const target_resolution_1 = require("./target-resolution");
+const config_1 = require("./config");
+const RECENT_ACTIVE_OBLIGATION_WINDOW_MS = 60 * 60 * 1000;
 function activityPriority(source) {
     return source === "friend-facing" ? 0 : 1;
 }
@@ -15,21 +23,487 @@ function compareActivity(a, b) {
         return sourceDiff;
     return b.lastActivityMs - a.lastActivityMs;
 }
-function summarizeLiveTasks(taskBoard) {
-    const live = [
-        ...taskBoard.byStatus.processing,
-        ...taskBoard.byStatus.validating,
-        ...taskBoard.byStatus.collaborating,
-    ];
-    return [...new Set(live)];
-}
 function isActiveBridge(bridge) {
     return bridge.lifecycle === "active";
 }
 function hasSharedObligationPressure(input) {
-    return (typeof input.currentObligation === "string"
-        && input.currentObligation.trim().length > 0) || input.mustResolveBeforeHandoff
-        || summarizeLiveTasks(input.taskBoard).length > 0;
+    return input.mustResolveBeforeHandoff
+        || activeObligationCount(input.pendingObligations) > 0;
+}
+function formatCodingLaneLabel(session) {
+    return `${session.runner} ${session.id}`;
+}
+function compactCodingCheckpoint(session) {
+    const checkpoint = session.checkpoint?.replace(/\s+/g, " ").trim();
+    if (!checkpoint)
+        return "";
+    return checkpoint.length <= 80 ? checkpoint : `${checkpoint.slice(0, 77)}...`;
+}
+function describeCodingSessionScope(session, currentSession) {
+    if (!session.originSession)
+        return "";
+    if (currentSession
+        && session.originSession.friendId === currentSession.friendId
+        && session.originSession.channel === currentSession.channel
+        && session.originSession.key === currentSession.key) {
+        return " for this thread";
+    }
+    return ` for ${session.originSession.channel}/${session.originSession.key}`;
+}
+function activeObligationCount(obligations) {
+    return (obligations ?? []).filter((ob) => (0, obligations_1.isOpenObligationStatus)(ob.status)).length;
+}
+function obligationOriginKey(obligation) {
+    return `${obligation.origin.friendId}/${obligation.origin.channel}/${(0, config_1.sanitizeKey)(obligation.origin.key)}`;
+}
+function buildLiveCodingLabelSet(codingSessions, otherCodingSessions) {
+    return new Set([
+        ...codingSessions.map(formatCodingLaneLabel),
+        ...otherCodingSessions.map(formatCodingLaneLabel),
+    ]);
+}
+function isMaterialActiveObligation(obligation, liveCodingLabels, nowMs) {
+    if (obligation.currentArtifact?.trim())
+        return true;
+    if (obligation.status === "waiting_for_merge" || obligation.status === "updating_runtime")
+        return true;
+    const surface = obligation.currentSurface;
+    if (surface?.kind === "merge" || surface?.kind === "runtime")
+        return true;
+    const recentlyTouched = (nowMs - obligationTimestampMs(obligation)) <= RECENT_ACTIVE_OBLIGATION_WINDOW_MS;
+    if (surface?.kind === "coding") {
+        const liveLabel = surface.label.trim();
+        return (liveLabel.length > 0 && liveCodingLabels.has(liveLabel)) || recentlyTouched;
+    }
+    return recentlyTouched;
+}
+function normalizePendingObligations(obligations, codingSessions, otherCodingSessions) {
+    const openObligations = (obligations ?? []).filter((obligation) => (0, obligations_1.isOpenObligationStatus)(obligation.status));
+    if (openObligations.length === 0)
+        return [];
+    const liveCodingLabels = buildLiveCodingLabelSet(codingSessions, otherCodingSessions);
+    const nowMs = Date.now();
+    const normalized = [];
+    const seenOrigins = new Set();
+    for (const obligation of [...openObligations].sort(newestObligationFirst)) {
+        if (!isMaterialActiveObligation(obligation, liveCodingLabels, nowMs))
+            continue;
+        const originKey = obligationOriginKey(obligation);
+        if (seenOrigins.has(originKey))
+            continue;
+        seenOrigins.add(originKey);
+        normalized.push(obligation);
+    }
+    return normalized;
+}
+function formatObligationSurface(obligation) {
+    if (!obligation.currentSurface?.label)
+        return "";
+    switch (obligation.status) {
+        case "investigating":
+            return ` (working in ${obligation.currentSurface.label})`;
+        case "waiting_for_merge":
+            return ` (waiting at ${obligation.currentSurface.label})`;
+        case "updating_runtime":
+            return ` (updating via ${obligation.currentSurface.label})`;
+        default:
+            return ` (${obligation.currentSurface.label})`;
+    }
+}
+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);
+}
+/* v8 ignore start -- Epic 1: obligation selection, resume handles, change detection @preserve */
+function obligationStatusPriority(status) {
+    switch (status) {
+        case "investigating": return 0;
+        case "waiting_for_merge": return 1;
+        case "updating_runtime": return 2;
+        case "pending": return 3;
+        case "fulfilled": return 4;
+    }
+}
+function selectPrimaryObligation(obligations, currentSession) {
+    const open = obligations.filter(obligations_1.isOpenObligation);
+    if (open.length === 0)
+        return null;
+    // Prefer current-session match among advanced (non-pending) obligations
+    const sessionMatch = currentSession
+        ? open.find((ob) => ob.status !== "pending"
+            && ob.origin.friendId === currentSession.friendId
+            && ob.origin.channel === currentSession.channel
+            && (0, config_1.sanitizeKey)(ob.origin.key) === (0, config_1.sanitizeKey)(currentSession.key))
+        : null;
+    if (sessionMatch)
+        return sessionMatch;
+    // Then any advanced obligation, sorted by status priority then freshness
+    const sorted = [...open].sort((a, b) => {
+        const statusDiff = obligationStatusPriority(a.status) - obligationStatusPriority(b.status);
+        if (statusDiff !== 0)
+            return statusDiff;
+        return obligationTimestampMs(b) - obligationTimestampMs(a);
+    });
+    return sorted[0] ?? null;
+}
+function findPrimaryOpenObligation(frame) {
+    return frame.primaryObligation ?? selectPrimaryObligation(frame.pendingObligations ?? [], frame.currentSession);
+}
+function matchesCurrentSession(frame, obligation) {
+    return Boolean(frame.currentSession
+        && obligation.origin.friendId === frame.currentSession.friendId
+        && obligation.origin.channel === frame.currentSession.channel
+        && (0, config_1.sanitizeKey)(obligation.origin.key) === (0, config_1.sanitizeKey)(frame.currentSession.key));
+}
+function findCurrentSessionOpenObligation(frame) {
+    return (frame.pendingObligations ?? []).find((obligation) => (0, obligations_1.isOpenObligationStatus)(obligation.status) && matchesCurrentSession(frame, obligation))
+        ?? null;
+}
+function formatActiveLane(frame, obligation) {
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession) {
+        return `${formatCodingLaneLabel(liveCodingSession)}${describeCodingSessionScope(liveCodingSession, frame.currentSession)}`;
+    }
+    if (obligation?.currentSurface?.label) {
+        return obligation.currentSurface.label;
+    }
+    if (obligation && matchesCurrentSession(frame, obligation) && frame.currentSession) {
+        return "this same thread";
+    }
+    if (frame.inner?.job?.status === "running") {
+        return "inner dialog";
+    }
+    return null;
+}
+function formatCodingArtifact(session) {
+    const artifactPath = session?.artifactPath?.trim();
+    if (artifactPath)
+        return artifactPath;
+    return session ? "no PR or merge artifact yet" : null;
+}
+function formatCurrentArtifact(frame, obligation) {
+    // Live coding session artifact takes precedence (fresher evidence)
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession?.artifactPath?.trim()) {
+        return liveCodingSession.artifactPath.trim();
+    }
+    if (obligation?.currentArtifact?.trim()) {
+        return obligation.currentArtifact.trim();
+    }
+    if (obligation?.currentSurface?.kind === "merge" && obligation.currentSurface.label.trim()) {
+        return obligation.currentSurface.label.trim();
+    }
+    const liveCodingArtifact = formatCodingArtifact(liveCodingSession);
+    if (liveCodingArtifact) {
+        return liveCodingArtifact;
+    }
+    if (obligation) {
+        return "no artifact yet";
+    }
+    return null;
+}
+function formatObligationContentNextAction(obligation) {
+    const content = obligation?.content?.trim();
+    if (!content)
+        return null;
+    return `work on "${content}" and bring back a concrete artifact`;
+}
+function backgroundOperationPriority(operation) {
+    switch (operation.status) {
+        case "failed": return 0;
+        case "queued": return 1;
+        case "running": return 2;
+        case "succeeded": return 3;
+    }
+}
+function backgroundOperationSpecText(spec, key) {
+    const value = spec?.[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+function selectPrimaryBackgroundOperation(frame) {
+    const operations = frame.backgroundOperations ?? [];
+    if (operations.length === 0)
+        return null;
+    return [...operations].sort((left, right) => {
+        const priorityDiff = backgroundOperationPriority(left) - backgroundOperationPriority(right);
+        if (priorityDiff !== 0)
+            return priorityDiff;
+        return Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
+    })[0] ?? null;
+}
+function formatBackgroundOperationNextAction(operation) {
+    if (operation.kind === "mail.import-discovered") {
+        return "inspect the import-ready archive and start the matching mail import";
+    }
+    if (operation.kind === "mail.import-mbox") {
+        switch (operation.status) {
+            case "failed":
+                switch (operation.failure?.class?.trim()) {
+                    case "transient-storage-read":
+                        return "retry-safe once the transient storage/network issue clears";
+                    case "mailroom-auth":
+                    case "mailroom-config":
+                        return "repair mail auth/config access, then retry";
+                    case "source-grant-missing":
+                    case "source-grant-ambiguous":
+                        return "repair the delegated owner/source lane, then retry";
+                    case "archive-discovery":
+                    case "archive-ambiguity":
+                    case "archive-missing":
+                    case "archive-access":
+                        return "materialize or point at the correct local archive, then retry";
+                }
+                if (operation.failure?.retryDisposition === "retry-safe") {
+                    return "retry the failed mail import once the transient issue clears or the dependency answers again";
+                }
+                if (operation.failure?.retryDisposition === "investigate-first") {
+                    return "inspect the failed mail import carefully, confirm the root cause, and then decide whether to retry";
+                }
+                return "inspect the failed mail import, fix the issue, and retry it";
+            case "queued":
+                return "queued — no action unless it stalls or i need live status";
+            case "running":
+                return "in flight — no action unless it stalls or i need live status";
+            case "succeeded":
+                return "caught up — no rerun needed unless a newer archive appears";
+        }
+    }
+    switch (operation.status) {
+        case "failed": return `repair the failed ${operation.title} operation and retry it`;
+        case "queued": return `let the queued ${operation.title} operation start, then re-check progress`;
+        case "running": return `monitor the ${operation.title} operation and react when it changes`;
+        case "succeeded": return `review the completed ${operation.title} operation and continue`;
+    }
+}
+function formatMailImportRecoveryUniverse(operation) {
+    const failureClass = operation.failure?.class?.trim();
+    if (!failureClass)
+        return null;
+    switch (failureClass) {
+        case "transient-storage-read":
+            return "transient dependency/read issue — safe to retry once storage/network answers again";
+        case "mailroom-auth":
+        case "mailroom-config":
+            return "mail auth/config issue — repair mail access or runtime config before retrying";
+        case "source-grant-missing":
+        case "source-grant-ambiguous":
+            return "delegated lane/registry issue — inspect owner/source linking before retrying";
+        case "archive-discovery":
+        case "archive-ambiguity":
+        case "archive-missing":
+        case "archive-access":
+            return "local archive/file issue — materialize or point at the right archive before retrying";
+        default:
+            return "unclassified import issue — inspect the recorded error before retrying";
+    }
+}
+function formatBackgroundOperationMeta(operation) {
+    const lines = [`operation: ${operation.id}`];
+    const filePath = backgroundOperationSpecText(operation.spec, "filePath")
+        || backgroundOperationSpecText(operation.spec, "newestCandidatePath");
+    if (filePath)
+        lines.push(`file: ${filePath}`);
+    const originLabel = backgroundOperationSpecText(operation.spec, "fileOriginLabel")
+        || backgroundOperationSpecText(operation.spec, "newestCandidateOriginLabel");
+    if (originLabel)
+        lines.push(`origin: ${originLabel}`);
+    const ownerEmail = backgroundOperationSpecText(operation.spec, "ownerEmail");
+    const source = backgroundOperationSpecText(operation.spec, "source");
+    if (ownerEmail || source) {
+        lines.push(`owner/source: ${ownerEmail || "unknown"} / ${source || "unknown"}`);
+    }
+    if (operation.failure?.class?.trim())
+        lines.push(`failure class: ${operation.failure.class}`);
+    if (operation.failure?.retryDisposition?.trim())
+        lines.push(`retry: ${operation.failure.retryDisposition}`);
+    if (operation.failure?.hint?.trim())
+        lines.push(`recovery: ${operation.failure.hint}`);
+    const recoveryUniverse = operation.kind === "mail.import-mbox" ? formatMailImportRecoveryUniverse(operation) : null;
+    if (recoveryUniverse)
+        lines.push(`recovery universe: ${recoveryUniverse}`);
+    if (operation.startedAt?.trim())
+        lines.push(`started: ${operation.startedAt}`);
+    if (operation.finishedAt?.trim())
+        lines.push(`finished: ${operation.finishedAt}`);
+    else if (operation.updatedAt?.trim())
+        lines.push(`updated: ${operation.updatedAt}`);
+    const nextAction = formatBackgroundOperationNextAction(operation);
+    if (nextAction.trim().length > 0)
+        lines.push(`next: ${nextAction}`);
+    if (operation.remediation?.length) {
+        lines.push(...operation.remediation.map((step) => `remediation: ${step}`));
+    }
+    return lines;
+}
+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 ${formatCodingLaneLabel(liveCodingSession)} and continue`;
+    }
+    if (liveCodingSession?.status === "stalled") {
+        return `unstick ${formatCodingLaneLabel(liveCodingSession)} 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) {
+        return formatObligationContentNextAction(obligation) || "continue the active loop and bring the result back here";
+    }
+    const backgroundOperation = selectPrimaryBackgroundOperation(frame);
+    if (backgroundOperation) {
+        return formatBackgroundOperationNextAction(backgroundOperation);
+    }
+    if (frame.mustResolveBeforeHandoff) {
+        return "finish what i started here before moving on";
+    }
+    return null;
+}
+const RECENT_OTHER_LIVE_SESSION_WINDOW_MS = 60 * 60 * 1000;
+function sessionOriginKey(origin) {
+    return `${origin.friendId}/${origin.channel}/${(0, config_1.sanitizeKey)(origin.key)}`;
+}
+function codingSessionTimestampMs(session) {
+    return Date.parse(session.lastActivityAt ?? session.startedAt);
+}
+function obligationTimestampMs(obligation) {
+    const value = Date.parse(obligation.updatedAt ?? obligation.createdAt);
+    return Number.isFinite(value) ? value : 0;
+}
+function newestObligationFirst(left, right) {
+    return obligationTimestampMs(right) - obligationTimestampMs(left);
+}
+function formatOtherSessionArtifact(obligation, codingSession) {
+    if (obligation?.currentArtifact?.trim())
+        return obligation.currentArtifact.trim();
+    if (obligation?.currentSurface?.kind === "merge" && obligation.currentSurface.label.trim()) {
+        return obligation.currentSurface.label.trim();
+    }
+    const codingArtifact = formatCodingArtifact(codingSession);
+    if (codingArtifact)
+        return codingArtifact;
+    return obligation ? "no artifact yet" : "no explicit artifact yet";
+}
+function formatOtherSessionNextAction(obligation, codingSession) {
+    if (obligation?.nextAction?.trim())
+        return obligation.nextAction.trim();
+    if (obligation?.status === "waiting_for_merge") {
+        return `wait for checks, merge ${formatMergeArtifact(obligation)}, then update runtime`;
+    }
+    if (obligation?.status === "updating_runtime") {
+        return "update runtime, verify version/changelog, then re-observe";
+    }
+    if (codingSession?.status === "waiting_input") {
+        return `answer ${formatCodingLaneLabel(codingSession)} and continue`;
+    }
+    if (codingSession?.status === "stalled") {
+        return `unstick ${formatCodingLaneLabel(codingSession)} and continue`;
+    }
+    if (codingSession) {
+        return "finish the coding pass and bring the result back there";
+    }
+    if (obligation) {
+        return formatObligationContentNextAction(obligation) || "continue the active loop and bring the result back there";
+    }
+    return "check this session and bring back the latest concrete state";
+}
+function formatOtherSessionLine(label, status, activeLane, artifact, nextAction) {
+    return `- ${label}: [${status}] ${activeLane}; artifact ${artifact}; next ${nextAction}`;
+}
+function formatOtherActiveSessionSummaries(frame, nowMs = Date.now()) {
+    const originMap = new Map();
+    for (const session of frame.friendActivity?.allOtherLiveSessions ?? []) {
+        if (session.friendId === "self" || session.channel === "inner")
+            continue;
+        originMap.set(sessionOriginKey(session), {
+            friendId: session.friendId,
+            channel: session.channel,
+            key: session.key,
+        });
+    }
+    const orphanCodingSummaries = (frame.otherCodingSessions ?? [])
+        .filter((session) => !session.originSession)
+        .sort((left, right) => codingSessionTimestampMs(right) - codingSessionTimestampMs(left))
+        .map((session) => ({
+        timestampMs: codingSessionTimestampMs(session),
+        line: formatOtherSessionLine("another session", session.status, formatCodingLaneLabel(session), formatCodingArtifact(session), formatOtherSessionNextAction(null, session)),
+    }));
+    for (const session of frame.otherCodingSessions ?? []) {
+        if (!session.originSession)
+            continue;
+        if (frame.currentSession
+            && session.originSession.friendId === frame.currentSession.friendId
+            && session.originSession.channel === frame.currentSession.channel
+            && (0, config_1.sanitizeKey)(session.originSession.key) === (0, config_1.sanitizeKey)(frame.currentSession.key)) {
+            continue;
+        }
+        originMap.set(sessionOriginKey(session.originSession), session.originSession);
+    }
+    for (const obligation of frame.pendingObligations ?? []) {
+        if (obligation.status === "fulfilled" || matchesCurrentSession(frame, obligation))
+            continue;
+        originMap.set(sessionOriginKey(obligation.origin), obligation.origin);
+    }
+    const summaries = [...originMap.values()].map((origin) => {
+        const originKey = sessionOriginKey(origin);
+        const obligation = [...(frame.pendingObligations ?? [])]
+            .filter((candidate) => candidate.status !== "fulfilled" && sessionOriginKey(candidate.origin) === originKey)
+            .sort(newestObligationFirst)[0] ?? null;
+        const codingSession = [...(frame.otherCodingSessions ?? [])]
+            .filter((candidate) => candidate.originSession && sessionOriginKey(candidate.originSession) === originKey)
+            .sort((left, right) => codingSessionTimestampMs(right) - codingSessionTimestampMs(left))[0] ?? null;
+        const liveSession = (frame.friendActivity?.allOtherLiveSessions ?? []).find((candidate) => sessionOriginKey(candidate) === originKey) ?? null;
+        const hasMaterialLiveSession = liveSession
+            ? ((nowMs - liveSession.lastActivityMs) <= RECENT_OTHER_LIVE_SESSION_WINDOW_MS
+                || (frame.currentSession != null
+                    && liveSession.friendId === frame.currentSession.friendId
+                    && liveSession.channel !== frame.currentSession.channel))
+            : false;
+        if (!obligation && !codingSession && !hasMaterialLiveSession) {
+            return null;
+        }
+        const timestampMs = Math.max(liveSession?.lastActivityMs ?? 0, codingSession ? codingSessionTimestampMs(codingSession) : 0, obligation ? obligationTimestampMs(obligation) : 0);
+        const activeLane = codingSession
+            ? formatCodingLaneLabel(codingSession)
+            : obligation?.currentSurface?.label?.trim() || "this live thread";
+        const artifact = formatOtherSessionArtifact(obligation, codingSession);
+        const nextAction = formatOtherSessionNextAction(obligation, codingSession);
+        const status = obligation?.status ?? codingSession?.status ?? "active";
+        const label = liveSession?.friendName ?? origin.friendId;
+        return {
+            timestampMs,
+            line: formatOtherSessionLine(`${label}/${origin.channel}/${origin.key}`, status, activeLane, artifact, nextAction),
+        };
+    }).filter((entry) => entry !== null)
+        .sort((left, right) => right.timestampMs - left.timestampMs);
+    const lines = summaries.map((entry) => entry.line);
+    return [...lines, ...orphanCodingSummaries.map((entry) => entry.line)];
 }
 function suggestBridgeForActiveWork(input) {
     const targetCandidates = (input.targetCandidates ?? [])
@@ -50,10 +524,16 @@ function suggestBridgeForActiveWork(input) {
         .sort((a, b) => {
         return b.lastActivityMs - a.lastActivityMs;
     });
-    if (!hasSharedObligationPressure(input) || targetCandidates.length !== 1) {
+    if (!hasSharedObligationPressure({
+        mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
+        pendingObligations: input.pendingObligations,
+    }) || targetCandidates.length === 0) {
         return null;
     }
     const targetSession = targetCandidates[0];
+    const objectiveHint = [...(input.pendingObligations ?? [])]
+        .find((obligation) => (0, obligations_1.isOpenObligationStatus)(obligation.status))
+        ?.content?.trim() || "keep this shared work aligned";
     const activeBridge = input.bridges.find(isActiveBridge) ?? null;
     if (activeBridge) {
         const alreadyAttached = activeBridge.attachedSessions.some((session) => session.friendId === targetSession.friendId
@@ -72,26 +552,69 @@ function suggestBridgeForActiveWork(input) {
     return {
         kind: "begin-new",
         targetSession,
-        objectiveHint: input.currentObligation?.trim() || "keep this shared work aligned",
+        objectiveHint,
         reason: "shared-work-candidate",
     };
 }
 function formatSessionLabel(session) {
     return `${session.channel}/${session.key}`;
 }
+function deriveResumeHandleConfidence(primaryObligation, codingSession) {
+    if (primaryObligation?.currentArtifact?.trim() && primaryObligation.nextAction?.trim())
+        return "high";
+    if (codingSession?.checkpoint?.trim())
+        return "medium";
+    if (primaryObligation)
+        return "low";
+    return "low";
+}
+function buildResumeHandle(currentSession, primaryObligation, codingSessions) {
+    const sessionLabel = currentSession ? formatSessionLabel(currentSession) : null;
+    if (!sessionLabel)
+        return null;
+    const liveCoding = codingSessions[0] ?? null;
+    const lane = liveCoding
+        ? `${formatCodingLaneLabel(liveCoding)}${describeCodingSessionScope(liveCoding, currentSession)}`
+        : (primaryObligation?.currentSurface?.label?.trim() || null);
+    const artifact = primaryObligation?.currentArtifact?.trim()
+        || (liveCoding?.artifactPath?.trim() || null);
+    const blockerOrWaitingOn = primaryObligation?.meaning?.waitingOn?.detail?.trim() || null;
+    const nextAction = primaryObligation?.nextAction?.trim()
+        || (primaryObligation?.content?.trim() ? `work on "${primaryObligation.content.trim()}" and bring back a concrete artifact` : null);
+    const lastVerifiedCheckpoint = liveCoding?.checkpoint?.trim() || null;
+    const codingIdentity = liveCoding
+        ? { sessionId: liveCoding.id, runner: liveCoding.runner, status: liveCoding.status }
+        : null;
+    return {
+        sessionLabel,
+        lane,
+        artifact,
+        blockerOrWaitingOn,
+        nextAction,
+        lastVerifiedCheckpoint,
+        confidence: deriveResumeHandleConfidence(primaryObligation, liveCoding),
+        codingIdentity,
+    };
+}
 function buildActiveWorkFrame(input) {
     const friendSessions = input.currentSession
         ? input.friendActivity
             .filter((entry) => entry.friendId === input.currentSession?.friendId)
             .sort(compareActivity)
         : [];
-    const liveTaskNames = summarizeLiveTasks(input.taskBoard);
     const activeBridgePresent = input.bridges.some(isActiveBridge);
+    const liveCodingSessions = input.codingSessions ?? [];
+    const allOtherLiveSessions = [...input.friendActivity].sort(compareActivity);
+    const otherCodingSessions = input.otherCodingSessions ?? [];
+    const pendingObligations = normalizePendingObligations(input.pendingObligations, liveCodingSessions, otherCodingSessions);
+    const openObligations = activeObligationCount(pendingObligations);
     const centerOfGravity = activeBridgePresent
         ? "shared-work"
-        : (input.inner.status === "running" || input.inner.hasPending || input.mustResolveBeforeHandoff)
+        : (input.inner.status === "running" || input.inner.hasPending || input.mustResolveBeforeHandoff || openObligations > 0 || liveCodingSessions.length > 0)
             ? "inward-work"
             : "local-turn";
+    const primaryObligation = selectPrimaryObligation(pendingObligations, input.currentSession ?? null);
+    const resumeHandle = buildResumeHandle(input.currentSession ?? null, primaryObligation, liveCodingSessions);
     const frame = {
         currentSession: input.currentSession ?? null,
         currentObligation: input.currentObligation?.trim() || null,
@@ -99,24 +622,27 @@ function buildActiveWorkFrame(input) {
         centerOfGravity,
         inner: input.inner,
         bridges: input.bridges,
-        taskPressure: {
-            compactBoard: input.taskBoard.compact,
-            liveTaskNames,
-            activeBridges: input.taskBoard.activeBridges,
-        },
         friendActivity: {
             freshestForCurrentFriend: friendSessions[0] ?? null,
             otherLiveSessionsForCurrentFriend: friendSessions,
+            allOtherLiveSessions,
         },
+        codingSessions: liveCodingSessions,
+        backgroundOperations: input.backgroundOperations ?? [],
+        otherCodingSessions,
+        pendingObligations,
         targetCandidates: input.targetCandidates ?? [],
+        innerReturnObligations: input.innerReturnObligations ?? [],
         bridgeSuggestion: suggestBridgeForActiveWork({
             currentSession: input.currentSession,
             currentObligation: input.currentObligation,
             mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
             bridges: input.bridges,
-            taskBoard: input.taskBoard,
+            pendingObligations,
             targetCandidates: input.targetCandidates,
         }),
+        primaryObligation,
+        resumeHandle,
     };
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
@@ -126,38 +652,145 @@ function buildActiveWorkFrame(input) {
             centerOfGravity: frame.centerOfGravity,
             friendId: frame.currentSession?.friendId ?? null,
             bridges: frame.bridges.length,
-            liveTasks: frame.taskPressure.liveTaskNames.length,
             liveSessions: frame.friendActivity.otherLiveSessionsForCurrentFriend.length,
+            codingSessions: frame.codingSessions.length,
+            otherLiveSessions: allOtherLiveSessions.length,
+            otherCodingSessions: otherCodingSessions.length,
+            pendingObligations: openObligations,
             hasBridgeSuggestion: frame.bridgeSuggestion !== null,
         },
     });
     return frame;
 }
-function formatActiveWorkFrame(frame) {
-    const lines = ["## active work"];
+function formatActiveWorkFrame(frame, options) {
+    const lines = ["## what i'm holding"];
+    lines.push("this is my top-level live world-state right now. inner work, coding lanes, other sessions, and return obligations all belong inside this picture.");
+    lines.push("if older checkpoints elsewhere in the transcript disagree with this picture, this picture wins.");
+    const primaryObligation = findPrimaryOpenObligation(frame);
+    const currentSessionObligation = findCurrentSessionOpenObligation(frame);
+    const activeLane = formatActiveLane(frame, primaryObligation);
+    const currentArtifact = formatCurrentArtifact(frame, primaryObligation);
+    const nextAction = formatNextAction(frame, primaryObligation);
+    const otherActiveSessions = formatOtherActiveSessionSummaries(frame);
+    // Session line
     if (frame.currentSession) {
-        lines.push(`current session: ${formatSessionLabel(frame.currentSession)}`);
+        let sessionLine = `i'm in a conversation on ${formatSessionLabel(frame.currentSession)}.`;
+        if (currentSessionObligation?.content?.trim()) {
+            sessionLine += ` i still owe them: ${currentSessionObligation.content.trim()}.`;
+        }
+        else if (frame.mustResolveBeforeHandoff) {
+            sessionLine += " i need to finish what i started here before moving on.";
+        }
+        lines.push("");
+        lines.push(sessionLine);
     }
-    lines.push(`center: ${frame.centerOfGravity}`);
-    if (typeof frame.currentObligation === "string" && frame.currentObligation.trim().length > 0) {
-        lines.push(`obligation: ${frame.currentObligation.trim()}`);
+    else {
+        lines.push("");
+        lines.push("i'm not in a conversation right now.");
     }
-    if (frame.mustResolveBeforeHandoff) {
-        lines.push("handoff pressure: must resolve before handoff");
+    if (activeLane || currentArtifact || nextAction) {
+        lines.push("");
+        lines.push("## current concrete state");
+        if (frame.currentSession) {
+            lines.push(`- live conversation: ${formatSessionLabel(frame.currentSession)}`);
+        }
+        if (activeLane) {
+            lines.push(`- active lane: ${activeLane}`);
+        }
+        if (currentArtifact) {
+            lines.push(`- current artifact: ${currentArtifact}`);
+        }
+        if (nextAction) {
+            lines.push(`- next action: ${nextAction}`);
+        }
+        if (frame.resumeHandle?.lastVerifiedCheckpoint) {
+            lines.push(`- last checkpoint: ${frame.resumeHandle.lastVerifiedCheckpoint}`);
+        }
+    }
+    // Inner status block
+    const job = frame.inner?.job;
+    if (job) {
+        if (job.status === "queued") {
+            let queuedLine = "i have a thought queued up for private attention.";
+            if (frame.inner?.contentSnippet) {
+                queuedLine += `\nit's about: "${frame.inner.contentSnippet}"`;
+            }
+            lines.push("");
+            lines.push(queuedLine);
+        }
+        else if (job.status === "running") {
+            const originName = job.origin?.friendName ?? job.origin?.friendId;
+            let runningLine = originName
+                ? `i'm thinking through something privately right now. ${originName} asked about something and i wanted to give it real thought.`
+                : "i'm thinking through something privately right now.";
+            if (frame.inner?.obligationPending) {
+                runningLine += "\ni still owe them an answer.";
+            }
+            lines.push("");
+            lines.push(runningLine);
+        }
+        else if (job.status === "surfaced") {
+            let surfacedLine = "i finished thinking about something privately. i should bring my answer back.";
+            if (job.surfacedResult) {
+                const truncated = job.surfacedResult.length > 120 ? job.surfacedResult.slice(0, 117) + "..." : job.surfacedResult;
+                surfacedLine += `\nwhat i came to: ${truncated}`;
+            }
+            lines.push("");
+            lines.push(surfacedLine);
+        }
+        // idle, returned, abandoned: omitted
+    }
+    if ((frame.codingSessions ?? []).length > 0) {
+        lines.push("");
+        lines.push("## live coding work");
+        for (const session of frame.codingSessions) {
+            const checkpoint = compactCodingCheckpoint(session);
+            lines.push(`- [${session.status}] ${formatCodingLaneLabel(session)}${describeCodingSessionScope(session, frame.currentSession)}${checkpoint ? `: ${checkpoint}` : ""}`);
+            /* v8 ignore start -- coding identity display: tested in identity-packet.test.ts @preserve */
+            if (session.codingIdentity) {
+                const id = session.codingIdentity;
+                lines.push(`  branch: ${id.branch ?? "unknown"} commit: ${id.commit ?? "unknown"} ${id.dirty ? "dirty" : "clean"} verification: ${id.verificationStatus}`);
+            }
+            /* v8 ignore stop */
+        }
+    }
+    const backgroundOperations = frame.backgroundOperations ?? [];
+    if (backgroundOperations.length > 0) {
+        lines.push("");
+        lines.push("## background operations");
+        for (const operation of backgroundOperations) {
+            let line = `- [${operation.status}] ${operation.title}`;
+            if (operation.summary.trim().length > 0) {
+                line += `: ${operation.summary}`;
+            }
+            line += `\n  ${formatBackgroundOperationMeta(operation).join("\n  ")}`;
+            if (operation.detail?.trim()) {
+                line += `\n  ${operation.detail.trim()}`;
+            }
+            if (operation.progress) {
+                const current = typeof operation.progress.current === "number" ? String(operation.progress.current) : "?";
+                const total = typeof operation.progress.total === "number" ? String(operation.progress.total) : null;
+                const unit = operation.progress.unit?.trim() ? ` ${operation.progress.unit.trim()}` : "";
+                line += `\n  progress: ${total ? `${current}/${total}` : current}${unit}`;
+            }
+            if (operation.error?.message?.trim()) {
+                line += `\n  error: ${operation.error.message.trim()}`;
+            }
+            lines.push(line);
+        }
     }
-    const innerStatus = frame.inner?.status ?? "idle";
-    const innerHasPending = frame.inner?.hasPending === true;
-    lines.push(`inner status: ${innerStatus}${innerHasPending ? " (pending queued)" : ""}`);
-    if ((frame.taskPressure?.liveTaskNames ?? []).length > 0) {
-        lines.push(`live tasks: ${frame.taskPressure.liveTaskNames.join(", ")}`);
+    if (otherActiveSessions.length > 0) {
+        lines.push("");
+        lines.push("## other active sessions");
+        lines.push(...otherActiveSessions);
     }
+    // Bridges
     if ((frame.bridges ?? []).length > 0) {
         const bridgeLabels = frame.bridges.map((bridge) => `${bridge.id} [${(0, state_machine_1.bridgeStateLabel)(bridge)}]`);
-        lines.push(`bridges: ${bridgeLabels.join(", ")}`);
-    }
-    if (frame.friendActivity?.freshestForCurrentFriend) {
-        lines.push(`freshest friend-facing session: ${formatSessionLabel(frame.friendActivity.freshestForCurrentFriend)}`);
+        lines.push("");
+        lines.push(`i have shared work spanning sessions: ${bridgeLabels.join(", ")}.`);
     }
+    // Target candidates (keep factual format)
     const targetCandidatesBlock = frame.targetCandidates && frame.targetCandidates.length > 0
         ? (0, target_resolution_1.formatTargetSessionCandidates)(frame.targetCandidates)
         : "";
@@ -165,14 +798,169 @@ function formatActiveWorkFrame(frame) {
         lines.push("");
         lines.push(targetCandidatesBlock);
     }
+    if ((frame.pendingObligations ?? []).length > 0) {
+        const openCount = frame.pendingObligations.filter((ob) => (0, obligations_1.isOpenObligationStatus)(ob.status)).length;
+        if (options?.obligationDetailsRenderedElsewhere && openCount > 0) {
+            // Enriched obligation data (with resumeHint, stalenessClass, waitingOn) is rendered elsewhere.
+            // Avoid duplicating the full list — just anchor the count here.
+            lines.push("");
+            lines.push(`return obligations: ${openCount} active (canonical details in **Owed** section of start-of-turn packet)`);
+        }
+        else if (openCount > 0) {
+            lines.push("");
+            lines.push("## return obligations");
+            for (const obligation of frame.pendingObligations) {
+                if (!(0, obligations_1.isOpenObligationStatus)(obligation.status))
+                    continue;
+                let obligationLine = `- [${obligation.status}] ${obligation.origin.friendId}/${obligation.origin.channel}/${obligation.origin.key}: ${obligation.content}${formatObligationSurface(obligation)}`;
+                if (obligation.latestNote?.trim()) {
+                    obligationLine += `\n  latest: ${obligation.latestNote.trim()}`;
+                }
+                lines.push(obligationLine);
+            }
+        }
+    }
+    if (frame.innerReturnObligations && frame.innerReturnObligations.length > 0) {
+        lines.push("");
+        lines.push("## inner return obligations");
+        for (const ob of frame.innerReturnObligations) {
+            const preview = ob.delegatedContent.length > 60
+                ? `${ob.delegatedContent.slice(0, 57)}...`
+                : ob.delegatedContent;
+            lines.push(`- [${ob.status}] ${ob.origin.friendId}/${ob.origin.channel}/${ob.origin.key}: ${preview}`);
+        }
+    }
+    // Bridge suggestion
     if (frame.bridgeSuggestion) {
-        if (frame.bridgeSuggestion.kind === "attach-existing") {
-            lines.push(`suggested bridge: attach ${frame.bridgeSuggestion.bridgeId} -> ${formatSessionLabel(frame.bridgeSuggestion.targetSession)}`);
+        lines.push("");
+        if (frame.bridgeSuggestion.kind === "begin-new") {
+            lines.push(`this work touches my conversation on ${formatSessionLabel(frame.bridgeSuggestion.targetSession)} too -- i should connect these threads.`);
         }
         else {
-            lines.push(`suggested bridge: begin -> ${formatSessionLabel(frame.bridgeSuggestion.targetSession)}`);
-            lines.push(`bridge objective hint: ${frame.bridgeSuggestion.objectiveHint}`);
+            lines.push(`this work relates to bridge ${frame.bridgeSuggestion.bridgeId} -- i should connect ${formatSessionLabel(frame.bridgeSuggestion.targetSession)} to it.`);
         }
     }
     return lines.join("\n");
 }
+function formatLiveWorldStateCheckpoint(frame) {
+    const primaryObligation = findPrimaryOpenObligation(frame);
+    const activeLane = formatActiveLane(frame, primaryObligation) ?? "no explicit live lane";
+    const currentArtifact = formatCurrentArtifact(frame, primaryObligation) ?? "no artifact yet";
+    const nextAction = formatNextAction(frame, primaryObligation) ?? "continue from the live world-state";
+    const otherActiveSessions = formatOtherActiveSessionSummaries(frame);
+    const lines = [
+        "## live world-state",
+        "This is the freshest state for this turn. If older transcript history conflicts with it, this state wins.",
+        `- live conversation: ${frame.currentSession ? formatSessionLabel(frame.currentSession) : "not in a live conversation"}`,
+        `- active lane: ${activeLane}`,
+        `- current artifact: ${currentArtifact}`,
+        `- next action: ${nextAction}`,
+    ];
+    if (frame.resumeHandle?.lastVerifiedCheckpoint) {
+        lines.push(`- last checkpoint: ${frame.resumeHandle.lastVerifiedCheckpoint}`);
+    }
+    if (otherActiveSessions.length > 0) {
+        lines.push("other active sessions:");
+        lines.push(...otherActiveSessions);
+    }
+    return lines.join("\n");
+}
+function snapshotActiveWork(frame) {
+    return {
+        obligationSnapshots: (frame.pendingObligations ?? []).map((ob) => ({
+            id: ob.id,
+            status: ob.status,
+            artifact: ob.currentArtifact?.trim() || null,
+            nextAction: ob.nextAction?.trim() || null,
+        })),
+        codingSnapshots: (frame.codingSessions ?? []).map((cs) => ({
+            id: cs.id,
+            status: cs.status,
+            artifact: cs.artifactPath?.trim() || null,
+            checkpoint: cs.checkpoint?.trim() || null,
+        })),
+        timestamp: new Date().toISOString(),
+    };
+}
+function detectActiveWorkChanges(previous, current) {
+    const changes = [];
+    const prevObMap = new Map(previous.obligationSnapshots.map((ob) => [ob.id, ob]));
+    const currObMap = new Map(current.obligationSnapshots.map((ob) => [ob.id, ob]));
+    // Detect new and changed obligations
+    for (const [id, curr] of currObMap) {
+        const prev = prevObMap.get(id);
+        if (!prev) {
+            changes.push({
+                kind: "obligation_appeared",
+                id,
+                from: null,
+                to: curr.status,
+                summary: `new obligation: ${curr.status}`,
+            });
+            continue;
+        }
+        if (prev.status !== curr.status) {
+            changes.push({
+                kind: "obligation_status_changed",
+                id,
+                from: prev.status,
+                to: curr.status,
+                summary: `obligation ${prev.status} -> ${curr.status}`,
+            });
+        }
+        if (prev.artifact !== curr.artifact) {
+            changes.push({
+                kind: "obligation_artifact_changed",
+                id,
+                from: prev.artifact,
+                to: curr.artifact,
+                summary: curr.artifact ? `artifact updated: ${curr.artifact}` : "artifact cleared",
+            });
+        }
+    }
+    const prevCodingMap = new Map(previous.codingSnapshots.map((cs) => [cs.id, cs]));
+    const currCodingMap = new Map(current.codingSnapshots.map((cs) => [cs.id, cs]));
+    for (const [id, curr] of currCodingMap) {
+        const prev = prevCodingMap.get(id);
+        if (!prev)
+            continue;
+        if (prev.status !== curr.status) {
+            changes.push({
+                kind: "coding_status_changed",
+                id,
+                from: prev.status,
+                to: curr.status,
+                summary: `coding ${prev.status} -> ${curr.status}`,
+            });
+        }
+        if (prev.artifact !== curr.artifact) {
+            changes.push({
+                kind: "coding_artifact_changed",
+                id,
+                from: prev.artifact,
+                to: curr.artifact,
+                summary: curr.artifact ? `artifact updated: ${curr.artifact}` : "artifact cleared",
+            });
+        }
+        if (prev.checkpoint !== curr.checkpoint) {
+            changes.push({
+                kind: "coding_checkpoint_changed",
+                id,
+                from: prev.checkpoint,
+                to: curr.checkpoint,
+                summary: curr.checkpoint ? `checkpoint: ${curr.checkpoint}` : "checkpoint cleared",
+            });
+        }
+    }
+    return changes;
+}
+function formatActiveWorkChanges(changes) {
+    if (changes.length === 0)
+        return "";
+    const lines = ["## what changed since last looked"];
+    for (const change of changes) {
+        lines.push(`- ${change.summary}`);
+    }
+    return lines.join("\n");
+}
+/* v8 ignore stop */