@tea-agent/loop-agent 0.40.0-next.1 → 0.40.0-next.11

package/dist/worker/console/console-update-runtime.js

@@ -0,0 +1,84 @@
+import os from "node:os";
+import { readPackageVersion } from "../../shared/package-metadata.js";
+import { createNpmUpdateClient } from "../../shared/update/npm-client.js";
+import { acquireUpdateLock, updateLockPath } from "../../shared/update/state.js";
+import { readInitRuntimeActivity } from "../observability/init-runtime-activity.js";
+import { performConsoleUpdateAndInit, } from "./console-update-and-init.js";
+import { TERMINAL_OPERATION_STATES } from "./operation-store.js";
+export function createConsoleUpdateExecutor(input) {
+    return async (channel) => {
+        const currentVersion = readPackageVersion(input.packageRoot);
+        if (!currentVersion) {
+            return {
+                state: "failed",
+                errorCode: "PACKAGE_IDENTITY_UNAVAILABLE",
+                errorMessage: "Console package version cannot be proven",
+                maintenance: {
+                    package: { status: "failed", channel },
+                    initialization: { status: "not-run", pendingPaths: [] },
+                    handoff: { status: "not-needed" },
+                },
+            };
+        }
+        const npm = createNpmUpdateClient({
+            currentVersion,
+            packageRoot: input.packageRoot,
+            cwd: input.repoRoot,
+        });
+        return performConsoleUpdateAndInit({
+            currentVersion,
+            preflight: async () => {
+                const [activity, operations] = await Promise.all([
+                    readInitRuntimeActivity(input.repoRoot),
+                    input.operations.list(),
+                ]);
+                if (activity.workerProjectionError ||
+                    activity.activeDagRunIds.length > 0 ||
+                    activity.activeWorkerTasks > 0 ||
+                    activity.activeWorkerBatches > 0) {
+                    return {
+                        ok: false,
+                        code: "ACTIVE_RUNTIME",
+                        message: "active DAG/Worker runtime exists or cannot be proven inactive",
+                    };
+                }
+                if (input.activeChatTurnCount() > 0) {
+                    return {
+                        ok: false,
+                        code: "CHAT_TURN_ACTIVE",
+                        message: "an Operator Chat turn is active",
+                    };
+                }
+                const liveOtherOperation = operations.some((operation) => operation.action !== "consoleUpdateAndInit" &&
+                    !TERMINAL_OPERATION_STATES.has(operation.state));
+                return liveOtherOperation
+                    ? {
+                        ok: false,
+                        code: "OPERATION_ACTIVE",
+                        message: "another Console operation is active",
+                    }
+                    : { ok: true };
+            },
+            acquireLock: () => acquireUpdateLock(updateLockPath(os.homedir())),
+            resolveVersion: (selectedChannel) => npm.distTagVersionCheck(selectedChannel),
+            canAutoInstall: () => npm.canAutoInstall(),
+            installExact: (version, selectedChannel) => npm.installExact(version, selectedChannel),
+            verifyInstalled: (version) => npm.verifyInstalled(version),
+            applySafeInit: async () => {
+                const result = await input.client.runExternal("loop-agent", ["init", "update", "--apply-safe", "--repo-root", input.repoRoot], {
+                    cwd: input.repoRoot,
+                    artifactName: "console-update-safe-init",
+                    timeoutMs: 120_000,
+                });
+                return result.ok
+                    ? { ok: true, pendingPaths: [] }
+                    : {
+                        ok: false,
+                        message: result.stderr || result.stdout || "safe initialization failed",
+                        pendingPaths: [],
+                    };
+            },
+            requestHandoff: async ({ targetVersion }) => input.requestHandoff(targetVersion),
+        }, channel);
+    };
+}

package/dist/worker/console/dag-execution-receipt.js

@@ -176,8 +176,26 @@ export function deriveEligibilityFactsFromDagSpec(input) {
     }));
     const allWriteSetEntries = writers.flatMap((writer) => writer.writeSet);
     const broadWriteSetRisk = allWriteSetEntries.some(isBroadWriteSetEntry);
-    const forbiddenOverlapRisk = tasks.some((task) => stringList(task.writeSet).some((entry) => [...stringList(task.forbiddenPaths), ...input.forbiddenPaths].some((forbidden) => pathMatchesPattern(entry, forbidden) ||
-        pathMatchesPattern(forbidden, entry))));
+    const taskForbidden = input.forbiddenPaths.map(normalizePathEntry);
+    const forbiddenOverlapRisk = tasks.some((task) => stringList(task.writeSet).some((entry) => {
+        const normalizedEntry = normalizePathEntry(entry);
+        return stringList(task.forbiddenPaths).some((forbidden) => {
+            const normalizedForbidden = normalizePathEntry(forbidden);
+            const isTaskGlobal = taskForbidden.includes(normalizedForbidden);
+            if (isTaskGlobal) {
+                // Task-level forbidden paths are hard global boundaries. A broad
+                // writer that could include one is not autonomously eligible.
+                return (pathMatchesPattern(normalizedEntry, normalizedForbidden) ||
+                    pathMatchesPattern(normalizedForbidden, normalizedEntry));
+            }
+            // Node-local forbidden paths may intentionally carve a narrower
+            // child (for example md/README.md) out of a broader writer
+            // writeSet. That exclusion is enforced by the runtime write guard.
+            // It is a conflict only when the writer entry itself is wholly
+            // inside the forbidden boundary.
+            return pathMatchesPattern(normalizedEntry, normalizedForbidden);
+        });
+    }));
     const hasStructuredVerification = tasks.some((task) => {
         if (task.executor !== "shell" || !task.shell)
             return false;

package/dist/worker/console/draft-store.js

@@ -1,5 +1,51 @@
 import path from "node:path";
 import { readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
+/**
+ * 从任意上游载荷安全投影 ledger 摘要（未知形状丢弃，绝不抛错、绝不信任字段外的数据）。
+ * 供 DraftStore / prd-intake-bridge 把 prepare/advance 结果中的 ledger 摘要带入草稿。
+ */
+export function summarizeLedgerPayload(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    if (record.present !== true)
+        return undefined;
+    const num = (key) => {
+        const raw = record[key];
+        return typeof raw === "number" && Number.isFinite(raw) ? raw : 0;
+    };
+    const gateRaw = record.gateStatus;
+    const gateStatus = gateRaw === "pass" || gateRaw === "fail" || gateRaw === "unknown"
+        ? gateRaw
+        : "unknown";
+    const failureCode = typeof record.failureCode === "string" && record.failureCode
+        ? record.failureCode
+        : null;
+    const rawExclusions = Array.isArray(record.exclusions) ? record.exclusions : [];
+    const exclusions = [];
+    for (const item of rawExclusions) {
+        if (!item || typeof item !== "object")
+            continue;
+        const entry = item;
+        const fragmentId = typeof entry.fragmentId === "string" ? entry.fragmentId : "";
+        const reason = typeof entry.reason === "string" ? entry.reason : "";
+        if (!fragmentId)
+            continue;
+        exclusions.push({ fragmentId, reason });
+    }
+    return {
+        present: true,
+        fragmentCount: num("fragmentCount"),
+        canonicalRequirementCount: num("canonicalRequirementCount"),
+        contextOnlyCount: num("contextOnlyCount"),
+        duplicateCount: num("duplicateCount"),
+        unresolvedCount: num("unresolvedCount"),
+        conflictCount: num("conflictCount"),
+        gateStatus,
+        failureCode,
+        exclusions,
+    };
+}
 function draftPath(appData, taskId) {
     const safe = taskId.replace(/[^a-zA-Z0-9._-]+/g, "_");
     return path.join(appData.drafts, `${safe}.json`);
@@ -86,6 +132,9 @@ export function toCanonicalDraftForCli(draft) {
     if (draft.interviewAssessmentRef) {
         canonical.interviewAssessmentRef = draft.interviewAssessmentRef;
     }
+    // AC-BLOCK-002：canonical draft JSON 绝不携带 ledgerSummary 字段（strict
+    // taskContractDraftSchema 拒绝未知键）。摘要仅留在 prd-intake-bridge 响应与
+    // console-types 的 LedgerSummaryView（UI 视图模型），不进入持久化 draft。
     return canonical;
 }
 export class DraftStore {

package/dist/worker/console/native-directory-picker.js

@@ -0,0 +1,13 @@
+/**
+ * DSH's native directory-picker adapter.
+ *
+ * The published DSH host package uses the modern Win32 IFileOpenDialog in a
+ * dedicated child process (plus osascript/Zenity/KDialog on other platforms),
+ * so the Console does not pay PowerShell startup cost or lose the chooser
+ * behind the browser window.
+ */
+import { pickNativeDirectory, } from "@deepseek-ai/dsh-host-directory-picker-native";
+/** Open the host OS single-folder chooser. Cancellation is a null result. */
+export async function pickNativeWorkspaceDirectory(signal, internals = {}) {
+    return pickNativeDirectory(signal, internals);
+}

package/dist/worker/console/operation-store.js

@@ -1,7 +1,7 @@
 import { randomBytes } from "node:crypto";
 import path from "node:path";
 import { listJsonFiles, readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
-export const TERMINAL_OPERATION_STATES = new Set(["succeeded", "failed", "timed-out"]);
+export const TERMINAL_OPERATION_STATES = new Set(["succeeded", "failed", "timed-out", "restarting"]);
 function operationFile(appData, operationId) {
     return path.join(appData.operations, `${operationId}.json`);
 }

package/dist/worker/console/operator-actions.js

@@ -536,6 +536,106 @@ async function acceptOperation(ctx, input) {
         },
     };
 }
+async function acceptConsoleUpdateAndInit(ctx, clientRequestId, channel) {
+    if (!ctx.consoleUpdateExecutor) {
+        return {
+            kind: "error",
+            status: 503,
+            body: operatorFailed({
+                command: "consoleUpdateAndInit",
+                outcome: "blocked",
+                code: "CONSOLE_UPDATE_UNAVAILABLE",
+                message: "Console update runtime is unavailable",
+            }),
+        };
+    }
+    const created = await ctx.operations.create({
+        clientRequestId,
+        action: "consoleUpdateAndInit",
+        actionParams: { channel },
+    });
+    if (created.kind === "conflict") {
+        return {
+            kind: "error",
+            status: 409,
+            body: operatorFailed({
+                command: "consoleUpdateAndInit",
+                outcome: "conflict",
+                code: "REQUEST_ID_REUSE_CONFLICT",
+                message: created.message,
+            }),
+        };
+    }
+    if (created.kind === "idempotent") {
+        return {
+            kind: "accepted",
+            status: 202,
+            body: {
+                operationId: created.operation.operationId,
+                state: created.operation.state,
+                clientRequestId: created.operation.clientRequestId,
+                action: created.operation.action,
+            },
+        };
+    }
+    queueMicrotask(() => {
+        void (async () => {
+            const operationId = created.operation.operationId;
+            await ctx.operations.update(operationId, {
+                state: "running",
+                startedAt: new Date().toISOString(),
+            });
+            ctx.events.append(operationId, {
+                at: new Date().toISOString(),
+                kind: "state",
+                state: "running",
+                message: `checking runtime, npm ${channel}, and safe initialization`,
+            });
+            try {
+                const result = await ctx.consoleUpdateExecutor(channel);
+                const state = result.state;
+                const next = await ctx.operations.update(operationId, {
+                    state,
+                    finishedAt: new Date().toISOString(),
+                    result: result,
+                    ...(result.errorCode ? { errorCode: result.errorCode } : {}),
+                    ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),
+                });
+                ctx.events.append(operationId, {
+                    at: new Date().toISOString(),
+                    kind: "state",
+                    state: next.state,
+                    message: result.errorMessage ?? `console maintenance ${next.state}`,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const next = await ctx.operations.update(operationId, {
+                    state: "needs-reconcile",
+                    finishedAt: new Date().toISOString(),
+                    errorCode: "CONSOLE_UPDATE_EXCEPTION",
+                    errorMessage: message,
+                });
+                ctx.events.append(operationId, {
+                    at: new Date().toISOString(),
+                    kind: "error",
+                    state: next.state,
+                    message,
+                });
+            }
+        })();
+    });
+    return {
+        kind: "accepted",
+        status: 202,
+        body: {
+            operationId: created.operation.operationId,
+            state: created.operation.state,
+            clientRequestId: created.operation.clientRequestId,
+            action: created.operation.action,
+        },
+    };
+}
 export async function dispatchOperatorAction(ctx, req) {
     const action = req.action?.trim();
     if (!action) {
@@ -566,6 +666,31 @@ export async function dispatchOperatorAction(ctx, req) {
         };
     }
     const p = paramsOf(req);
+    if (action === "consoleUpdateAndInit") {
+        if (req.source !== "human-ui") {
+            return {
+                kind: "error",
+                status: 403,
+                body: operatorFailed({
+                    command: action,
+                    outcome: "blocked",
+                    code: "HUMAN_UI_REQUIRED",
+                    message: "consoleUpdateAndInit is available only from the Operate UI",
+                }),
+            };
+        }
+        if (!req.clientRequestId?.trim()) {
+            return invalid(action, "clientRequestId is required");
+        }
+        if (Object.keys(p).some((key) => key !== "channel")) {
+            return invalid(action, "only channel may be provided");
+        }
+        const channel = p.channel ?? "latest";
+        if (channel !== "latest" && channel !== "next") {
+            return invalid(action, "channel must be latest or next");
+        }
+        return acceptConsoleUpdateAndInit(ctx, req.clientRequestId, channel);
+    }
     switch (action) {
         case "operatorCapabilities": {
             const doc = buildOperatorCapabilitiesDocument();
@@ -1516,9 +1641,10 @@ export async function dispatchOperatorAction(ctx, req) {
                 broadWriteSetRisk: typeof reviewPacket.broadWriteSetRisk === "boolean"
                     ? reviewPacket.broadWriteSetRisk
                     : derivedFacts.broadWriteSetRisk,
-                forbiddenOverlapRisk: typeof reviewPacket.forbiddenOverlapRisk === "boolean"
-                    ? reviewPacket.forbiddenOverlapRisk
-                    : derivedFacts.forbiddenOverlapRisk,
+                // Always use the staged DAG + live task boundary derivation here.
+                // The generation review packet lacks task-boundary scope and can
+                // mistake a narrower node-local exclusion for a global overlap.
+                forbiddenOverlapRisk: derivedFacts.forbiddenOverlapRisk,
                 hasStructuredVerification: packetShellVerification,
             };
             const assessment = assessAutonomousExecutionEligibility(eligibility);
@@ -2159,8 +2285,8 @@ export async function dispatchOperatorAction(ctx, req) {
             return accepted;
         }
         case "dagPromptOverrideConfig": {
-            // Experimental internal switch; the browser UI hides the prompt-edit
-            // entry unless this reports enabled=true.
+            // The prompt-edit entry is visible by default. The internal environment
+            // switch remains an emergency kill switch and is reflected here.
             return {
                 kind: "sync",
                 status: 200,
@@ -2182,7 +2308,7 @@ export async function dispatchOperatorAction(ctx, req) {
             }
             if (parsedOverrides.overrides.length > 0 &&
                 !isDagRerunPromptOverrideEnabled()) {
-                return invalid(action, `prompt override rerun is disabled; set ${DAG_RERUN_PROMPT_OVERRIDE_ENV}=1 to enable this experimental capability`);
+                return invalid(action, `prompt override rerun is disabled by ${DAG_RERUN_PROMPT_OVERRIDE_ENV}; unset it or use a value other than 0, false, or off to enable this experimental capability`);
             }
             const overrideArgs = parsedOverrides.overrides.length > 0
                 ? await buildPromptOverrideCliArgs(ctx, parsedOverrides.overrides)
@@ -2215,7 +2341,7 @@ export async function dispatchOperatorAction(ctx, req) {
             }
             if (parsedOverrides.overrides.length > 0 &&
                 !isDagRerunPromptOverrideEnabled()) {
-                return invalid(action, `prompt override rerun is disabled; set ${DAG_RERUN_PROMPT_OVERRIDE_ENV}=1 to enable this experimental capability`);
+                return invalid(action, `prompt override rerun is disabled by ${DAG_RERUN_PROMPT_OVERRIDE_ENV}; unset it or use a value other than 0, false, or off to enable this experimental capability`);
             }
             const overrideArgs = parsedOverrides.overrides.length > 0
                 ? await buildPromptOverrideCliArgs(ctx, parsedOverrides.overrides)

package/dist/worker/console/operator-surface-health.js

@@ -12,6 +12,7 @@ export function buildOperatorSurfaceHealthV1(input) {
         repoName: input.repoRoot.split(/[\\/]/).filter(Boolean).pop() ?? "repository",
         packageName,
         packageVersion,
+        consoleInstanceId: input.consoleInstanceId,
         piReadiness: input.piReadiness,
         inspect: {
             ready: input.inspectReady,

package/dist/worker/console/prd-intake-bridge.js

@@ -9,6 +9,7 @@ import { getTaskPaths } from "../../task/runtime.js";
 import { SEMANTIC_INTAKE_ARTIFACT_REL, } from "../../task/source-prepare/semantic-intake.js";
 import { extractRequirementFactsFromMarkdown } from "../../task/source-prepare/parse-intent.js";
 import { filterPlaceholderPaths, isNonPlaceholderPath, } from "../../task/source-prepare/placeholder-paths.js";
+import { summarizeLedgerPayload, } from "./draft-store.js";
 import { emptyDraft } from "./interview/grill-me.js";
 import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
 function asStringList(value) {
@@ -219,6 +220,15 @@ export async function buildDraftFromTaskIntake(input) {
     const paths = getTaskPaths(input.repoRoot, input.taskId);
     const warnings = warningList(input.advanceJson);
     const lifecycleState = lifecycleFromAdvanceJson(input.advanceJson);
+    // Source fidelity ledger 安全摘要透传（AC-009）：来自 advance/prepare 结果，
+    // 未知形状安全丢弃，绝不携带未截断原文。
+    const advanceRoot = input.advanceJson && typeof input.advanceJson === "object"
+        ? input.advanceJson
+        : {};
+    const ledgerSummary = summarizeLedgerPayload(advanceRoot.ledgerSummary) ??
+        summarizeLedgerPayload(advanceRoot.result && typeof advanceRoot.result === "object"
+            ? advanceRoot.result.ledgerSummary
+            : undefined);
     const semanticApplied = warnings.some((w) => w.code === "SEMANTIC_INTAKE_APPLIED");
     const semanticFailed = warnings.find((w) => w.code === "SEMANTIC_INTAKE_PI_FAILED" ||
         w.code === "SEMANTIC_INTAKE_INVALID_OUTPUT" ||
@@ -427,11 +437,14 @@ export async function buildDraftFromTaskIntake(input) {
     if (input.engineering) {
         draft = applyEngineeringBoundaryToDraft(draft, input.engineering);
     }
+    // AC-BLOCK-002：摘要仅经响应返回 UI 视图模型，不写入 draft（防止 strict
+    // taskContractDraftSchema 因未知 ledgerSummary 键拒绝 canonical draft）。
     return {
         draft,
         parseStatus,
         semanticIntake,
         gaps,
+        ...(ledgerSummary ? { ledgerSummary } : {}),
         lifecycleState,
     };
 }