lossless-openclaw-orchestrator 1.2.0-beta.2 → 1.2.0-beta.3

package/dist/packages/cli/src/openclaw-tool-smoke.js

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute } from "node:path";
+import { PREPARED_CARD_STATES } from "../../core/src/index.js";
 export const DEFAULT_REQUIRED_TOOL_CALLS = [
     "loo_doctor",
     "loo_search_sessions",
@@ -40,6 +41,7 @@ export const DEFAULT_REQUIRED_TOOL_CALLS = [
     "loo_prepared_cards",
     "loo_prepared_inbox"
 ];
+const PREPARED_CARD_STATE_SET = new Set(PREPARED_CARD_STATES);
 const AUTONOMY_TICK_SUMMARY_KEYS = [
     "totalLanes",
     "returnedSteps",
@@ -1214,7 +1216,7 @@ function summarizeInvocation(toolName, call, requestArgs = {}) {
             const state = stringPath(card, ["state"]);
             return !cardRef?.startsWith("prepared_card:")
                 || !targetRef?.startsWith("codex_thread:")
-                || !["ready", "stale", "partial", "unknown"].includes(state ?? "");
+                || !PREPARED_CARD_STATE_SET.has(state ?? "");
         }))
             blockers.push("prepared_cards_public_refs_invalid");
     }

package/dist/packages/core/src/index.js

@@ -14,6 +14,21 @@ function getDatabaseSync() {
     }
     return cachedDatabaseSync;
 }
+export const PREPARED_CARD_STATES = [
+    "ready",
+    "stale",
+    "partial",
+    "unknown",
+    "completed",
+    "blocked_missing_info",
+    "waiting_approval",
+    "watching_external_check",
+    "needs_resume",
+    "dirty_worktree_handoff",
+    "stale_or_partial",
+    "ready_for_review",
+    "unknown_lifecycle"
+];
 const COLLABORATION_COCKPIT_INTERNAL_CARD_LIMIT = 5000;
 const OPERATING_SOURCE_KINDS = [
     "lco",
@@ -1581,6 +1596,7 @@ export function getPreparedCards(db, options = {}) {
     let stale = 0;
     let partial = 0;
     let unknown = 0;
+    let completed = 0;
     let lowConfidence = 0;
     for (const row of rows) {
         const card = publicPreparedCardFromRow(row);
@@ -1588,12 +1604,14 @@ export function getPreparedCards(db, options = {}) {
             filteredUnsafeRows += 1;
             continue;
         }
-        if (card.stale)
+        if (card.stale || card.state === "stale")
             stale += 1;
-        if (card.state === "partial")
+        if (preparedCardCountsAsPartialSummary(card.state))
             partial += 1;
-        if (card.state === "unknown")
+        if (card.state === "unknown" || card.state === "unknown_lifecycle")
             unknown += 1;
+        if (card.state === "completed")
+            completed += 1;
         if (card.confidence < 0.5)
             lowConfidence += 1;
         if (validCards.length < limit)
@@ -1631,6 +1649,7 @@ export function getPreparedCards(db, options = {}) {
             stale,
             partial,
             unknown,
+            completed,
             lowConfidence
         },
         cards: validCards,
@@ -1929,9 +1948,19 @@ function buildPreparedCardDraft(db, threadId, leaves, filteredUnsafeRows) {
     const watcherObservationsStatus = watcherObservationCoverageForTarget(db, targetRef);
     const freshnessAt = latestIso([...leaves.map((leaf) => leaf.freshnessAt), session?.updatedAt ?? null]);
     const stale = leaves.some((leaf) => leaf.stale);
+    const evidenceState = stale
+        ? "stale_or_partial"
+        : summaryLeavesStatus === "unknown"
+            ? "unknown_lifecycle"
+            : summaryLeavesStatus === "partial" || sessionMetadataStatus === "partial"
+                ? "stale_or_partial"
+                : "ready";
+    const lifecycle = preparedLifecycleFromMetadata(metadata, evidenceState);
+    const state = lifecycle.state;
     const reasonCodes = unique([
         leaves.length > 0 ? "summary_leaves_ready" : "summary_leaves_missing",
         "metadata_only",
+        ...lifecycle.reasonCodes,
         watcherObservationsStatus === "not_configured" ? "watcher_not_configured" : "watcher_observations_available",
         stale ? "stale_cache" : "",
         summaryLeavesStatus === "partial" ? "authority_partial" : "",
@@ -1941,17 +1970,10 @@ function buildPreparedCardDraft(db, threadId, leaves, filteredUnsafeRows) {
         watcherObservationsStatus === "unknown" ? "watcher_observations_unknown" : "",
         filteredUnsafeRows > 0 ? "filtered_unsafe_rows" : ""
     ].filter(Boolean));
-    const state = stale
-        ? "stale"
-        : summaryLeavesStatus === "unknown"
-            ? "unknown"
-            : summaryLeavesStatus === "partial" || sessionMetadataStatus === "partial"
-                ? "partial"
-                : "ready";
     const averageLeafConfidence = leaves.length
         ? leaves.reduce((sum, leaf) => sum + leaf.confidence, 0) / leaves.length
         : 0.3;
-    const confidence = preparedCardConfidence(averageLeafConfidence, state);
+    const confidence = preparedCardConfidence(averageLeafConfidence, state, evidenceState);
     const sourceRangeRefsFull = unique(leaves.flatMap((leaf) => leaf.sourceRangeRefs));
     const sourceRangeRefs = sourceRangeRefsFull.slice(0, PREPARED_CARD_SOURCE_RANGE_REF_LIMIT);
     const sourceRangeRefsOmitted = Math.max(0, sourceRangeRefsFull.length - sourceRangeRefs.length)
@@ -1965,7 +1987,7 @@ function buildPreparedCardDraft(db, threadId, leaves, filteredUnsafeRows) {
         role: "title"
     });
     const title = looksSensitiveRefLike(cleanedTitle.text) ? publicSafeText(safeThreadId(threadId), 160) : cleanedTitle.text;
-    const summaryText = publicSafeText(`Prepared state: ${leaves.length} summary leaf${leaves.length === 1 ? "" : "s"} across ${Math.max(0, leafRangeCount)} prepared source range${leafRangeCount === 1 ? "" : "s"}.`, 320);
+    const summaryText = publicSafeText(`Prepared state: ${leaves.length} summary leaf${leaves.length === 1 ? "" : "s"} across ${Math.max(0, leafRangeCount)} prepared source range${leafRangeCount === 1 ? "" : "s"}. Lifecycle: ${preparedCardStateLabel(state)}.`, 320);
     const nextAction = preparedCardNextAction(state);
     const authorityCoverage = {
         summaryLeaves: {
@@ -1985,6 +2007,10 @@ function buildPreparedCardDraft(db, threadId, leaves, filteredUnsafeRows) {
         leafRefs: leaves.map((leaf) => leaf.leafRef),
         inputHashes: leaves.map((leaf) => leaf.inputHash),
         outputHashes: leaves.map((leaf) => leaf.outputHash),
+        metadataSignalHash: lifecycle.metadataSignalHash,
+        lifecycleState: state,
+        lifecycleReasonCodes: lifecycle.reasonCodes,
+        evidenceState,
         freshnessAt,
         stale,
         summaryLeavesStatus,
@@ -2020,7 +2046,7 @@ function buildPreparedCardDraft(db, threadId, leaves, filteredUnsafeRows) {
 function preparedInboxItemFromCard(card) {
     const reasonCodes = unique([
         ...card.reasonCodes,
-        card.state === "ready" ? "prepared_card_ready" : "needs_attention"
+        card.state === "ready" ? "prepared_card_ready" : card.state === "completed" ? "prepared_card_completed" : "needs_attention"
     ]);
     const urgencyScore = preparedInboxUrgencyScore(card, reasonCodes);
     return {
@@ -2289,7 +2315,7 @@ function getPreparedTargetCoverage(db, threadId) {
         preparedSourceEvents: preparedSourceEvents.count > 0 ? "ok" : "not_configured",
         preparedSourceRanges: preparedSourceRanges.publicCount > 0 ? "ok" : preparedSourceRanges.rawCount > 0 ? "partial" : "not_configured",
         summaryLeaves: summaryLeaves.publicCount > 0 ? "ok" : summaryLeaves.rawCount > 0 ? "partial" : "not_configured",
-        preparedCards: publicCard ? publicCard.state === "ready" && !publicCard.stale ? "ok" : "partial" : preparedCards > 0 ? "partial" : "not_configured",
+        preparedCards: publicCard ? preparedTargetCardCoverage(publicCard) : preparedCards > 0 ? "partial" : "not_configured",
         preparedInboxItems: publicCard && preparedInboxItems.publicCount > 0 ? "ok" : preparedInboxItems.rawCount > 0 ? "partial" : "not_configured",
         watcherObservations: watcherObservationCoverageForTarget(db, targetRef)
     };
@@ -2314,8 +2340,7 @@ function getPreparedTargetCoverage(db, threadId) {
     const partialDerivedCache = requiredCoverage.some((state) => state === "partial");
     const allDerivedLayersMissing = requiredCoverage.every((state) => state === "not_configured");
     const stale = Boolean(session && (missingDerivedCache
-        || publicCard?.stale
-        || publicCard?.state !== "ready"
+        || (publicCard ? preparedTargetCardCoverage(publicCard) !== "ok" : false)
         || summaryLeaves.staleCount > 0
         || (sourceUpdatedAt && preparedFreshnessAt && sourceUpdatedAt > preparedFreshnessAt)));
     const anyDerivedRows = preparedSourceEvents.count + preparedSourceRanges.rawCount + summaryLeaves.rawCount + preparedCards + preparedInboxItems.rawCount > 0;
@@ -2353,6 +2378,18 @@ function getPreparedTargetCoverage(db, threadId) {
         nextAction: preparedTargetNextAction(status)
     };
 }
+function preparedTargetCardCoverage(card) {
+    if (card.stale)
+        return "partial";
+    return preparedCardStateHasFreshTargetCoverage(card.state) ? "ok" : "partial";
+}
+function preparedCardStateHasFreshTargetCoverage(state) {
+    return state !== "stale"
+        && state !== "partial"
+        && state !== "stale_or_partial"
+        && state !== "unknown"
+        && state !== "unknown_lifecycle";
+}
 function countPreparedTargetRows(db, sql, ...params) {
     return Number(db.prepare(sql).get(...params)?.count ?? 0);
 }
@@ -2545,7 +2582,7 @@ function preparedCoverageState(value) {
     return value === "ok" || value === "partial" || value === "not_configured" || value === "unknown" ? value : "unknown";
 }
 function isPreparedCardState(value) {
-    return value === "ready" || value === "stale" || value === "partial" || value === "unknown";
+    return PREPARED_CARD_STATES.includes(value);
 }
 function isPublicPreparedSourceRef(value) {
     if (value.startsWith("codex_thread:"))
@@ -2569,7 +2606,125 @@ function isPublicCodexSubagentResultRef(value) {
     }
     return /^[A-Za-z0-9._:-]{1,160}$/.test(decodedId) && !looksSensitiveRefLike(decodedId);
 }
-function preparedCardConfidence(averageLeafConfidence, state) {
+function preparedLifecycleFromMetadata(metadata, evidenceState) {
+    const signals = {
+        status: normalizedMetadataValue(metadata.status),
+        blocker: normalizedMetadataValue(metadata.blocker),
+        nextAction: normalizedMetadataValue(metadata.nextAction),
+        closeoutState: normalizedMetadataValue(metadata.closeoutState),
+        planCompletionState: normalizedMetadataValue(metadata.planCompletionState)
+    };
+    const metadataSignalHash = stableId(JSON.stringify(signals));
+    const nonBlockerText = [signals.status, signals.nextAction, signals.closeoutState, signals.planCompletionState].filter(Boolean).join(" ");
+    const text = [nonBlockerText, signals.blocker].filter(Boolean).join(" ");
+    const sourceReasonCodes = Object.entries(signals)
+        .filter(([, value]) => value.length > 0)
+        .map(([field]) => `lifecycle_signal:${field.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`)}`);
+    const completedByStatus = lifecycleCompletionLike(signals.status);
+    const completedByCloseoutAndPlan = lifecycleCompletionLike(signals.closeoutState)
+        && lifecycleCompletionLike(signals.planCompletionState);
+    const completed = completedByStatus || completedByCloseoutAndPlan;
+    const dirtyHandoff = /\b(?:dirty[-_ ]?worktree|uncommitted|worktree[-_ ]?handoff|dirty[-_ ]?handoff|handoff[-_ ]?dirty|cleanup[-_ ]?required)\b/.test(text);
+    const waitingApproval = /\b(?:waiting[-_ ]?(?:for[-_ ]?)?approval|needs[-_ ]?approval|requires[-_ ]?approval|approval[-_ ]?(?:required|needed|pending)|pending[-_ ]?approval|approval[-_ ]?gate|do[-_ ]?not[-_ ]?execute[-_ ]?without[-_ ]?explicit[-_ ]?approval)\b/.test(text);
+    const needsResume = /\b(?:needs[-_ ]?(?:to[-_ ]?)?resume|resume[-_ ]?(?:session|thread|work|run|lane|needed|required|requested|request)|continue[-_ ]?(?:session|thread|lane)|nudge[-_ ]?(?:session|thread|agent|lane)|rejoin[-_ ]?(?:session|thread|lane))\b/.test(text);
+    const watchingExternalCheck = /\b(?:(?:watch|watching|monitor|monitoring)[-_ ]+(?:ci|checks?|codeql|coderabbit|deploy(?:[-_ ]?check)?|external[-_ ]?(?:check|review)|review[-_ ]?check)|(?:waiting[-_ ]?(?:on|for)|pending)[-_ ]+(?:ci|checks?|codeql|coderabbit|deploy|external[-_ ]?check|review[-_ ]?check)|(?:ci|checks?|codeql|coderabbit|deploy[-_ ]?check|review[-_ ]?check)[-_ ]+(?:pending|queued|running|failing|failed|blocked|red|not[-_ ]?green|in[-_ ]?progress))\b/.test(text);
+    const readyForReview = /\b(?:ready[-_ ]?for[-_ ]?review|review[-_ ]?ready|ready[-_ ]?to[-_ ]?review|pr[-_ ]?ready|needs[-_ ]?review)\b/.test(text);
+    const negatedBlocker = /\b(?:not[-_ ]?blocked|no[-_ ]?blocker|unblocked|without[-_ ]?blocker|blocker[-_ ]?(?:none|na|n[-_ ]?a))\b/.test(text);
+    const missingInfoSignal = /\b(?:missing[-_ ]?(?:info|input|context)|needs[-_ ]?(?:info|input|context)|waiting[-_ ]?(?:on|for)[-_ ]?(?:user|operator|human|input|context)|cannot[-_ ]?proceed)\b/.test(nonBlockerText);
+    const blockedSignal = !negatedBlocker && /\b(?:blocked|blocker)\b/.test(nonBlockerText);
+    const blockedMissingInfo = !waitingApproval
+        && !dirtyHandoff
+        && !watchingExternalCheck
+        && !negatedBlocker
+        && (hasRealBlocker(metadata.blocker) || missingInfoSignal || blockedSignal);
+    const matchedLifecycleStates = [
+        completed ? "completed" : null,
+        dirtyHandoff ? "dirty_worktree_handoff" : null,
+        waitingApproval ? "waiting_approval" : null,
+        blockedMissingInfo ? "blocked_missing_info" : null,
+        needsResume ? "needs_resume" : null,
+        watchingExternalCheck ? "watching_external_check" : null,
+        readyForReview ? "ready_for_review" : null
+    ].filter((state) => Boolean(state));
+    const evidenceReasonCodes = evidenceState !== "ready" ? [`lifecycle:${evidenceState}`] : [];
+    const conflict = completed && matchedLifecycleStates.some((state) => state !== "completed");
+    if (conflict) {
+        return {
+            state: "unknown_lifecycle",
+            reasonCodes: unique([
+                "semantic_lifecycle",
+                "lifecycle:unknown_lifecycle",
+                "lifecycle_conflict",
+                ...matchedLifecycleStates.map((state) => `lifecycle:${state}`),
+                ...evidenceReasonCodes,
+                ...sourceReasonCodes
+            ]),
+            metadataSignalHash
+        };
+    }
+    const semanticState = dirtyHandoff
+        ? "dirty_worktree_handoff"
+        : waitingApproval
+            ? "waiting_approval"
+            : blockedMissingInfo
+                ? "blocked_missing_info"
+                : needsResume
+                    ? "needs_resume"
+                    : watchingExternalCheck
+                        ? "watching_external_check"
+                        : readyForReview
+                            ? "ready_for_review"
+                            : completed
+                                ? "completed"
+                                : null;
+    if (semanticState === "completed" && evidenceState !== "ready") {
+        return {
+            state: evidenceState,
+            reasonCodes: unique(["semantic_lifecycle", "lifecycle:completed", `lifecycle:${evidenceState}`, ...sourceReasonCodes]),
+            metadataSignalHash
+        };
+    }
+    if (semanticState) {
+        return {
+            state: semanticState,
+            reasonCodes: unique(["semantic_lifecycle", `lifecycle:${semanticState}`, ...evidenceReasonCodes, ...sourceReasonCodes]),
+            metadataSignalHash
+        };
+    }
+    if (evidenceState !== "ready") {
+        return {
+            state: evidenceState,
+            reasonCodes: unique(["semantic_lifecycle", `lifecycle:${evidenceState}`, "lifecycle_signal_missing", ...sourceReasonCodes]),
+            metadataSignalHash
+        };
+    }
+    return {
+        state: "ready",
+        reasonCodes: unique(["semantic_lifecycle", "lifecycle:unknown_lifecycle", "lifecycle_signal_missing"]),
+        metadataSignalHash
+    };
+}
+function lifecycleCompletionLike(value) {
+    return ["complete", "completed", "done", "closed", "merged", "success", "successful", "succeeded", "passed"].includes(value);
+}
+function preparedCardStateLabel(state) {
+    return {
+        ready: "evidence ready, lifecycle unknown",
+        stale: "stale evidence",
+        partial: "partial evidence",
+        unknown: "unknown evidence",
+        completed: "completed",
+        blocked_missing_info: "blocked missing info",
+        waiting_approval: "waiting approval",
+        watching_external_check: "watching external check",
+        needs_resume: "needs resume",
+        dirty_worktree_handoff: "dirty worktree handoff",
+        stale_or_partial: "stale or partial",
+        ready_for_review: "ready for review",
+        unknown_lifecycle: "unknown lifecycle"
+    }[state] ?? "unknown lifecycle";
+}
+function preparedCardConfidence(averageLeafConfidence, state, evidenceState = state) {
     let confidence = Number.isFinite(averageLeafConfidence) ? averageLeafConfidence : 0.3;
     if (state === "partial")
         confidence = Math.min(confidence, 0.49);
@@ -2577,6 +2732,14 @@ function preparedCardConfidence(averageLeafConfidence, state) {
         confidence = Math.min(confidence, 0.49);
     if (state === "unknown")
         confidence = Math.min(confidence, 0.44);
+    if (state === "stale_or_partial")
+        confidence = Math.min(confidence, 0.49);
+    if (state === "unknown_lifecycle")
+        confidence = Math.min(confidence, 0.44);
+    if (evidenceState === "partial" || evidenceState === "stale" || evidenceState === "stale_or_partial")
+        confidence = Math.min(confidence, 0.49);
+    if (evidenceState === "unknown" || evidenceState === "unknown_lifecycle")
+        confidence = Math.min(confidence, 0.44);
     return Math.max(0.2, Math.min(0.99, Number(confidence.toFixed(2))));
 }
 function preparedCardNextAction(state) {
@@ -2586,14 +2749,41 @@ function preparedCardNextAction(state) {
         return "Refresh the local prepared-state cache before treating this card as current.";
     if (state === "partial")
         return "Inspect source coverage and summary leaves before relying on this prepared card.";
+    if (state === "completed")
+        return "No action is needed unless bounded evidence contradicts the completed lifecycle state.";
+    if (state === "blocked_missing_info")
+        return "Inspect bounded evidence and resolve the missing input or blocker before resuming.";
+    if (state === "waiting_approval")
+        return "Inspect the bounded approval context; do not execute without explicit approval.";
+    if (state === "watching_external_check")
+        return "Refresh external check or watcher evidence before deciding the next action.";
+    if (state === "needs_resume")
+        return "Inspect bounded evidence and resume only through the approval-gated control path.";
+    if (state === "dirty_worktree_handoff")
+        return "Inspect handoff evidence and clean or transfer the dirty worktree deliberately.";
+    if (state === "stale_or_partial")
+        return "Refresh or inspect partial prepared-state evidence before relying on this lifecycle card.";
+    if (state === "ready_for_review")
+        return "Review bounded evidence and source refs before marking the lane complete.";
+    if (state === "unknown_lifecycle")
+        return "Inspect summary leaves and session metadata; lifecycle signals are missing or conflicting.";
     return "Inspect summary leaves and source coverage; missing or conflicting authority prevents a ready claim.";
 }
 function preparedInboxUrgencyScore(card, reasonCodes) {
     const stateScore = {
         unknown: 88,
+        unknown_lifecycle: 60,
         stale: 82,
+        stale_or_partial: 74,
         partial: 74,
-        ready: 42
+        blocked_missing_info: 94,
+        waiting_approval: 92,
+        dirty_worktree_handoff: 89,
+        watching_external_check: 78,
+        needs_resume: 76,
+        ready_for_review: 68,
+        ready: 42,
+        completed: 18
     };
     const codeScore = reasonCodes.reduce((score, code) => score + ({
         authority_unknown: 8,
@@ -2601,9 +2791,26 @@ function preparedInboxUrgencyScore(card, reasonCodes) {
         stale_cache: 8,
         low_confidence: 6,
         filtered_unsafe_rows: 5,
-        needs_attention: 4
+        needs_attention: 4,
+        "lifecycle_conflict": 10,
+        "lifecycle:blocked_missing_info": 8,
+        "lifecycle:waiting_approval": 7,
+        "lifecycle:dirty_worktree_handoff": 7,
+        "lifecycle:watching_external_check": 5,
+        "lifecycle:needs_resume": 5
     }[code] ?? 0), 0);
-    return Math.max(0, Math.min(100, Number((stateScore[card.state] + codeScore + Math.round((1 - card.confidence) * 10)).toFixed(2))));
+    const baseStateScore = stateScore[card.state] ?? 50;
+    return Math.max(0, Math.min(100, Number((baseStateScore + codeScore + Math.round((1 - card.confidence) * 10)).toFixed(2))));
+}
+function preparedCardCountsAsPartialSummary(state) {
+    return state === "partial"
+        || state === "stale_or_partial"
+        || state === "blocked_missing_info"
+        || state === "waiting_approval"
+        || state === "watching_external_check"
+        || state === "needs_resume"
+        || state === "dirty_worktree_handoff"
+        || state === "ready_for_review";
 }
 function preparedCardReadActions() {
     return {

package/dist/packages/mcp-server/src/tools.js

@@ -1,6 +1,6 @@
 import { readFileSync, realpathSync, statSync } from "node:fs";
 import { basename } from "node:path";
-import { configuredLcmPeerDbPaths, createCloseoutEnvelopeReport, createAttentionInbox, createBusinessPulse, createCodexActiveThreadState, createCodexAutonomyTick, createCodexCollaborationNextSteps, createCodexCollaborationCockpit, createCodexRuntimeDesktopVisibilityStatus, describeSession, describeRecallRef, defaultCodexRoots, createIndexedSessionSanitizerReport, createIndexedSessionSanitizerRepairPlan, expandSession, expandQuery, expandSummaryLeaves, getPreparedCards, getPreparedInbox, getPreparedStateStatus, getWatcherEvents, createPlanStatePinsReport, createGithubOperatingItemsReport, createProjectDigest, createResumeRequestPacket, createWatcherStatusReport, createCodexDesktopCoherenceReport, createVisibleCodexSessionMap, getCockpitInbox, getCodexFinalMessages, getCodexPlans, getCodexSessionManagementMap, getCodexThreadMap, getCodexTouchedFiles, getCodexToolCalls, getRecentSessions, getSummaryLeaves, grepRecall, indexCodexSessions, probeLcmPeerDbs, probeCodexSqliteStores, searchSessions } from "../../core/src/index.js";
+import { configuredLcmPeerDbPaths, createCloseoutEnvelopeReport, createAttentionInbox, createBusinessPulse, createCodexActiveThreadState, createCodexAutonomyTick, createCodexCollaborationNextSteps, createCodexCollaborationCockpit, createCodexRuntimeDesktopVisibilityStatus, describeSession, describeRecallRef, defaultCodexRoots, createIndexedSessionSanitizerReport, createIndexedSessionSanitizerRepairPlan, expandSession, expandQuery, expandSummaryLeaves, getPreparedCards, getPreparedInbox, getPreparedStateStatus, PREPARED_CARD_STATES, getWatcherEvents, createPlanStatePinsReport, createGithubOperatingItemsReport, createProjectDigest, createResumeRequestPacket, createWatcherStatusReport, createCodexDesktopCoherenceReport, createVisibleCodexSessionMap, getCockpitInbox, getCodexFinalMessages, getCodexPlans, getCodexSessionManagementMap, getCodexThreadMap, getCodexTouchedFiles, getCodexToolCalls, getRecentSessions, getSummaryLeaves, grepRecall, indexCodexSessions, probeLcmPeerDbs, probeCodexSqliteStores, searchSessions } from "../../core/src/index.js";
 import { LOO_COMMAND_POLICY, createCodexAppServerStatusReport, createCodexAppServerThreadsReport, codexTransportStatus, createCodexControl, createCodexDesktopCollaborationProof, createCodexDesktopFallbackReport, createDesktopGuiProofReport, createDesktopLiveProofHarness, createDesktopProofAction, desktopActDryRun, desktopFallbackDiagnostics, desktopSee, isDesktopBackend, redactValue } from "../../adapters/src/index.js";
 export const LOO_TOOL_TIERS = ["public_facade", "workflow_detail", "proof_debug", "internal_low_level"];
 export const LOO_TOOL_SURFACE = {
@@ -274,7 +274,7 @@ export function createLooTools(options) {
         })),
         tool("loo_prepared_cards", "List public-safe prepared Codex state cards over summary leaves.", {
             thread_id: { type: "string" },
-            state: { type: "string", enum: ["ready", "stale", "partial", "unknown"] },
+            state: { type: "string", enum: [...PREPARED_CARD_STATES] },
             limit: { type: "integer", minimum: 1, maximum: 500 }
         }, (input) => getPreparedCards(options.db, {
             threadId: optionalString(input.thread_id),
@@ -1366,9 +1366,9 @@ function optionalSummaryLeafKind(value) {
 function optionalPreparedCardState(value) {
     if (value === undefined)
         return undefined;
-    if (value === "ready" || value === "stale" || value === "partial" || value === "unknown")
+    if (typeof value === "string" && PREPARED_CARD_STATES.includes(value))
         return value;
-    throw new Error("state must be ready, stale, partial, or unknown");
+    throw new Error(`state must be one of ${PREPARED_CARD_STATES.join(", ")}`);
 }
 function optionalRecentScope(value) {
     if (value === undefined)

package/docs/RELEASE_NOTES_1.2.0-beta.3.md

@@ -0,0 +1,95 @@
+# Release Notes 1.2.0-beta.3
+
+`1.2.0-beta.3` is a scoped prerelease checkpoint for Codex-first local orchestration
+and the LCO 1.2 prepared-state sprint. It publishes semantic
+prepared-card lifecycle routing and the completed-card target coverage follow-up
+merged after `1.2.0-beta.2`.
+
+This release is intentionally on the npm `beta` channel. It does not promote
+`latest` and it does not claim 1.2 GA.
+
+## What Changed
+
+- Added semantic lifecycle states for prepared cards and prepared inbox routing:
+  `completed`, `blocked_missing_info`, `waiting_approval`,
+  `watching_external_check`, `needs_resume`, `dirty_worktree_handoff`,
+  `ready_for_review`, `stale_or_partial`, and `unknown_lifecycle`.
+- Exposed the lifecycle state enum through the shared core registry, MCP tool
+  schema, OpenClaw plugin manifests, and OpenClaw gateway smoke validation.
+- Added deterministic lifecycle reason codes, lifecycle-aware next actions, and
+  urgency ranking for advisory prepared cards.
+- Added a completed-card summary counter so finished lanes remain visible in
+  prepared-card summaries instead of disappearing from stale/partial/unknown
+  counters.
+- Tightened lifecycle classification so generic words such as `resume`,
+  `monitor`, and `ci` do not become lifecycle states without operator-action
+  context.
+- Fixed completed prepared-card target coverage so a fresh public completed card
+  counts as target coverage `ok` and does not make `loo_prepared_state_status`
+  report stale/partial coverage for a fully materialized completed lane.
+- Preserved stale, partial, unknown, unsafe-row, and stale-freshness downgrades
+  for incomplete or unsafe prepared-state evidence.
+- Carries forward the #160 desktop proof-action release boundary:
+  `loo_desktop_proof_action` / `loo desktop proof-action` validates the CUA Driver TextEdit scratch proof gate and does not prove generic GUI mutation.
+  The proof action still requires exact backend, target app, target window, action hash, approval ref, permission state, scratch file path, and `execute: true` before the backend can run.
+  Generic gateway invocation without exact proof args fails closed. The desktop proof action keeps the same proof boundary as beta.35.
+- Carries forward strict OpenClaw gateway result handling: plugin output with
+  `output.details.ok: false` is reported as
+  `openclaw_tool_result_not_ok:<tool>` rather than successful tool proof.
+
+## Current Claim Scope
+
+Allowed prerelease claim:
+
+> Local prepared Codex state and summary-leaf recall for OpenClaw/Eva, including
+> semantic prepared-card lifecycle routing, prepared inbox prioritization,
+> bounded summary expansion, visible Codex sidebar inventory, and
+> approval-gated start-thread proof packets without raw transcript reads.
+
+Prepared state remains an advisory local derived cache, not source authority
+for PR, CI, release, runtime, customer, or business truth.
+
+This release remains focused on local Codex sessions.
+
+## Release Gate Notes
+
+- Parent 1.2 tracker: #405.
+- Cockpit tracker: #448.
+- Release checkpoint issue: #473.
+- Included implementation PRs: #452 and #472.
+- Baseline stable release: `v1.1.4`.
+- Prior beta release: `v1.2.0-beta.2`.
+- Candidate package: `lossless-openclaw-orchestrator@1.2.0-beta.3`.
+- Expected npm dist-tag: `beta`.
+- Expected git tag: `v1.2.0-beta.3`.
+- Expected GitHub Release:
+  `https://github.com/100yenadmin/Lossless-Codex-Orchestrator-LCO/releases/tag/v1.2.0-beta.3`.
+- Required scoped prerelease gates: focused prepared-card/OpenClaw tool-smoke
+  tests, build/typecheck, `npm pack --dry-run`, release bundle/status checks,
+  GitHub CI, CodeQL, current-head review threads clear, npm publish to `beta`,
+  GitHub prerelease, and post-publish finalization status.
+- Bundle/status/finalization checks do not publish to npm and do not create a GitHub Release.
+- Working-app status example:
+  `loo release status --claim-scope codex-working-app-proof --runtime-proof-dir <path> --approved-live-control-evidence <path> --npm-publish-approval-evidence <path> --github-release-approval-evidence <path> --candidate-sha <sha> --github-ci-evidence <path> --codeql-evidence <path> --evidence-dir <path> --strict`
+- Reduced-scope status example:
+  `loo release status --claim-scope codex-read-search-expand-dry-run --npm-publish-approval-evidence <path> --github-release-approval-evidence <path> --candidate-sha <sha> --github-ci-evidence <path> --codeql-evidence <path> --evidence-dir <path> --strict`
+- `approved_live_control_smoke_missing` remains the expected blocker when a
+  working-app or live-control claim is attempted without approved live-control
+  smoke evidence for the exact candidate SHA.
+
+## Explicit Non-Claims
+
+No new live Codex control smoke is run by this release.
+It does not run generic GUI mutation and does not run Codex GUI mutation.
+No automatic gateway authorization.
+No broad gateway scope approval. No prompt typing. No clicking. No arbitrary app control.
+No screenshots or videos are part of the public release evidence.
+Claude Code remains an adapter stub, not an adapter-equivalence claim.
+No true Codex compaction-summary capture.
+No model compaction proof.
+No raw transcript upload and no OpenClaw LCM merge.
+No Notion, support-control, Stripe, or Company Brain P1 adapter proof.
+No cloud sync.
+No unattended desktop takeover.
+No npm `latest` promotion.
+No release-grade enterprise security or customer-ready security claim.

package/evals/scenarios/v1/prepared-cards-inbox-v1.json

@@ -1,9 +1,9 @@
 {
   "scenario_version": "1.0",
   "id": "prepared-cards-inbox-v1",
-  "title": "Prepared-state OpenClaw gateway dogfood",
+  "title": "Prepared-state lifecycle OpenClaw gateway dogfood",
   "claim_scope": "codex-read-search-expand-dry-run",
-  "user_task": "As Eva, inspect prepared Codex session cards, choose the highest-priority attention item, and expand only bounded summary-leaf evidence before deciding the next safe action.",
+  "user_task": "As Eva, inspect prepared Codex session cards, distinguish evidence readiness from semantic lifecycle state, choose the highest-priority attention item, and expand only bounded summary-leaf evidence before deciding the next safe action.",
   "surface": "openclaw_gateway",
   "allowed_tools": [
     "loo_prepared_state_status",
@@ -39,7 +39,9 @@
     "source coverage",
     "authority coverage",
     "freshness and confidence",
-    "stale partial unknown and low-confidence reason codes",
+    "semantic lifecycle state and lifecycle reason codes",
+    "completed blocked_missing_info waiting_approval watching_external_check needs_resume dirty_worktree_handoff ready_for_review stale_or_partial and unknown_lifecycle classification",
+    "stale partial unknown and low-confidence evidence-readiness reason codes",
     "execute=false attention queue actions",
     "bounded summary expansion references",
     "OpenClaw gateway tool-smoke",
@@ -69,6 +71,8 @@
     "requires_execute_false_actions": true,
     "requires_openclaw_gateway_tool_smoke": true,
     "requires_agent_recommendation": true,
+    "requires_semantic_lifecycle_reason_codes": true,
+    "requires_lifecycle_urgency_ranking": true,
     "requires_stale_partial_unknown_reason_codes": true,
     "max_raw_transcript_spans": 0,
     "max_raw_tool_payloads": 0,
@@ -76,6 +80,6 @@
     "max_gui_actions": 0,
     "max_screenshots_in_public_evidence": 0
   },
-  "proof_boundary": "Dry-run fixture and OpenClaw gateway dogfood scenario for deterministic prepared-card and attention-inbox materialization over public-safe summary leaves. It proves advisory local prepared Codex state handoff and targeted prepared-state coverage for OpenClaw/Eva only when paired with a public-safe `loo openclaw tool-smoke` report that invokes prepared-state tools for a requested thread id, emits an agent recommendation, and records `rawTranscriptRead=false`. It does not prove model compaction, true Codex compaction-summary capture, live control, GUI mutation, unattended autonomy, release readiness, or 1.2 GA readiness.",
-  "next_action": "Attach issue-specific OpenClaw gateway dogfood evidence for #413/#451, then continue #414 and #415 behind their explicit canary/protocol boundaries."
+  "proof_boundary": "Dry-run fixture and OpenClaw gateway dogfood scenario for deterministic prepared-card and attention-inbox materialization over public-safe summary leaves plus session metadata lifecycle signals. It proves advisory local prepared Codex lifecycle routing and targeted prepared-state coverage for OpenClaw/Eva only when paired with focused lifecycle fixtures, a public-safe `loo openclaw tool-smoke` report that invokes prepared-state tools for a requested thread id, emits an agent recommendation, and records `rawTranscriptRead=false`. It does not prove model compaction, true Codex compaction-summary capture, live control, GUI mutation, unattended autonomy, release readiness, or 1.2 GA readiness.",
+  "next_action": "Attach issue-specific semantic lifecycle evidence for #446, then continue remaining #405/#448 children behind their explicit canary/protocol boundaries."
 }

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "lossless-openclaw-orchestrator",
   "name": "Lossless OpenClaw Orchestrator",
   "description": "Control and collaborate with local Codex sessions through OpenClaw using local indexing, bounded recall, and approval-gated controls.",
-  "version": "1.2.0-beta.2",
+  "version": "1.2.0-beta.3",
   "kind": "tool",
   "tools": {
     "prefix": "loo_"
@@ -477,7 +477,16 @@
                 "ready",
                 "stale",
                 "partial",
-                "unknown"
+                "unknown",
+                "completed",
+                "blocked_missing_info",
+                "waiting_approval",
+                "watching_external_check",
+                "needs_resume",
+                "dirty_worktree_handoff",
+                "stale_or_partial",
+                "ready_for_review",
+                "unknown_lifecycle"
               ]
             },
             "limit": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lossless-openclaw-orchestrator",
-  "version": "1.2.0-beta.2",
+  "version": "1.2.0-beta.3",
   "description": "Index, search, and control local Codex sessions through OpenClaw with approval-gated safety; Claude Code remains an experimental adapter stub.",
   "type": "module",
   "license": "PolyForm-Noncommercial-1.0.0",

package/packages/cli/src/openclaw-tool-smoke.ts

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute } from "node:path";
+import { PREPARED_CARD_STATES } from "../../core/src/index.js";
 
 export const DEFAULT_REQUIRED_TOOL_CALLS = [
   "loo_doctor",
@@ -42,6 +43,8 @@ export const DEFAULT_REQUIRED_TOOL_CALLS = [
   "loo_prepared_inbox"
 ];
 
+const PREPARED_CARD_STATE_SET = new Set<string>(PREPARED_CARD_STATES);
+
 const AUTONOMY_TICK_SUMMARY_KEYS = [
   "totalLanes",
   "returnedSteps",
@@ -1332,7 +1335,7 @@ function summarizeInvocation(
       const state = stringPath(card, ["state"]);
       return !cardRef?.startsWith("prepared_card:")
         || !targetRef?.startsWith("codex_thread:")
-        || !["ready", "stale", "partial", "unknown"].includes(state ?? "");
+        || !PREPARED_CARD_STATE_SET.has(state ?? "");
     })) blockers.push("prepared_cards_public_refs_invalid");
   }
   if (toolName === "loo_prepared_inbox") {

package/packages/core/src/index.ts

@@ -262,7 +262,22 @@ export type SummaryLeafMaterializationOptions = {
   limit?: number;
 };
 
-export type PreparedCardState = "ready" | "stale" | "partial" | "unknown";
+export const PREPARED_CARD_STATES = [
+  "ready",
+  "stale",
+  "partial",
+  "unknown",
+  "completed",
+  "blocked_missing_info",
+  "waiting_approval",
+  "watching_external_check",
+  "needs_resume",
+  "dirty_worktree_handoff",
+  "stale_or_partial",
+  "ready_for_review",
+  "unknown_lifecycle"
+] as const;
+export type PreparedCardState = (typeof PREPARED_CARD_STATES)[number];
 export type PreparedCardKind = "codex_session";
 export type PreparedStateCoverage = "ok" | "partial" | "not_configured" | "unknown";
 
@@ -393,6 +408,7 @@ export type PreparedCardsReport = {
     stale: number;
     partial: number;
     unknown: number;
+    completed: number;
     lowConfidence: number;
   };
   cards: PreparedCard[];
@@ -3891,6 +3907,7 @@ export function getPreparedCards(db: LooDatabase, options: PreparedCardsOptions
   let stale = 0;
   let partial = 0;
   let unknown = 0;
+  let completed = 0;
   let lowConfidence = 0;
   for (const row of rows) {
     const card = publicPreparedCardFromRow(row);
@@ -3898,9 +3915,10 @@ export function getPreparedCards(db: LooDatabase, options: PreparedCardsOptions
       filteredUnsafeRows += 1;
       continue;
     }
-    if (card.stale) stale += 1;
-    if (card.state === "partial") partial += 1;
-    if (card.state === "unknown") unknown += 1;
+    if (card.stale || card.state === "stale") stale += 1;
+    if (preparedCardCountsAsPartialSummary(card.state)) partial += 1;
+    if (card.state === "unknown" || card.state === "unknown_lifecycle") unknown += 1;
+    if (card.state === "completed") completed += 1;
     if (card.confidence < 0.5) lowConfidence += 1;
     if (validCards.length < limit) validCards.push(card);
   }
@@ -3936,6 +3954,7 @@ export function getPreparedCards(db: LooDatabase, options: PreparedCardsOptions
       stale,
       partial,
       unknown,
+      completed,
       lowConfidence
     },
     cards: validCards,
@@ -4268,9 +4287,19 @@ function buildPreparedCardDraft(db: LooDatabase, threadId: string, leaves: Summa
   const watcherObservationsStatus = watcherObservationCoverageForTarget(db, targetRef);
   const freshnessAt = latestIso([...leaves.map((leaf) => leaf.freshnessAt), session?.updatedAt ?? null]);
   const stale = leaves.some((leaf) => leaf.stale);
+  const evidenceState: PreparedCardState = stale
+    ? "stale_or_partial"
+    : summaryLeavesStatus === "unknown"
+      ? "unknown_lifecycle"
+      : summaryLeavesStatus === "partial" || sessionMetadataStatus === "partial"
+        ? "stale_or_partial"
+        : "ready";
+  const lifecycle = preparedLifecycleFromMetadata(metadata, evidenceState);
+  const state = lifecycle.state;
   const reasonCodes = unique([
     leaves.length > 0 ? "summary_leaves_ready" : "summary_leaves_missing",
     "metadata_only",
+    ...lifecycle.reasonCodes,
     watcherObservationsStatus === "not_configured" ? "watcher_not_configured" : "watcher_observations_available",
     stale ? "stale_cache" : "",
     summaryLeavesStatus === "partial" ? "authority_partial" : "",
@@ -4280,17 +4309,10 @@ function buildPreparedCardDraft(db: LooDatabase, threadId: string, leaves: Summa
     watcherObservationsStatus === "unknown" ? "watcher_observations_unknown" : "",
     filteredUnsafeRows > 0 ? "filtered_unsafe_rows" : ""
   ].filter(Boolean));
-  const state: PreparedCardState = stale
-    ? "stale"
-    : summaryLeavesStatus === "unknown"
-      ? "unknown"
-      : summaryLeavesStatus === "partial" || sessionMetadataStatus === "partial"
-        ? "partial"
-        : "ready";
   const averageLeafConfidence = leaves.length
     ? leaves.reduce((sum, leaf) => sum + leaf.confidence, 0) / leaves.length
     : 0.3;
-  const confidence = preparedCardConfidence(averageLeafConfidence, state);
+  const confidence = preparedCardConfidence(averageLeafConfidence, state, evidenceState);
   const sourceRangeRefsFull = unique(leaves.flatMap((leaf) => leaf.sourceRangeRefs));
   const sourceRangeRefs = sourceRangeRefsFull.slice(0, PREPARED_CARD_SOURCE_RANGE_REF_LIMIT);
   const sourceRangeRefsOmitted = Math.max(0, sourceRangeRefsFull.length - sourceRangeRefs.length)
@@ -4305,7 +4327,7 @@ function buildPreparedCardDraft(db: LooDatabase, threadId: string, leaves: Summa
   });
   const title = looksSensitiveRefLike(cleanedTitle.text) ? publicSafeText(safeThreadId(threadId), 160) : cleanedTitle.text;
   const summaryText = publicSafeText(
-    `Prepared state: ${leaves.length} summary leaf${leaves.length === 1 ? "" : "s"} across ${Math.max(0, leafRangeCount)} prepared source range${leafRangeCount === 1 ? "" : "s"}.`,
+    `Prepared state: ${leaves.length} summary leaf${leaves.length === 1 ? "" : "s"} across ${Math.max(0, leafRangeCount)} prepared source range${leafRangeCount === 1 ? "" : "s"}. Lifecycle: ${preparedCardStateLabel(state)}.`,
     320
   );
   const nextAction = preparedCardNextAction(state);
@@ -4327,6 +4349,10 @@ function buildPreparedCardDraft(db: LooDatabase, threadId: string, leaves: Summa
     leafRefs: leaves.map((leaf) => leaf.leafRef),
     inputHashes: leaves.map((leaf) => leaf.inputHash),
     outputHashes: leaves.map((leaf) => leaf.outputHash),
+    metadataSignalHash: lifecycle.metadataSignalHash,
+    lifecycleState: state,
+    lifecycleReasonCodes: lifecycle.reasonCodes,
+    evidenceState,
     freshnessAt,
     stale,
     summaryLeavesStatus,
@@ -4363,7 +4389,7 @@ function buildPreparedCardDraft(db: LooDatabase, threadId: string, leaves: Summa
 function preparedInboxItemFromCard(card: PreparedCard): PreparedInboxItem {
   const reasonCodes = unique([
     ...card.reasonCodes,
-    card.state === "ready" ? "prepared_card_ready" : "needs_attention"
+    card.state === "ready" ? "prepared_card_ready" : card.state === "completed" ? "prepared_card_completed" : "needs_attention"
   ]);
   const urgencyScore = preparedInboxUrgencyScore(card, reasonCodes);
   return {
@@ -4642,7 +4668,7 @@ function getPreparedTargetCoverage(db: LooDatabase, threadId?: string): Prepared
     preparedSourceEvents: preparedSourceEvents.count > 0 ? "ok" : "not_configured",
     preparedSourceRanges: preparedSourceRanges.publicCount > 0 ? "ok" : preparedSourceRanges.rawCount > 0 ? "partial" : "not_configured",
     summaryLeaves: summaryLeaves.publicCount > 0 ? "ok" : summaryLeaves.rawCount > 0 ? "partial" : "not_configured",
-    preparedCards: publicCard ? publicCard.state === "ready" && !publicCard.stale ? "ok" : "partial" : preparedCards > 0 ? "partial" : "not_configured",
+    preparedCards: publicCard ? preparedTargetCardCoverage(publicCard) : preparedCards > 0 ? "partial" : "not_configured",
     preparedInboxItems: publicCard && preparedInboxItems.publicCount > 0 ? "ok" : preparedInboxItems.rawCount > 0 ? "partial" : "not_configured",
     watcherObservations: watcherObservationCoverageForTarget(db, targetRef)
   } satisfies PreparedTargetCoverage["sourceCoverage"];
@@ -4668,8 +4694,7 @@ function getPreparedTargetCoverage(db: LooDatabase, threadId?: string): Prepared
   const allDerivedLayersMissing = requiredCoverage.every((state) => state === "not_configured");
   const stale = Boolean(session && (
     missingDerivedCache
-    || publicCard?.stale
-    || publicCard?.state !== "ready"
+    || (publicCard ? preparedTargetCardCoverage(publicCard) !== "ok" : false)
     || summaryLeaves.staleCount > 0
     || (sourceUpdatedAt && preparedFreshnessAt && sourceUpdatedAt > preparedFreshnessAt)
   ));
@@ -4709,6 +4734,19 @@ function getPreparedTargetCoverage(db: LooDatabase, threadId?: string): Prepared
   };
 }
 
+function preparedTargetCardCoverage(card: PreparedCard): PreparedStateCoverage {
+  if (card.stale) return "partial";
+  return preparedCardStateHasFreshTargetCoverage(card.state) ? "ok" : "partial";
+}
+
+function preparedCardStateHasFreshTargetCoverage(state: PreparedCardState): boolean {
+  return state !== "stale"
+    && state !== "partial"
+    && state !== "stale_or_partial"
+    && state !== "unknown"
+    && state !== "unknown_lifecycle";
+}
+
 function countPreparedTargetRows(db: LooDatabase, sql: string, ...params: Array<string | number>): number {
   return Number((db.prepare(sql).get(...params) as { count: number } | undefined)?.count ?? 0);
 }
@@ -4911,7 +4949,7 @@ function preparedCoverageState(value: unknown): PreparedStateCoverage {
 }
 
 function isPreparedCardState(value: string): value is PreparedCardState {
-  return value === "ready" || value === "stale" || value === "partial" || value === "unknown";
+  return (PREPARED_CARD_STATES as readonly string[]).includes(value);
 }
 
 function isPublicPreparedSourceRef(value: string): boolean {
@@ -4933,11 +4971,139 @@ function isPublicCodexSubagentResultRef(value: string): boolean {
   return /^[A-Za-z0-9._:-]{1,160}$/.test(decodedId) && !looksSensitiveRefLike(decodedId);
 }
 
-function preparedCardConfidence(averageLeafConfidence: number, state: PreparedCardState): number {
+function preparedLifecycleFromMetadata(
+  metadata: SessionMetadata,
+  evidenceState: PreparedCardState
+): { state: PreparedCardState; reasonCodes: string[]; metadataSignalHash: string } {
+  const signals = {
+    status: normalizedMetadataValue(metadata.status),
+    blocker: normalizedMetadataValue(metadata.blocker),
+    nextAction: normalizedMetadataValue(metadata.nextAction),
+    closeoutState: normalizedMetadataValue(metadata.closeoutState),
+    planCompletionState: normalizedMetadataValue(metadata.planCompletionState)
+  };
+  const metadataSignalHash = stableId(JSON.stringify(signals));
+  const nonBlockerText = [signals.status, signals.nextAction, signals.closeoutState, signals.planCompletionState].filter(Boolean).join(" ");
+  const text = [nonBlockerText, signals.blocker].filter(Boolean).join(" ");
+  const sourceReasonCodes = Object.entries(signals)
+    .filter(([, value]) => value.length > 0)
+    .map(([field]) => `lifecycle_signal:${field.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`)}`);
+  const completedByStatus = lifecycleCompletionLike(signals.status);
+  const completedByCloseoutAndPlan = lifecycleCompletionLike(signals.closeoutState)
+    && lifecycleCompletionLike(signals.planCompletionState);
+  const completed = completedByStatus || completedByCloseoutAndPlan;
+  const dirtyHandoff = /\b(?:dirty[-_ ]?worktree|uncommitted|worktree[-_ ]?handoff|dirty[-_ ]?handoff|handoff[-_ ]?dirty|cleanup[-_ ]?required)\b/.test(text);
+  const waitingApproval = /\b(?:waiting[-_ ]?(?:for[-_ ]?)?approval|needs[-_ ]?approval|requires[-_ ]?approval|approval[-_ ]?(?:required|needed|pending)|pending[-_ ]?approval|approval[-_ ]?gate|do[-_ ]?not[-_ ]?execute[-_ ]?without[-_ ]?explicit[-_ ]?approval)\b/.test(text);
+  const needsResume = /\b(?:needs[-_ ]?(?:to[-_ ]?)?resume|resume[-_ ]?(?:session|thread|work|run|lane|needed|required|requested|request)|continue[-_ ]?(?:session|thread|lane)|nudge[-_ ]?(?:session|thread|agent|lane)|rejoin[-_ ]?(?:session|thread|lane))\b/.test(text);
+  const watchingExternalCheck = /\b(?:(?:watch|watching|monitor|monitoring)[-_ ]+(?:ci|checks?|codeql|coderabbit|deploy(?:[-_ ]?check)?|external[-_ ]?(?:check|review)|review[-_ ]?check)|(?:waiting[-_ ]?(?:on|for)|pending)[-_ ]+(?:ci|checks?|codeql|coderabbit|deploy|external[-_ ]?check|review[-_ ]?check)|(?:ci|checks?|codeql|coderabbit|deploy[-_ ]?check|review[-_ ]?check)[-_ ]+(?:pending|queued|running|failing|failed|blocked|red|not[-_ ]?green|in[-_ ]?progress))\b/.test(text);
+  const readyForReview = /\b(?:ready[-_ ]?for[-_ ]?review|review[-_ ]?ready|ready[-_ ]?to[-_ ]?review|pr[-_ ]?ready|needs[-_ ]?review)\b/.test(text);
+  const negatedBlocker = /\b(?:not[-_ ]?blocked|no[-_ ]?blocker|unblocked|without[-_ ]?blocker|blocker[-_ ]?(?:none|na|n[-_ ]?a))\b/.test(text);
+  const missingInfoSignal = /\b(?:missing[-_ ]?(?:info|input|context)|needs[-_ ]?(?:info|input|context)|waiting[-_ ]?(?:on|for)[-_ ]?(?:user|operator|human|input|context)|cannot[-_ ]?proceed)\b/.test(nonBlockerText);
+  const blockedSignal = !negatedBlocker && /\b(?:blocked|blocker)\b/.test(nonBlockerText);
+  const blockedMissingInfo = !waitingApproval
+    && !dirtyHandoff
+    && !watchingExternalCheck
+    && !negatedBlocker
+    && (hasRealBlocker(metadata.blocker) || missingInfoSignal || blockedSignal);
+  const matchedLifecycleStates: PreparedCardState[] = [
+    completed ? "completed" : null,
+    dirtyHandoff ? "dirty_worktree_handoff" : null,
+    waitingApproval ? "waiting_approval" : null,
+    blockedMissingInfo ? "blocked_missing_info" : null,
+    needsResume ? "needs_resume" : null,
+    watchingExternalCheck ? "watching_external_check" : null,
+    readyForReview ? "ready_for_review" : null
+  ].filter((state): state is PreparedCardState => Boolean(state));
+  const evidenceReasonCodes = evidenceState !== "ready" ? [`lifecycle:${evidenceState}`] : [];
+  const conflict = completed && matchedLifecycleStates.some((state) => state !== "completed");
+  if (conflict) {
+    return {
+      state: "unknown_lifecycle",
+      reasonCodes: unique([
+        "semantic_lifecycle",
+        "lifecycle:unknown_lifecycle",
+        "lifecycle_conflict",
+        ...matchedLifecycleStates.map((state) => `lifecycle:${state}`),
+        ...evidenceReasonCodes,
+        ...sourceReasonCodes
+      ]),
+      metadataSignalHash
+    };
+  }
+  const semanticState: PreparedCardState | null = dirtyHandoff
+    ? "dirty_worktree_handoff"
+    : waitingApproval
+      ? "waiting_approval"
+      : blockedMissingInfo
+        ? "blocked_missing_info"
+        : needsResume
+          ? "needs_resume"
+          : watchingExternalCheck
+            ? "watching_external_check"
+            : readyForReview
+              ? "ready_for_review"
+              : completed
+                ? "completed"
+                : null;
+  if (semanticState === "completed" && evidenceState !== "ready") {
+    return {
+      state: evidenceState,
+      reasonCodes: unique(["semantic_lifecycle", "lifecycle:completed", `lifecycle:${evidenceState}`, ...sourceReasonCodes]),
+      metadataSignalHash
+    };
+  }
+  if (semanticState) {
+    return {
+      state: semanticState,
+      reasonCodes: unique(["semantic_lifecycle", `lifecycle:${semanticState}`, ...evidenceReasonCodes, ...sourceReasonCodes]),
+      metadataSignalHash
+    };
+  }
+  if (evidenceState !== "ready") {
+    return {
+      state: evidenceState,
+      reasonCodes: unique(["semantic_lifecycle", `lifecycle:${evidenceState}`, "lifecycle_signal_missing", ...sourceReasonCodes]),
+      metadataSignalHash
+    };
+  }
+  return {
+    state: "ready",
+    reasonCodes: unique(["semantic_lifecycle", "lifecycle:unknown_lifecycle", "lifecycle_signal_missing"]),
+    metadataSignalHash
+  };
+}
+
+function lifecycleCompletionLike(value: string): boolean {
+  return ["complete", "completed", "done", "closed", "merged", "success", "successful", "succeeded", "passed"].includes(value);
+}
+
+function preparedCardStateLabel(state: PreparedCardState): string {
+  return ({
+    ready: "evidence ready, lifecycle unknown",
+    stale: "stale evidence",
+    partial: "partial evidence",
+    unknown: "unknown evidence",
+    completed: "completed",
+    blocked_missing_info: "blocked missing info",
+    waiting_approval: "waiting approval",
+    watching_external_check: "watching external check",
+    needs_resume: "needs resume",
+    dirty_worktree_handoff: "dirty worktree handoff",
+    stale_or_partial: "stale or partial",
+    ready_for_review: "ready for review",
+    unknown_lifecycle: "unknown lifecycle"
+  } as Record<PreparedCardState, string>)[state] ?? "unknown lifecycle";
+}
+
+function preparedCardConfidence(averageLeafConfidence: number, state: PreparedCardState, evidenceState: PreparedCardState = state): number {
   let confidence = Number.isFinite(averageLeafConfidence) ? averageLeafConfidence : 0.3;
   if (state === "partial") confidence = Math.min(confidence, 0.49);
   if (state === "stale") confidence = Math.min(confidence, 0.49);
   if (state === "unknown") confidence = Math.min(confidence, 0.44);
+  if (state === "stale_or_partial") confidence = Math.min(confidence, 0.49);
+  if (state === "unknown_lifecycle") confidence = Math.min(confidence, 0.44);
+  if (evidenceState === "partial" || evidenceState === "stale" || evidenceState === "stale_or_partial") confidence = Math.min(confidence, 0.49);
+  if (evidenceState === "unknown" || evidenceState === "unknown_lifecycle") confidence = Math.min(confidence, 0.44);
   return Math.max(0.2, Math.min(0.99, Number(confidence.toFixed(2))));
 }
 
@@ -4945,15 +5111,33 @@ function preparedCardNextAction(state: PreparedCardState): string {
   if (state === "ready") return "Use loo_summary_expand for bounded evidence before deciding whether broader session expansion is needed.";
   if (state === "stale") return "Refresh the local prepared-state cache before treating this card as current.";
   if (state === "partial") return "Inspect source coverage and summary leaves before relying on this prepared card.";
+  if (state === "completed") return "No action is needed unless bounded evidence contradicts the completed lifecycle state.";
+  if (state === "blocked_missing_info") return "Inspect bounded evidence and resolve the missing input or blocker before resuming.";
+  if (state === "waiting_approval") return "Inspect the bounded approval context; do not execute without explicit approval.";
+  if (state === "watching_external_check") return "Refresh external check or watcher evidence before deciding the next action.";
+  if (state === "needs_resume") return "Inspect bounded evidence and resume only through the approval-gated control path.";
+  if (state === "dirty_worktree_handoff") return "Inspect handoff evidence and clean or transfer the dirty worktree deliberately.";
+  if (state === "stale_or_partial") return "Refresh or inspect partial prepared-state evidence before relying on this lifecycle card.";
+  if (state === "ready_for_review") return "Review bounded evidence and source refs before marking the lane complete.";
+  if (state === "unknown_lifecycle") return "Inspect summary leaves and session metadata; lifecycle signals are missing or conflicting.";
   return "Inspect summary leaves and source coverage; missing or conflicting authority prevents a ready claim.";
 }
 
 function preparedInboxUrgencyScore(card: PreparedCard, reasonCodes: string[]): number {
   const stateScore = {
     unknown: 88,
+    unknown_lifecycle: 60,
     stale: 82,
+    stale_or_partial: 74,
     partial: 74,
-    ready: 42
+    blocked_missing_info: 94,
+    waiting_approval: 92,
+    dirty_worktree_handoff: 89,
+    watching_external_check: 78,
+    needs_resume: 76,
+    ready_for_review: 68,
+    ready: 42,
+    completed: 18
   } as const;
   const codeScore = reasonCodes.reduce((score, code) => score + ({
     authority_unknown: 8,
@@ -4961,9 +5145,27 @@ function preparedInboxUrgencyScore(card: PreparedCard, reasonCodes: string[]): n
     stale_cache: 8,
     low_confidence: 6,
     filtered_unsafe_rows: 5,
-    needs_attention: 4
+    needs_attention: 4,
+    "lifecycle_conflict": 10,
+    "lifecycle:blocked_missing_info": 8,
+    "lifecycle:waiting_approval": 7,
+    "lifecycle:dirty_worktree_handoff": 7,
+    "lifecycle:watching_external_check": 5,
+    "lifecycle:needs_resume": 5
   }[code] ?? 0), 0);
-  return Math.max(0, Math.min(100, Number((stateScore[card.state] + codeScore + Math.round((1 - card.confidence) * 10)).toFixed(2))));
+  const baseStateScore = stateScore[card.state] ?? 50;
+  return Math.max(0, Math.min(100, Number((baseStateScore + codeScore + Math.round((1 - card.confidence) * 10)).toFixed(2))));
+}
+
+function preparedCardCountsAsPartialSummary(state: PreparedCardState): boolean {
+  return state === "partial"
+    || state === "stale_or_partial"
+    || state === "blocked_missing_info"
+    || state === "waiting_approval"
+    || state === "watching_external_check"
+    || state === "needs_resume"
+    || state === "dirty_worktree_handoff"
+    || state === "ready_for_review";
 }
 
 function preparedCardReadActions(): PreparedCardsReport["actionsPerformed"] {

package/packages/mcp-server/src/tools.ts

@@ -22,6 +22,7 @@ import {
   getPreparedCards,
   getPreparedInbox,
   getPreparedStateStatus,
+  PREPARED_CARD_STATES,
   getWatcherEvents,
   createPlanStatePinsReport,
   createGithubOperatingItemsReport,
@@ -406,7 +407,7 @@ export function createLooTools(options: { db: LooDatabase; audit: AuditStore; co
     })),
     tool("loo_prepared_cards", "List public-safe prepared Codex state cards over summary leaves.", {
       thread_id: { type: "string" },
-      state: { type: "string", enum: ["ready", "stale", "partial", "unknown"] },
+      state: { type: "string", enum: [...PREPARED_CARD_STATES] },
       limit: { type: "integer", minimum: 1, maximum: 500 }
     }, (input) => getPreparedCards(options.db, {
       threadId: optionalString(input.thread_id),
@@ -1544,8 +1545,8 @@ function optionalSummaryLeafKind(value: unknown): SummaryLeafKind | undefined {
 
 function optionalPreparedCardState(value: unknown): PreparedCardState | undefined {
   if (value === undefined) return undefined;
-  if (value === "ready" || value === "stale" || value === "partial" || value === "unknown") return value;
-  throw new Error("state must be ready, stale, partial, or unknown");
+  if (typeof value === "string" && (PREPARED_CARD_STATES as readonly string[]).includes(value)) return value as PreparedCardState;
+  throw new Error(`state must be one of ${PREPARED_CARD_STATES.join(", ")}`);
 }
 
 function optionalRecentScope(value: unknown): "active" | "recent" | "all" | undefined {

package/packages/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "lossless-openclaw-orchestrator",
   "name": "Lossless OpenClaw Orchestrator",
   "description": "Control and collaborate with local Codex sessions through OpenClaw using local indexing, bounded recall, and approval-gated controls.",
-  "version": "1.2.0-beta.2",
+  "version": "1.2.0-beta.3",
   "kind": "tool",
   "tools": {
     "prefix": "loo_"
@@ -477,7 +477,16 @@
                 "ready",
                 "stale",
                 "partial",
-                "unknown"
+                "unknown",
+                "completed",
+                "blocked_missing_info",
+                "waiting_approval",
+                "watching_external_check",
+                "needs_resume",
+                "dirty_worktree_handoff",
+                "stale_or_partial",
+                "ready_for_review",
+                "unknown_lifecycle"
               ]
             },
             "limit": {