@tea-agent/loop-agent 0.44.0-next.3 → 0.44.0-next.5

package/dist/worker/console/static-src/operator-chat/process-label.js

@@ -9,11 +9,15 @@ import { isSubagentTool } from "../../chat/tool-preview.js";
  * @returns the three bucket counts.
  */
 export function countTurnProcessItems(items) {
+    return countEntries(items.map((item) => ({ source: "process", item })));
+}
+function countEntries(entries) {
     let toolCalls = 0;
     let messages = 0;
     let subagents = 0;
-    for (const item of items) {
-        if (item.kind === "tool") {
+    for (const entry of entries) {
+        if (entry.source === "process" && entry.item.kind === "tool") {
+            const item = entry.item;
             if (isSubagentTool(item.tool.toolName))
                 subagents += 1;
             else
@@ -24,6 +28,11 @@ export function countTurnProcessItems(items) {
     }
     return { toolCalls, messages, subagents };
 }
+/** Count only the ordered process window; prelude/post-answer nodes are kept
+ * visible but do not inflate the DSH compact disclosure summary. */
+export function countTurnFlowItems(entries) {
+    return countEntries(entries);
+}
 /**
  * Summary label for a completed turn's process disclosure.
  *

package/dist/worker/console/static-src/operator-chat/turn-group-equality.js

@@ -9,5 +9,6 @@ export function sameTurnGroupInputs(previous, next) {
         previous.user === next.user &&
         previous.live === next.live &&
         sameReferences(previous.assistants, next.assistants) &&
-        sameReferences(previous.tools, next.tools));
+        sameReferences(previous.tools, next.tools) &&
+        sameReferences(previous.conversationItems ?? [], next.conversationItems ?? []));
 }

package/dist/worker/console/static-src/operator-chat/useChatSessions.js

@@ -501,6 +501,7 @@ export function useChatSessions(params) {
             applyActivatedSession({
                 messages: hydrated.messages,
                 toolCalls: hydrated.toolCalls,
+                conversationEvents: body.conversationEvents,
                 sessionStats: body.sessionStats,
                 usage: body.usage,
                 turnTelemetry: body.turnTelemetry,
@@ -636,6 +637,7 @@ export function useChatSessions(params) {
                 applyActivatedSession({
                     messages: hydrated.messages,
                     toolCalls: hydrated.toolCalls,
+                    conversationEvents: body.conversationEvents,
                     sessionStats: body.sessionStats,
                     usage: body.usage,
                     turnTelemetry: body.turnTelemetry,

package/dist/worker/console/static-src/operator-chat/useChatThread.js

@@ -8,6 +8,7 @@ import { mergePendingSubmissionOnHydration } from "./pending-user-message.js";
 import { taskContextUnchanged } from "./format.js";
 import { upsertCompactionMessage } from "./compaction-message.js";
 import { sameTurnGroupInputs } from "./turn-group-equality.js";
+import { conversationNodesFromEvents, } from "../../chat/conversation-nodes.js";
 const EMPTY_USAGE = {
     inputTokens: 0,
     outputTokens: 0,
@@ -141,6 +142,7 @@ export function useChatThread(params) {
     const [sessionStats, setSessionStats] = useState(EMPTY_SESSION_STATS);
     const [turnTelemetry, setTurnTelemetry] = useState([]);
     const [operatorActions, setOperatorActions] = useState([]);
+    const [conversationNodes, setConversationNodes] = useState([]);
     const [sddSessionIdentity, setSddSessionIdentity] = useState(null);
     const [streaming, setStreaming] = useState(false);
     const [turnPhase, setTurnPhase] = useState("idle");
@@ -192,6 +194,7 @@ export function useChatThread(params) {
         setTodos,
         setGoal,
         setOperatorActions,
+        setConversationNodes,
         setSddSessionIdentity,
         setStreamingAssistantId,
         setUnread,
@@ -330,6 +333,7 @@ export function useChatThread(params) {
             toolCalls,
             streaming,
             activeAssistantId: streamingAssistantId,
+            conversationNodes,
         });
         // Preserve completed group objects across streaming tokens. Stable
         // historical groups keep their references so
@@ -348,6 +352,7 @@ export function useChatThread(params) {
         toolCalls,
         streaming,
         streamingAssistantId,
+        conversationNodes,
         historyLimit,
     ]);
     const loadEarlierMessages = useCallback(async (beforePrepend) => {
@@ -427,6 +432,7 @@ export function useChatThread(params) {
         setSessionStats(EMPTY_SESSION_STATS);
         setTurnTelemetry([]);
         setOperatorActions([]);
+        setConversationNodes([]);
         setSddSessionIdentity(null);
         setStreaming(false);
         setTurnPhase("idle");
@@ -476,6 +482,7 @@ export function useChatThread(params) {
             }
             : undefined));
         setToolCalls(next.toolCalls);
+        setConversationNodes(conversationNodesFromEvents(next.conversationEvents ?? []));
         setOperationCards([]);
         setHumanGateCards([]);
         setArtifactCards([]);
@@ -546,6 +553,7 @@ export function useChatThread(params) {
             refs.turnAssistantIdsRef.current = new Map();
             refs.sealedAssistantIdsRef.current = new Set();
             const hydrated = hydrateSessionThread(body.session.messages ?? []);
+            setConversationNodes(conversationNodesFromEvents(body.conversationEvents ?? []));
             // Recovery is addressed to targetSessionId, so an optimistic
             // submission from another session must never be projected into
             // this snapshot (the activation path enforces the same owner gate).
@@ -618,6 +626,7 @@ export function useChatThread(params) {
         sessionStats,
         turnTelemetry,
         operatorActions,
+        conversationNodes,
         sddSessionIdentity,
         setSddSessionIdentity,
         streaming,

package/dist/worker/observe/node-context-insights.js

@@ -0,0 +1,479 @@
+/**
+ * Read-only context insights projection for a DAG node attempt — the
+ * loop-agent counterpart of the dsh-context dashboard, built exclusively from
+ * recorded run facts:
+ *
+ *   - context receipt (`<node>/context-receipts/attempt-N.json`) → composition
+ *   - session events (`<node>/session-events.jsonl`) → per-request usage
+ *     trend, tool activity, file footprint, timing
+ *   - node record (`<node>.json`) → skill injection footprint, headline totals
+ *
+ * Everything is derived deterministically from persisted facts; nothing is
+ * estimated beyond what the recorded bytes already contain. All projections are
+ * read-only, bounded, and redaction-preserving (paths already pass through
+ * redactSecrets in node-transparency before reaching here for receipt data;
+ * file-activity paths are redacted in this module).
+ */
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { redactSecrets } from "../../shared/preview.js";
+import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
+import { resolveDagRunArtifact, resolveDagRunJson, } from "./dag-run-artifacts.js";
+export const NODE_CONTEXT_INSIGHTS_SCHEMA_VERSION = 1;
+/** Upper bound on session-event lines scanned per attempt (defensive). */
+const SESSION_EVENT_LINE_LIMIT = 50_000;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asInt(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? value
+        : null;
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+/** Minimal per-line JSON parse (session events are JSONL). */
+function parseSessionEventLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function messageOf(event) {
+    const message = event.message;
+    return isRecord(message) ? message : null;
+}
+function contentBlocksOf(message) {
+    const content = message?.content;
+    return Array.isArray(content) ? content : [];
+}
+function usageOf(message) {
+    const usage = message?.usage;
+    return isRecord(usage) ? usage : null;
+}
+function toolNameOfArgs(args) {
+    for (const key of ["path", "file", "file_path", "filePath"]) {
+        const value = args[key];
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return null;
+}
+function searchTargetsOfArgs(args) {
+    const targets = [];
+    const push = (value) => {
+        if (typeof value === "string" && value.length > 0)
+            targets.push(value);
+    };
+    push(args.path);
+    push(args.directory);
+    push(args.dir);
+    const pattern = asString(args.pattern) ?? asString(args.query);
+    if (pattern)
+        targets.push(`pattern:${pattern.slice(0, 120)}`);
+    return targets;
+}
+/** Extract referenced file paths from a bash command string (best effort). */
+function filesFromCommand(command) {
+    const files = [];
+    const patterns = [
+        /(?:^|\s)(?:cat|head|tail|less|more)\s+([^\s;&|]+)/g,
+        /(?:^|\s)(?:rg|grep|find|fd|ls)\s+.*?([^\s;&|]*\.[A-Za-z0-9]{1,8})/g,
+        /(?:^|\s)(?:sed|awk|sort|uniq|wc)\s+.*?([^\s;&|]*\.[A-Za-z0-9]{1,8})/g,
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(command)) !== null) {
+            const candidate = match[1];
+            if (candidate && candidate.length > 1)
+                files.push(candidate);
+        }
+    }
+    return files;
+}
+function classifyFileOp(toolName) {
+    const name = toolName.toLowerCase();
+    if (["read", "read_file", "readfile", "view"].includes(name))
+        return "read";
+    if (["write", "write_file", "writefile", "create"].includes(name))
+        return "write";
+    if (["edit", "str_replace", "str_replace_editor", "apply_patch"].includes(name))
+        return "edit";
+    if (["grep", "rg", "find", "fd", "search", "glob", "list", "ls"].includes(name))
+        return "search";
+    return null;
+}
+function normalizeRepoPath(raw, repoRoot) {
+    let value = raw;
+    const resolvedRoot = path.resolve(repoRoot);
+    const rootVariants = [
+        resolvedRoot,
+        resolvedRoot.replace(/\\/g, "/"),
+        resolvedRoot.replace(/\\/g, "/").toLowerCase(),
+    ];
+    for (const variant of rootVariants) {
+        if (value.toLowerCase().startsWith(`${variant.toLowerCase()}\\`) ||
+            value.toLowerCase().startsWith(`${variant.toLowerCase()}/`)) {
+            value = value.slice(variant.length + 1);
+            break;
+        }
+        if (value.toLowerCase() === variant.toLowerCase()) {
+            value = ".";
+            break;
+        }
+    }
+    return value.replace(/\\/g, "/");
+}
+function accumulateFileActivity(fileActivity, key, op) {
+    const existing = fileActivity.get(key) ?? {
+        path: key,
+        reads: 0,
+        writes: 0,
+        edits: 0,
+        searches: 0,
+    };
+    if (op === "read")
+        existing.reads += 1;
+    else if (op === "write")
+        existing.writes += 1;
+    else if (op === "edit")
+        existing.edits += 1;
+    else
+        existing.searches += 1;
+    fileActivity.set(key, existing);
+}
+/**
+ * Pure projection over parsed session events. Exported for unit tests.
+ */
+export function projectSessionInsights(events, repoRoot) {
+    let requestCount = 0;
+    let toolCalls = 0;
+    let toolErrors = 0;
+    let humanInputs = 0;
+    let thinkingSteps = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
+    let cacheSamples = 0;
+    let cacheHits = 0;
+    const requests = [];
+    const toolCounters = new Map();
+    const fileActivity = new Map();
+    // Tool calls issued in the current in-flight model request (reset per
+    // assistant message_end) so each request row attributes its own calls.
+    let pendingToolCalls = 0;
+    let pendingThinking = false;
+    for (const event of events) {
+        if (!event)
+            continue;
+        const type = asString(event.type);
+        if (type === "tool_execution_start") {
+            toolCalls += 1;
+            pendingToolCalls += 1;
+            const toolName = asString(event.toolName) ?? "unknown";
+            const row = toolCounters.get(toolName) ?? {
+                toolName,
+                calls: 0,
+                errors: 0,
+            };
+            row.calls += 1;
+            toolCounters.set(toolName, row);
+            const args = isRecord(event.args) ? event.args : {};
+            const op = classifyFileOp(toolName);
+            if (op === "read" || op === "write" || op === "edit") {
+                const target = toolNameOfArgs(args);
+                if (target) {
+                    accumulateFileActivity(fileActivity, normalizeRepoPath(redactSecrets(target), repoRoot), op);
+                }
+            }
+            else if (op === "search") {
+                for (const target of searchTargetsOfArgs(args)) {
+                    accumulateFileActivity(fileActivity, normalizeRepoPath(redactSecrets(target), repoRoot), "search");
+                }
+            }
+            else if (toolName.toLowerCase() === "bash") {
+                const command = asString(args.command) ?? "";
+                for (const file of filesFromCommand(command)) {
+                    accumulateFileActivity(fileActivity, normalizeRepoPath(redactSecrets(file), repoRoot), "search");
+                }
+            }
+            continue;
+        }
+        if (type === "tool_execution_end") {
+            if (event.isError === true)
+                toolErrors += 1;
+            continue;
+        }
+        const message = messageOf(event);
+        if (!message)
+            continue;
+        const role = asString(message.role);
+        if (type === "message_start" && role === "assistant") {
+            // A new model request begins.
+            requestCount += 1;
+            pendingToolCalls = 0;
+            pendingThinking = false;
+            continue;
+        }
+        if (type === "message_end" && role === "assistant") {
+            for (const block of contentBlocksOf(message)) {
+                if (isRecord(block) && asString(block.type) === "thinking") {
+                    thinkingSteps += 1;
+                    pendingThinking = true;
+                }
+            }
+            const usage = usageOf(message);
+            const input = asInt(usage?.input);
+            const output = asInt(usage?.output);
+            const cacheRead = asInt(usage?.cacheRead);
+            const cacheWrite = asInt(usage?.cacheWrite);
+            if (usage && (input ?? 0) + (cacheRead ?? 0) > 0) {
+                cacheSamples += 1;
+                if ((cacheRead ?? 0) > 0)
+                    cacheHits += 1;
+            }
+            if (input != null)
+                inputTokens += input;
+            if (output != null)
+                outputTokens += output;
+            if (cacheRead != null)
+                cacheReadTokens += cacheRead;
+            if (cacheWrite != null)
+                cacheWriteTokens += cacheWrite;
+            requests.push({
+                request: requestCount,
+                recordedAt: asString(event.recordedAt),
+                model: asString(message.model),
+                provider: asString(message.provider),
+                usage: usage == null
+                    ? null
+                    : {
+                        input,
+                        output,
+                        cacheRead,
+                        cacheWrite,
+                        totalTokens: asInt(usage.totalTokens),
+                    },
+                stopReason: asString(message.stopReason),
+                toolCalls: pendingToolCalls,
+                thinking: pendingThinking,
+            });
+            pendingToolCalls = 0;
+            pendingThinking = false;
+            continue;
+        }
+        if (type === "message_end" && role === "user") {
+            humanInputs += 1;
+        }
+    }
+    const toolActivity = [...toolCounters.values()].sort((a, b) => b.calls - a.calls || a.toolName.localeCompare(b.toolName));
+    const fileActivityRows = [...fileActivity.values()].sort((a, b) => b.reads + b.writes + b.edits + b.searches -
+        (a.reads + a.writes + a.edits + a.searches) ||
+        a.path.localeCompare(b.path));
+    return {
+        requests,
+        toolActivity,
+        fileActivity: fileActivityRows,
+        stats: {
+            requests: requestCount,
+            toolCalls,
+            toolErrors,
+            humanInputs,
+            thinkingSteps,
+            cacheHitRate: cacheSamples > 0 ? cacheHits / cacheSamples : null,
+            inputTokens,
+            outputTokens,
+            cacheReadTokens,
+            cacheWriteTokens,
+        },
+    };
+}
+export async function loadDagNodeContextInsights(repoRoot, dagRunId, nodeId, attempt) {
+    if (!isSafeObservabilityIdentifier(dagRunId)) {
+        return {
+            status: 400,
+            body: { error: "Invalid DAG run identifier", reason: "invalid-id" },
+        };
+    }
+    if (!isSafeObservabilityIdentifier(nodeId)) {
+        return {
+            status: 400,
+            body: { error: "Invalid node identifier", reason: "invalid-id" },
+        };
+    }
+    const resolvedRun = resolveDagRunJson(repoRoot, dagRunId);
+    if (!resolvedRun.ok) {
+        return {
+            status: resolvedRun.reason === "invalid-id" ? 400 : 404,
+            body: { error: "DAG run not found", reason: resolvedRun.reason },
+        };
+    }
+    // Node record (<nodeId>.json) carries attempt metadata + headline totals.
+    const recordResolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        `${nodeId}.json`,
+    ]);
+    let nodeRecord = null;
+    if (recordResolved.ok) {
+        try {
+            const raw = JSON.parse(await readFile(recordResolved.result.absolutePath, "utf8"));
+            if (isRecord(raw))
+                nodeRecord = raw;
+        }
+        catch {
+            nodeRecord = null;
+        }
+    }
+    const selectedAttempt = normalizeAttemptNumber(attempt, nodeRecord);
+    // Context receipt composition.
+    const receiptResolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "context-receipts",
+        `attempt-${selectedAttempt}.json`,
+    ]);
+    let composition = null;
+    if (receiptResolved.ok) {
+        try {
+            const raw = JSON.parse(await readFile(receiptResolved.result.absolutePath, "utf8"));
+            if (isRecord(raw) && Array.isArray(raw.orderedComponents)) {
+                const byKind = new Map();
+                for (const entry of raw.orderedComponents) {
+                    if (!isRecord(entry))
+                        continue;
+                    const kind = asString(entry.kind);
+                    const bytes = asInt(entry.bytes) ?? 0;
+                    if (!kind)
+                        continue;
+                    const slice = byKind.get(kind) ?? { kind, items: 0, bytes: 0 };
+                    slice.items += 1;
+                    slice.bytes += bytes;
+                    byKind.set(kind, slice);
+                }
+                composition = [...byKind.values()].sort((a, b) => b.bytes - a.bytes);
+            }
+        }
+        catch {
+            composition = null;
+        }
+    }
+    // Session events for the node (single file across attempts in v1 format).
+    const sessionResolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "session-events.jsonl",
+    ]);
+    let sessionProjection = null;
+    if (sessionResolved.ok) {
+        try {
+            const raw = await readFile(sessionResolved.result.absolutePath, "utf8");
+            const lines = raw.split("\n").slice(0, SESSION_EVENT_LINE_LIMIT);
+            const events = lines
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .map(parseSessionEventLine);
+            sessionProjection = projectSessionInsights(events, repoRoot);
+        }
+        catch {
+            sessionProjection = null;
+        }
+    }
+    const attemptRecord = findAttemptRecord(nodeRecord, selectedAttempt);
+    const timing = timingFromRecords(nodeRecord, attemptRecord);
+    const skills = skillInjectionsOf(nodeRecord);
+    const body = {
+        schemaVersion: NODE_CONTEXT_INSIGHTS_SCHEMA_VERSION,
+        dagRunId,
+        nodeId,
+        attempt: selectedAttempt,
+        generatedFrom: {
+            sessionEvents: sessionProjection != null,
+            contextReceipt: composition != null,
+            nodeRecord: nodeRecord != null,
+        },
+        stats: {
+            requests: sessionProjection?.stats.requests ?? 0,
+            toolCalls: sessionProjection?.stats.toolCalls ?? 0,
+            toolErrors: sessionProjection?.stats.toolErrors ?? 0,
+            humanInputs: sessionProjection?.stats.humanInputs ?? 0,
+            thinkingSteps: sessionProjection?.stats.thinkingSteps ?? 0,
+            tokensUsed: asInt(attemptRecord?.tokensUsed) ?? asInt(nodeRecord?.tokensUsed),
+            parsedEvents: asInt(attemptRecord?.parsedEvents) ?? asInt(nodeRecord?.parsedEvents),
+            writeToolCallCount: asInt(attemptRecord?.writeToolCallCount) ??
+                asInt(nodeRecord?.writeToolCallCount),
+            cacheHitRate: sessionProjection?.stats.cacheHitRate ?? null,
+            inputTokens: sessionProjection?.stats.inputTokens ?? null,
+            outputTokens: sessionProjection?.stats.outputTokens ?? null,
+            cacheReadTokens: sessionProjection?.stats.cacheReadTokens ?? null,
+            cacheWriteTokens: sessionProjection?.stats.cacheWriteTokens ?? null,
+        },
+        timing,
+        composition,
+        skills,
+        toolActivity: sessionProjection?.toolActivity ?? [],
+        fileActivity: sessionProjection?.fileActivity ?? [],
+        usageTrend: sessionProjection?.requests ?? [],
+    };
+    return { status: 200, body };
+}
+function normalizeAttemptNumber(rawAttempt, nodeRecord) {
+    if (Number.isSafeInteger(rawAttempt) && (rawAttempt ?? 0) > 0) {
+        return rawAttempt;
+    }
+    if (typeof nodeRecord?.currentAttempt === "number" &&
+        Number.isSafeInteger(nodeRecord.currentAttempt) &&
+        nodeRecord.currentAttempt > 0) {
+        return nodeRecord.currentAttempt;
+    }
+    return 1;
+}
+function findAttemptRecord(nodeRecord, attempt) {
+    if (!nodeRecord)
+        return null;
+    const attempts = nodeRecord.attempts;
+    if (!Array.isArray(attempts))
+        return null;
+    for (const entry of attempts) {
+        if (isRecord(entry) && entry.attempt === attempt)
+            return entry;
+    }
+    return null;
+}
+function timingFromRecords(nodeRecord, attemptRecord) {
+    const attemptTiming = isRecord(attemptRecord?.timing)
+        ? attemptRecord.timing
+        : null;
+    const nodeTiming = isRecord(nodeRecord?.timing)
+        ? nodeRecord.timing
+        : null;
+    return {
+        startedAt: asString(attemptRecord?.startedAt) ?? asString(nodeRecord?.startedAt),
+        finishedAt: asString(attemptRecord?.finishedAt) ?? asString(nodeRecord?.finishedAt),
+        durationMs: asInt(attemptRecord?.durationMs) ?? asInt(nodeRecord?.durationMs),
+        executorDurationMs: asInt(attemptTiming?.executorDurationMs) ??
+            asInt(nodeTiming?.executorDurationMs),
+    };
+}
+function skillInjectionsOf(nodeRecord) {
+    const raw = nodeRecord?.resolvedSkills;
+    if (!Array.isArray(raw))
+        return [];
+    const skills = [];
+    for (const entry of raw) {
+        if (!isRecord(entry))
+            continue;
+        const name = asString(entry.name);
+        if (!name)
+            continue;
+        skills.push({
+            name,
+            resolution: asString(entry.resolution) ?? "unknown",
+            bytes: asInt(entry.bytes),
+            truncated: entry.truncated === true,
+            injectionMode: asString(entry.injectionMode),
+        });
+    }
+    return skills;
+}

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -619,13 +619,15 @@ export function composeDependencyPolicyWithBoundary(policy, boundary) {
         return policy;
     const allowed = (boundary.allowed ?? []).filter((item) => item.trim());
     const forbidden = (boundary.forbidden ?? []).filter((item) => item.trim());
-    if (allowed.length === 0 && forbidden.length === 0)
+    const requiredClauses = (boundary.requiredClauses ?? []).filter((item) => item.trim());
+    if (allowed.length === 0 && forbidden.length === 0 && requiredClauses.length === 0)
         return policy;
     if (policy?.includes(CAPABILITY_BOUNDARY_MARKER))
         return policy;
     const sentence = `${CAPABILITY_BOUNDARY_MARKER}：` +
         (allowed.length > 0 ? `仅可使用 ${allowed.join("、")}` : "无允许清单") +
         (forbidden.length > 0 ? `；禁止 ${forbidden.join("、")}` : "") +
+        (requiredClauses.length > 0 ? `；必须满足 ${requiredClauses.join("；")}` : "") +
         "。";
     return policy?.trim() ? `${policy.trim()}；${sentence}` : sentence;
 }

package/dist/workflows/dag/frontend-plan-completeness.js

@@ -1,4 +1,14 @@
 import { collectCanonicalStateFlowNames } from "./frontend-contract-facts.js";
+export function enrichFrontendPlanMissingFacts(missing) {
+    return missing.map((item) => ({
+        ...item,
+        owner: "Plan",
+        repairScope: item.kind === "state-registry" || item.kind === "mock-api"
+            ? "global-phase"
+            : item.requirementIds.length > 1 ? "requirement-slice" : "fact",
+        nextAction: "replace-fact-and-finalize",
+    }));
+}
 export function committedFactFromPlanRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return undefined;
@@ -94,7 +104,7 @@ export function collectFrontendPlanMissingFacts(input) {
             }
         }
     }
-    return missing;
+    return enrichFrontendPlanMissingFacts(missing);
 }
 /** Completeness checks for phases whose facts are committed incrementally. */
 export function collectFrontendPlanPhaseMissingFacts(input) {
@@ -155,7 +165,7 @@ export function collectFrontendPlanPhaseMissingFacts(input) {
                 });
             }
         }
-        return missing;
+        return enrichFrontendPlanMissingFacts(missing);
     }
     const hasMockApi = facts.some((fact) => fact.kind === "mock-api");
     const allInteractions = collectCanonicalStateFlowNames(facts).interactionNames;
@@ -182,5 +192,5 @@ export function collectFrontendPlanPhaseMissingFacts(input) {
             reason: `interaction ${interaction} has no committed data-flow fact`,
         });
     }
-    return missing;
+    return enrichFrontendPlanMissingFacts(missing);
 }