@tea-agent/loop-agent 0.31.1 → 0.32.1

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

@@ -0,0 +1,207 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { formatModelRef, mergeSessionRuntime, runtimeSelectionFromRecord, sessionRuntimeMatches, } from "../../chat/runtime-selection.js";
+import { confirmationToken } from "./format.js";
+import { buildToolCatalog } from "./tools-catalog.js";
+/** Capabilities catalog, model / thinking-level switcher, runtime-context
+ *  popover and the outside-click dismissal for both transient menus. */
+export function useRuntimeControls(params) {
+    const { origin, session, setSession, refs, setError } = params;
+    const [capabilities, setCapabilities] = useState(null);
+    const [models, setModels] = useState([]);
+    const [thinkingLevels, setThinkingLevels] = useState([]);
+    const [runtimeContext, setRuntimeContext] = useState(null);
+    const [toolsOpen, setToolsOpen] = useState(false);
+    const [runtimeContextOpen, setRuntimeContextOpen] = useState(false);
+    const toolsMenuRef = useRef(null);
+    const runtimeContextMenuRef = useRef(null);
+    const loadCapabilities = useCallback(async () => {
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/capabilities`);
+            if (!res.ok)
+                return;
+            const body = (await res.json());
+            setCapabilities(body);
+        }
+        catch {
+            // capabilities optional; Chat still works without them
+        }
+    }, [origin]);
+    useEffect(() => {
+        void loadCapabilities();
+    }, [loadCapabilities]);
+    useEffect(() => {
+        if (!session) {
+            setModels([]);
+            setRuntimeContext(null);
+            return;
+        }
+        const sessionId = session.sessionId;
+        const base = `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`;
+        void fetch(`${base}/models`, { credentials: "include" })
+            .then((r) => (r.ok ? r.json() : null))
+            .then((body) => {
+            // Guard against a stale response landing after the user switched/
+            // created/forked a session: only adopt models for the session we
+            // actually requested them for.
+            if (!body || refs.sessionRef.current?.sessionId !== sessionId)
+                return;
+            setModels(body.models ?? []);
+            setThinkingLevels(body.thinkingLevels ?? []);
+        });
+        void fetch(`${base}/runtime-context`, { credentials: "include" })
+            .then((r) => (r.ok ? r.json() : null))
+            .then((body) => {
+            // Stale-response guard: a slow runtime-context reply for session A
+            // must not overwrite the context/session state of the now-current
+            // session B.
+            if (!body?.context || refs.sessionRef.current?.sessionId !== sessionId)
+                return;
+            setRuntimeContext(body.context);
+            const ctx = body.context;
+            const patch = {
+                model: ctx.model,
+                thinkingLevel: ctx.thinkingLevel,
+            };
+            setSession((current) => {
+                if (!current || current.sessionId !== sessionId)
+                    return current;
+                if (sessionRuntimeMatches(current, patch))
+                    return current;
+                const merged = mergeSessionRuntime(current, patch);
+                refs.sessionRef.current = merged;
+                return merged;
+            });
+        });
+    }, [origin, session?.sessionId, refs, setSession]);
+    const switchRuntime = useCallback(async (body) => {
+        if (!session)
+            return;
+        // Capture the target session so a slow model/thinking response cannot
+        // write its result into a different (newly created/forked/switched)
+        // session the user has since moved to.
+        const targetSessionId = session.sessionId;
+        const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(session.sessionId)}/model`, {
+            method: "POST",
+            credentials: "include",
+            headers: {
+                "content-type": "application/json",
+                "x-loop-console-confirmation": confirmationToken(),
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            // Only surface the failure for the session that still owns it.
+            if (refs.sessionRef.current?.sessionId === targetSessionId)
+                setError("模型或思考等级切换失败");
+            return;
+        }
+        const payload = (await res.json().catch(() => ({})));
+        if (!payload.session)
+            return;
+        // Drop the result entirely if the active session changed mid-flight.
+        if (refs.sessionRef.current?.sessionId !== targetSessionId)
+            return;
+        setSession((current) => {
+            if (!current || current.sessionId !== targetSessionId)
+                return current;
+            const patch = runtimeSelectionFromRecord(payload.session);
+            if (sessionRuntimeMatches(current, patch))
+                return current;
+            const merged = mergeSessionRuntime(current, patch);
+            refs.sessionRef.current = merged;
+            return merged;
+        });
+        setRuntimeContext((current) => current
+            ? {
+                ...current,
+                ...(payload.session.modelProvider && payload.session.modelId
+                    ? {
+                        model: {
+                            provider: payload.session.modelProvider,
+                            modelId: payload.session.modelId,
+                        },
+                    }
+                    : {}),
+                ...(payload.session.thinkingLevel
+                    ? { thinkingLevel: payload.session.thinkingLevel }
+                    : body.thinkingLevel
+                        ? { thinkingLevel: body.thinkingLevel }
+                        : {}),
+            }
+            : current);
+    }, [origin, session, refs, setSession, setError]);
+    // Close tools catalog on outside click / Escape.
+    useEffect(() => {
+        if (!toolsOpen)
+            return;
+        const onPointer = (e) => {
+            const root = toolsMenuRef.current;
+            if (!root)
+                return;
+            if (e.target instanceof Node && !root.contains(e.target)) {
+                setToolsOpen(false);
+            }
+        };
+        const onKey = (e) => {
+            if (e.key === "Escape")
+                setToolsOpen(false);
+        };
+        document.addEventListener("mousedown", onPointer);
+        document.addEventListener("keydown", onKey);
+        return () => {
+            document.removeEventListener("mousedown", onPointer);
+            document.removeEventListener("keydown", onKey);
+        };
+    }, [toolsOpen]);
+    // Close runtime-context popover on outside click / Escape.
+    useEffect(() => {
+        if (!runtimeContextOpen)
+            return;
+        const onPointer = (e) => {
+            const root = runtimeContextMenuRef.current;
+            if (!root)
+                return;
+            if (e.target instanceof Node && !root.contains(e.target)) {
+                setRuntimeContextOpen(false);
+            }
+        };
+        const onKey = (e) => {
+            if (e.key === "Escape")
+                setRuntimeContextOpen(false);
+        };
+        document.addEventListener("mousedown", onPointer);
+        document.addEventListener("keydown", onKey);
+        return () => {
+            document.removeEventListener("mousedown", onPointer);
+            document.removeEventListener("keydown", onKey);
+        };
+    }, [runtimeContextOpen]);
+    const toolCatalog = useMemo(() => buildToolCatalog(capabilities), [
+        capabilities,
+    ]);
+    const activeModel = session?.model ?? runtimeContext?.model;
+    const activeModelRef = activeModel
+        ? formatModelRef(activeModel.provider, activeModel.modelId)
+        : "";
+    const activeThinkingLevel = session?.thinkingLevel ?? runtimeContext?.thinkingLevel ?? "";
+    const activeModelListed = !activeModelRef ||
+        models.some((model) => formatModelRef(model.provider, model.id) === activeModelRef);
+    return {
+        capabilities,
+        models,
+        thinkingLevels,
+        runtimeContext,
+        toolsOpen,
+        setToolsOpen,
+        runtimeContextOpen,
+        setRuntimeContextOpen,
+        toolsMenuRef,
+        runtimeContextMenuRef,
+        switchRuntime,
+        toolCatalog,
+        activeModel,
+        activeModelRef,
+        activeThinkingLevel,
+        activeModelListed,
+    };
+}

package/dist/worker/feature/acceptance-policy.js

@@ -0,0 +1,227 @@
+import { z } from "zod";
+/**
+ * ADR 0007: only `agent-worker feature verify-final` is the canonical writer for
+ * Feature Verification Bundle, QA pass evidence, and Final Verification Record.
+ * Task Pool Done, DAG verify-shell receipts, and packet FINAL-VERIFY-* smoke
+ * nodes are inputs only — they must never be treated as coverage writers.
+ */
+export const CANONICAL_FINAL_VERIFICATION_AUTHORITY = "feature-verify-final";
+export const DEFAULT_VERIFY_FINAL_COMMAND = "agent-worker feature verify-final";
+const deliverySequenceSchema = z.array(z.enum(["verify-final", "delivery", "closeout"]));
+export const acceptancePolicySchema = z
+    .object({
+    schema_version: z.literal(1),
+    authority: z.string().min(1).optional(),
+    independent_qa_required: z.boolean().optional(),
+    coverage_writer: z.string().min(1).optional(),
+    final_verification: z
+        .object({
+        command: z.string().min(1),
+    })
+        .strict()
+        .optional(),
+    delivery_sequence: deliverySequenceSchema.optional(),
+})
+    .strict();
+const DEFAULT_POLICY = {
+    schema_version: 1,
+    authority: CANONICAL_FINAL_VERIFICATION_AUTHORITY,
+    independent_qa_required: true,
+    coverage_writer: CANONICAL_FINAL_VERIFICATION_AUTHORITY,
+    final_verification: {
+        command: DEFAULT_VERIFY_FINAL_COMMAND,
+    },
+    delivery_sequence: ["verify-final", "delivery", "closeout"],
+};
+/**
+ * Parse optional `acceptance_policy` from a Feature Packet object (typically
+ * `feature.yaml`). Unknown fields are rejected; missing fields receive ADR 0007
+ * defaults without inventing covered evidence.
+ */
+export function parseAcceptancePolicy(packet) {
+    if (!packet || typeof packet !== "object")
+        return { ...DEFAULT_POLICY };
+    const raw = packet.acceptance_policy;
+    if (raw === undefined || raw === null)
+        return { ...DEFAULT_POLICY };
+    const parsed = acceptancePolicySchema.safeParse(raw);
+    if (!parsed.success)
+        return { ...DEFAULT_POLICY };
+    return normalizeAcceptancePolicy(parsed.data);
+}
+/** Apply canonical defaults while preserving explicit packet overrides. */
+export function normalizeAcceptancePolicy(policy) {
+    return {
+        schema_version: 1,
+        authority: policy.authority?.trim() || DEFAULT_POLICY.authority,
+        independent_qa_required: policy.independent_qa_required ?? DEFAULT_POLICY.independent_qa_required,
+        coverage_writer: policy.coverage_writer?.trim() || DEFAULT_POLICY.coverage_writer,
+        final_verification: {
+            command: policy.final_verification?.command?.trim() ||
+                DEFAULT_POLICY.final_verification.command,
+        },
+        delivery_sequence: policy.delivery_sequence && policy.delivery_sequence.length > 0
+            ? [...policy.delivery_sequence]
+            : [...DEFAULT_POLICY.delivery_sequence],
+    };
+}
+/** Extract additive policy fields that may exist on raw acceptance YAML items. */
+export function extractAcceptanceItemPolicyFields(rawItem) {
+    if (!rawItem || typeof rawItem !== "object") {
+        return { requiredEvidenceKinds: [], expectedTaskRefs: [] };
+    }
+    const verification = rawItem.verification;
+    if (!verification || typeof verification !== "object") {
+        return { requiredEvidenceKinds: [], expectedTaskRefs: [] };
+    }
+    const record = verification;
+    const authority = typeof record.authority === "string" && record.authority.trim().length > 0
+        ? record.authority.trim()
+        : undefined;
+    const requiredEvidenceKinds = readStringArray(record.required_evidence_kinds ?? record.required_evidence);
+    const expectedTaskRefs = readStringArray(record.expected_task_refs);
+    return { authority, requiredEvidenceKinds, expectedTaskRefs };
+}
+export function indexRawAcceptanceItems(rawAcceptance) {
+    const result = new Map();
+    if (!rawAcceptance || typeof rawAcceptance !== "object")
+        return result;
+    const items = rawAcceptance.acceptance;
+    if (!Array.isArray(items))
+        return result;
+    for (const item of items) {
+        if (!item || typeof item !== "object")
+            continue;
+        const id = item.id;
+        if (typeof id === "string" && id.length > 0)
+            result.set(id, item);
+    }
+    return result;
+}
+export function buildAcceptanceGaps(input) {
+    const gaps = [];
+    const verifyFinalCommand = buildVerifyFinalCommand(input.policy, input.featureDir, input.repoRoot);
+    const allTasksDone = input.tasks.length > 0 &&
+        input.tasks.every((task) => task.status === "Done");
+    for (const item of input.acceptanceItems) {
+        if (item.priority !== "must")
+            continue;
+        const fact = input.coverage.find((entry) => entry.acId === item.id);
+        if (!fact || fact.status === "covered" || fact.status === "waived")
+            continue;
+        const rawItem = input.rawByAcId?.get(item.id);
+        const policyFields = extractAcceptanceItemPolicyFields(rawItem);
+        const authority = resolveItemAuthority(input.policy, policyFields);
+        const blockers = collectBlockers({
+            policy: input.policy,
+            policyFields,
+            item,
+            authority,
+        });
+        const status = normalizeGapStatus(fact.status);
+        const missingEvidenceKinds = resolveMissingEvidenceKinds({
+            policyFields,
+            item,
+            fact,
+            status,
+        });
+        gaps.push({
+            acId: item.id,
+            status,
+            missingEvidenceKinds,
+            expectedTaskRefs: item.verification.expected_task_refs,
+            authority,
+            nextCommand: projectGapNextCommand({
+                status,
+                blockers,
+                allTasksDone,
+                verifyFinalCommand,
+                featureDir: input.featureDir,
+                repoRoot: input.repoRoot,
+                blockedBy: fact.blockedBy,
+            }),
+            blockers,
+        });
+    }
+    return gaps;
+}
+function resolveItemAuthority(policy, policyFields) {
+    return policyFields.authority ?? policy.authority ?? CANONICAL_FINAL_VERIFICATION_AUTHORITY;
+}
+function collectBlockers(input) {
+    const blockers = [];
+    if (!input.policyFields.authority && input.policy.independent_qa_required) {
+        blockers.push("missing authority: required AC has no verification.authority");
+    }
+    if (input.policyFields.expectedTaskRefs.length === 0 &&
+        (input.policyFields.requiredEvidenceKinds.length === 0 &&
+            (input.item.verification.implementation_task_refs?.length ?? 0) === 0 &&
+            (input.item.verification.verification_task_refs?.length ?? 0) === 0)) {
+        blockers.push("missing producer: no expected_task_refs or dual-coverage refs");
+    }
+    if (input.policy.independent_qa_required &&
+        input.policyFields.requiredEvidenceKinds.length === 0 &&
+        (input.item.verification.required_evidence?.length ?? 0) === 0 &&
+        input.authority === CANONICAL_FINAL_VERIFICATION_AUTHORITY) {
+        blockers.push("missing evidence kinds: declare verification.required_evidence_kinds or required_evidence");
+    }
+    if (input.authority !== CANONICAL_FINAL_VERIFICATION_AUTHORITY &&
+        input.policy.coverage_writer === CANONICAL_FINAL_VERIFICATION_AUTHORITY) {
+        blockers.push(`non-canonical authority ${input.authority}; ADR 0007 requires ${CANONICAL_FINAL_VERIFICATION_AUTHORITY}`);
+    }
+    return blockers;
+}
+function resolveMissingEvidenceKinds(input) {
+    if (input.status === "blocked")
+        return [];
+    const declared = [
+        ...input.policyFields.requiredEvidenceKinds,
+        ...(input.item.verification.required_evidence ?? []),
+    ];
+    const unique = [...new Set(declared)];
+    if (unique.length > 0 && input.fact.evidence.length === 0)
+        return unique;
+    if (unique.length === 0 && input.status !== "missing") {
+        return ["canonical-qa-evidence"];
+    }
+    return unique;
+}
+function normalizeGapStatus(status) {
+    if (status === "awaiting-verification")
+        return "awaiting-verification";
+    if (status === "blocked")
+        return "blocked";
+    if (status === "partial")
+        return "partial";
+    return "missing";
+}
+function projectGapNextCommand(input) {
+    if (input.status === "blocked") {
+        if (input.blockedBy.length > 0) {
+            const taskId = input.blockedBy[0];
+            return `agent-worker feature review --feature-dir ${quote(input.featureDir)} --repo ${quote(input.repoRoot)}`;
+        }
+        return undefined;
+    }
+    if (!input.allTasksDone) {
+        return `agent-worker batch run-ready --feature-dir ${quote(input.featureDir)} --repo ${quote(input.repoRoot)}`;
+    }
+    if (input.status === "partial" ||
+        input.status === "awaiting-verification" ||
+        input.status === "missing") {
+        return input.verifyFinalCommand;
+    }
+    return undefined;
+}
+function buildVerifyFinalCommand(policy, featureDir, repoRoot) {
+    const base = policy.final_verification?.command?.trim() || DEFAULT_VERIFY_FINAL_COMMAND;
+    return `${base} --feature-dir ${quote(featureDir)} --repo ${quote(repoRoot)}`;
+}
+function readStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function quote(value) {
+    return JSON.stringify(value);
+}

package/dist/worker/feature/decision-loader.js

@@ -27,7 +27,7 @@ export async function loadFeatureDecisionModels(repoRoot) {
 function degradeExisting(feature, warnings) {
     return { ...feature, status: "needs_action", statusLabel: "需处理", blockingItems: [...warnings.map((warning) => ({ type: "projection_warning", message: warning, evidence: [] })), ...feature.blockingItems], nextAction: { kind: "repair_projection", label: "修复损坏的 Feature / Task Pool facts 后重新审阅" }, projectionWarnings: [...new Set([...feature.projectionWarnings, ...warnings])] };
 }
-function degradedFeature(featureId, warning) { return { schemaVersion: 1, featureId, status: "needs_action", statusLabel: "需处理", summary: { tasksTotal: 0, tasksSucceeded: 0, tasksFailed: 0, tasksReady: 0, tasksBlocked: 0, requiredAcTotal: 0, requiredAcCovered: 0 }, riskSummary: { high: 1, medium: 0, low: 0 }, blockingItems: [{ type: "projection_warning", message: warning, evidence: [] }], followUps: { pending: [], actionCards: [], resolvedFailureTaskIds: [] }, tasks: [], acceptanceCoverage: [], nextAction: { kind: "repair_projection", label: "修复损坏事实后重新审阅" }, alternativeActions: [], evidence: { morningReport: null, observeSnapshot: null, delivery: null, closeout: null }, projectionWarnings: [warning] }; }
+function degradedFeature(featureId, warning) { return { schemaVersion: 1, featureId, status: "needs_action", statusLabel: "需处理", summary: { tasksTotal: 0, tasksSucceeded: 0, tasksFailed: 0, tasksReady: 0, tasksBlocked: 0, requiredAcTotal: 0, requiredAcCovered: 0 }, riskSummary: { high: 1, medium: 0, low: 0 }, blockingItems: [{ type: "projection_warning", message: warning, evidence: [] }], followUps: { pending: [], actionCards: [], resolvedFailureTaskIds: [] }, tasks: [], acceptanceCoverage: [], acceptanceGaps: [], nextAction: { kind: "repair_projection", label: "修复损坏事实后重新审阅" }, alternativeActions: [], evidence: { morningReport: null, observeSnapshot: null, delivery: null, closeout: null }, projectionWarnings: [warning] }; }
 async function auditTaskPoolFacts(repoRoot) {
     const warnings = [];
     try {

package/dist/worker/feature/next-action.js

@@ -1,3 +1,4 @@
+import { resolveWorkerRecoveryDecision } from "../pool/recovery-decision.js";
 export function projectNextAction(input, status) {
     const featureArgs = `--feature-dir ${quote(input.featureDir)} --repo ${quote(input.repoRoot)}`;
     const resolvedFailures = new Set(input.resolvedFailureTaskIds ?? []);
@@ -31,20 +32,59 @@ export function projectNextAction(input, status) {
     }
     const failed = input.tasks.find((task) => task.status === "Failed" && !resolvedFailures.has(task.taskId));
     if (failed) {
-        if (failed.failureCategory === "EnvFailure") {
+        const decision = resolveWorkerRecoveryDecision({
+            state: {
+                status: failed.status ?? "Failed",
+                ...(failed.workerRunId ? { workerRunId: failed.workerRunId } : {}),
+                ...(failed.failureCategory
+                    ? {
+                        failure: {
+                            category: failed.failureCategory,
+                            recommendedFollowUpKind: "feature-review",
+                            derivedFollowUpTaskId: `${failed.taskId}-review`,
+                            source: "fallback",
+                        },
+                    }
+                    : {}),
+            },
+        });
+        if (decision.recommendedAction === "retry") {
             return {
                 kind: "retry_task",
-                label: `重试环境失败任务 ${failed.taskId}`,
+                label: `重试失败任务 ${failed.taskId}`,
                 command: `agent-worker task retry ${quote(failed.taskId)} --feature-id ${quote(input.featureId)} --repo ${quote(input.repoRoot)}`,
             };
         }
-        return {
-            kind: "handle_failure",
-            label: `根据失败证据处理 ${failed.taskId}；ProductBug 可生成并人工批准 Follow-up`,
-        };
+        if (decision.recommendedAction === "decide") {
+            return {
+                kind: "handle_failure",
+                label: `根据失败证据处理 ${failed.taskId}；ProductBug 可生成并人工批准 Follow-up`,
+            };
+        }
     }
     const blocked = input.tasks.find((task) => ["Blocked", "HumanReview", "Abandoned"].includes(task.status ?? ""));
     if (blocked) {
+        const decision = resolveWorkerRecoveryDecision({
+            state: {
+                status: blocked.status ?? "Blocked",
+                ...(blocked.failureCategory
+                    ? {
+                        failure: {
+                            category: blocked.failureCategory,
+                            recommendedFollowUpKind: "feature-review",
+                            derivedFollowUpTaskId: `${blocked.taskId}-review`,
+                            source: "fallback",
+                        },
+                    }
+                    : {}),
+            },
+        });
+        if (decision.recommendedAction === "revise-contract") {
+            return {
+                kind: "revise_contract",
+                label: `修订 ${blocked.taskId} 的 contract/spec 后再 materialize`,
+            };
+        }
         return {
             kind: "resolve_human_gate",
             label: `处理 ${blocked.taskId} 的人工 Gate 或阻塞原因`,
@@ -65,6 +105,16 @@ export function projectNextAction(input, status) {
             command: `agent-worker batch run-ready ${featureArgs}`,
         };
     }
+    if (status === "awaiting_qa" || status === "deliverable") {
+        const gap = input.acceptanceGaps?.find((entry) => entry.nextCommand);
+        if (gap?.nextCommand) {
+            return {
+                kind: status === "deliverable" ? "advance_delivery" : "complete_qa",
+                label: `补齐 ${gap.acId} 验收缺口（${gap.status}）`,
+                command: gap.nextCommand,
+            };
+        }
+    }
     if (status === "awaiting_qa") {
         const finalish = input.tasks.find((task) => /(final[-_]?(verify|verification))|closeout/i.test(task.taskId));
         if (finalish && (finalish.status === "Done" || finalish.status === "Ready")) {

package/dist/worker/feature/profile-schema.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { acceptancePolicySchema } from "./acceptance-policy.js";
 /**
  * Feature-level profile for a Feature Packet (M4 `fullstack-v1`).
  *
@@ -36,6 +37,8 @@ export const featureProfileSchema = z
     })
         .strict()
         .optional(),
+    /** Phase 6 ADR 0007 acceptance / verify-final / delivery policy. */
+    acceptance_policy: acceptancePolicySchema.optional(),
 })
     .strict();
 /** Whether a parsed profile activates the fullstack-v1 gate set. */

package/dist/worker/feature/reducer.js

@@ -81,6 +81,7 @@ export function reduceFeature(input) {
             status: task.status ?? (isReady(task.taskId, input) ? "Ready" : "Draft"),
         })),
         acceptanceCoverage: input.acceptance,
+        acceptanceGaps: input.acceptanceGaps ?? [],
         nextAction: projectNextAction(input, status),
         alternativeActions: [],
         evidence: {