@tea-agent/loop-agent 0.43.0-next.9 → 0.43.0

package/dist/worker/console/workspace-context.js

@@ -1,3 +1,6 @@
+import { deliverScheduledGoalResult } from "./chat/scheduled-goal-delivery.js";
+import { ScheduledGoalHost } from "./scheduled-goal-host.js";
+import { ScheduledGoalStore } from "../scheduler/scheduled-goal-store.js";
 /**
  * Repo-scoped Workspace Context (2026-08-22 multi-workspace foundation, W1).
  *
@@ -39,6 +42,7 @@ import { GoalRegistry } from "./chat/goals.js";
 import { GoalRoundDriver } from "./chat/goal-round-driver.js";
 import { TerminalSessionRegistry } from "./chat/terminal-sessions.js";
 import { ScmService } from "./chat/scm-service.js";
+import { BrowserAutomationService } from "./chat/browser-automation.js";
 import { driveGoalRound, recoverDeferredTurns } from "./chat/routes.js";
 import { createOperationEventStore, } from "./operation-sse.js";
 import { OperationStore } from "../../infrastructure/console/operation-store.js";
@@ -52,6 +56,7 @@ import { probePiReadiness, } from "./pi-readiness.js";
 import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 import { NightAuxTicker } from "./night-aux-ticker.js";
 import { createObserveRouteContext, } from "../observe/routes.js";
+import { WorkspaceInitializationService } from "./workspace-initialization.js";
 import { WorkspaceRegistry } from "./workspace-registry.js";
 import { resolveConsoleDefaultTimeoutMs } from "./server.js";
 /**
@@ -242,6 +247,7 @@ export async function createWorkspaceContext(record, deps) {
         readiness: readinessCache,
         getReadiness,
         refreshReadiness,
+        workspaceInitialization: new WorkspaceInitializationService({ workspaceId: record.workspaceId, name: record.name, repoRoot, client, operations, events, activeChatTurnCount: () => chatTurnExecutions.size() }),
         observeBaseUrl: deps.observeBaseUrl,
         fetchImpl: deps.fetchImpl,
         getConsoleOrigin: deps.getConsoleOrigin,
@@ -295,6 +301,11 @@ export async function createWorkspaceContext(record, deps) {
     // Workspace-scoped git source control shared by the model tool (scm) and
     // the Console UI SCM panel (HTTP API).
     const scmService = new ScmService(repoRoot);
+    const browserAutomation = new BrowserAutomationService({
+        profileDir: appData.browserProfile,
+        downloadsDir: appData.browserDownloads,
+        screenshotsDir: appData.browserScreenshots,
+    });
     const chatRuntime = new ConsolePiRuntime({
         cwd: repoRoot,
         sessionDir: appData.chatSessions,
@@ -306,6 +317,7 @@ export async function createWorkspaceContext(record, deps) {
         sddDataAlignment,
         terminalRegistry,
         scmService,
+        browserAutomation,
     });
     let chatRouteDeps;
     const goalRoundDriver = new GoalRoundDriver((sessionId) => driveGoalRound(chatRouteDeps, sessionId));
@@ -322,6 +334,7 @@ export async function createWorkspaceContext(record, deps) {
         operationLinker: chatOperationLinker,
         terminals: terminalRegistry,
         scm: scmService,
+        browserAutomation,
         appData,
         bootToken: deps.bootToken,
         getConsoleOrigin: deps.getConsoleOrigin,
@@ -330,6 +343,12 @@ export async function createWorkspaceContext(record, deps) {
         detachSession: (sessionId) => registry.detachSession(record.workspaceId, sessionId),
     };
     const nightAuxTicker = new NightAuxTicker({ repoRoot, client });
+    const scheduledGoals = new ScheduledGoalStore(repoRoot);
+    const scheduledGoalHost = new ScheduledGoalHost({
+        goals: scheduledGoals, client, operations, events,
+        deliver: (goal) => deliverScheduledGoalResult(goal, scheduledGoals, chatStore),
+        onError: (goalId, error) => process.stderr.write(`[scheduled-goal] ${goalId ?? "wake"}: ${error instanceof Error ? error.message : String(error)}\n`),
+    });
     const observeRouteContext = createObserveRouteContext(repoRoot, {
         staticDir: deps.inspectStaticDir,
     });
@@ -364,6 +383,7 @@ export async function createWorkspaceContext(record, deps) {
             if (disposed)
                 return;
             disposed = true;
+            scheduledGoalHost.stop();
             try {
                 goalRoundDriver.dispose();
             }
@@ -382,6 +402,7 @@ export async function createWorkspaceContext(record, deps) {
             catch {
                 // best-effort
             }
+            void browserAutomation.dispose();
             try {
                 nightAuxTicker.dispose();
             }
@@ -390,6 +411,7 @@ export async function createWorkspaceContext(record, deps) {
             }
         },
     };
+    scheduledGoalHost.start();
     return context;
 }
 /** Inspect-facing readiness/capability summary for a registry record. */

package/dist/worker/console/workspace-initialization.js

@@ -0,0 +1,209 @@
+import { lstat, readFile } from "node:fs/promises";
+import path from "node:path";
+import { acquireUpdateLock, updateLockPath } from "../../shared/update/state.js";
+import os from "node:os";
+import { TERMINAL_OPERATION_STATES } from "../../infrastructure/console/operation-store.js";
+import { readInitRuntimeActivity } from "../observability/init-runtime-activity.js";
+const record = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("初始化检查返回了无效数据");
+    return value;
+};
+const entries = (value) => {
+    if (!Array.isArray(value))
+        throw new Error("初始化检查缺少状态清单");
+    return value.map(record);
+};
+/** A single registered workspace owns checks, CLI cwd and durable operations. */
+export class WorkspaceInitializationService {
+    options;
+    cached;
+    pending;
+    activeOperationId;
+    generation = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    snapshot(state, message, pendingPaths = []) {
+        const { workspaceId, name, repoRoot } = this.options;
+        return { workspaceId, name, displayPath: repoRoot, state, message, pendingPaths, canUpdate: false, pendingItems: [] };
+    }
+    async jsonFile(relative) {
+        const file = path.join(this.options.repoRoot, relative);
+        try {
+            const stat = await lstat(file);
+            if (!stat.isFile() || stat.isSymbolicLink())
+                throw new Error(`${relative} 不是普通配置文件`);
+            return record(JSON.parse(await readFile(file, "utf8")));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw new Error(`${relative} 无法读取，请检查文件内容与权限`);
+        }
+    }
+    async command(args, name) {
+        const result = await this.options.client.run(args, {
+            cwd: this.options.repoRoot, artifactName: `workspace-init-${name}`,
+            expectJson: true, timeoutMs: 120_000,
+        });
+        if (!result.ok || result.exitCode !== 0 || result.timedOut || result.parseFailure) {
+            throw new Error(`工作区配置${name === "check" ? "检查" : "操作"}失败，请查看操作记录或检查模型与初始化配置`);
+        }
+        return record(result.json);
+    }
+    async catalog() {
+        const catalog = await this.command(["init", "model-catalog", "--json"], "models");
+        return entries(catalog.models).filter(item => item.eligibleForHarness === true && typeof item.reference === "string")
+            .map(item => ({ reference: item.reference, name: typeof item.name === "string" ? item.name : item.reference }));
+    }
+    async inspect() {
+        try {
+            try {
+                const harnessDir = await lstat(path.join(this.options.repoRoot, ".harness"));
+                if (!harnessDir.isDirectory() || harnessDir.isSymbolicLink())
+                    throw new Error(".harness 必须是仓库内的普通目录");
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            const surface = await this.jsonFile(".harness/init-surface.json");
+            const harness = await this.jsonFile("harness.json");
+            if (surface && (surface.schemaVersion !== 1 || !surface.files || typeof surface.files !== "object" || Array.isArray(surface.files))) {
+                throw new Error("初始化记录不完整，请检查 .harness/init-surface.json");
+            }
+            if (!surface && !harness) {
+                const snapshot = this.snapshot("uninitialized", "此仓库尚未初始化。初始化后可使用项目任务与工作流配置。");
+                try {
+                    snapshot.models = await this.catalog();
+                }
+                catch {
+                    snapshot.message = "此仓库尚未初始化；可用模型读取失败，请检查模型设置后重新检查。";
+                }
+                return snapshot;
+            }
+            const report = await this.command(["init", "check-update", "--json"], "check");
+            if (!["recorded", "inferred-baseline", "missing"].includes(String(report.surfaceState)) || typeof report.ok !== "boolean") {
+                throw new Error("初始化检查返回了未知状态");
+            }
+            const actions = entries(report.deterministicActions);
+            const merges = entries(report.modelMergeTasks);
+            const decisions = entries(report.humanDecisions);
+            const pendingItems = [];
+            for (const [kind, list] of [["safe-update", actions], ["merge", merges], ["confirmation", decisions]]) {
+                for (const item of list) {
+                    if (typeof item.path !== "string")
+                        continue;
+                    const detail = typeof item.reason === "string" ? item.reason : undefined;
+                    const baseline = item.type === "bootstrap-surface";
+                    const itemKind = baseline ? "confirmation" : kind;
+                    const reason = baseline ? "缺少可靠的初始化记录，不能直接判断哪些内容可覆盖。"
+                        : kind === "safe-update" ? "此项可由程序安全更新，保留项目自定义内容。"
+                            : kind === "merge" ? "现有内容与新版初始化模板不同，需要保留项目配置后合并。"
+                                : /not a directory/.test(detail ?? "") ? "这里需要一个目录，但当前路径被文件占用。"
+                                    : /removed.*local changes/.test(detail ?? "") ? "新版不再使用此文件，但它包含本地修改，需要决定保留还是删除。"
+                                        : /target path.*already exists/.test(detail ?? "") ? "迁移目标已有不同内容，需要确认两份文件如何保留。"
+                                            : "此项无法安全自动处理，请先核对检查详情，再确定处理方式。";
+                    pendingItems.push({ path: item.path, kind: itemKind, reason,
+                        nextStep: itemKind === "safe-update" ? "点击更新按钮即可处理。"
+                            : itemKind === "merge" ? "可将下方处理说明交给智能体合并；只有需求冲突时才需你确认。"
+                                : "将处理说明交给智能体检查；需要取舍时确认方案，处理后重新检查。",
+                        ...(detail ? { detail } : {}) });
+                }
+            }
+            const modelsReady = record(report.modelReadiness).status === "ready";
+            if (!modelsReady)
+                pendingItems.push({ path: "模型配置", kind: "model",
+                    reason: "当前模型配置或认证尚未就绪，更新文件不能解决此问题。",
+                    nextStep: "检查模型定义及提供商认证，保留仍可用的模型配置，完成后重新检查。" });
+            const canUpdate = pendingItems.some(item => item.kind === "safe-update");
+            const needsAttention = pendingItems.some(item => item.kind !== "safe-update") || !report.ok || report.surfaceState !== "recorded" && !canUpdate;
+            if (needsAttention || canUpdate) {
+                const safeCount = pendingItems.filter(item => item.kind === "safe-update").length;
+                const message = canUpdate
+                    ? `有 ${safeCount} 项可在此更新。${needsAttention ? "其余待处理项的原因和下一步见下方。" : "更新会保留项目自定义内容。"}`
+                    : "暂无可直接更新的内容。请按下方原因处理，完成后重新检查。";
+                if (!pendingItems.length)
+                    pendingItems.push({ path: "初始化配置", kind: "confirmation",
+                        reason: "检查尚未通过，但没有返回可自动更新的项目。",
+                        nextStep: "复制处理说明交给智能体检查初始化记录，完成后重新检查。" });
+                return { ...this.snapshot(needsAttention ? "needs-attention" : "update-available", message, [...new Set(pendingItems.map(item => item.path))]), canUpdate, pendingItems };
+            }
+            return this.snapshot("ready", "工作区配置已就绪");
+        }
+        catch (error) {
+            return this.snapshot("error", error instanceof Error ? error.message : "初始化状态检查失败");
+        }
+    }
+    async check(refresh = false) {
+        const latest = (await this.options.operations.list()).filter(op => op.action === "workspaceInitialize").at(-1);
+        const running = latest && !TERMINAL_OPERATION_STATES.has(latest.state) && latest.state !== "needs-reconcile";
+        if (!running && (refresh || !this.cached || Date.now() - this.cached.at > 30_000)) {
+            const generation = this.generation;
+            this.pending ??= this.inspect().then(value => { if (generation === this.generation)
+                this.cached = { value, at: Date.now() }; return value; }).finally(() => { this.pending = undefined; });
+            await this.pending;
+        }
+        const value = this.cached?.value ?? this.snapshot("uninitialized", "正在初始化工作区…");
+        return { ...value, ...(latest ? { operation: { operationId: latest.operationId, state: latest.state, ...(latest.errorMessage ? { message: latest.errorMessage } : {}) } } : {}) };
+    }
+    async start(clientRequestId, model) {
+        const created = await this.options.operations.create({ clientRequestId, action: "workspaceInitialize", actionParams: { ...(model ? { model } : {}) } });
+        if (created.kind !== "created")
+            return created;
+        const operationId = created.operation.operationId;
+        if (this.activeOperationId) {
+            await this.options.operations.update(operationId, { state: "failed", finishedAt: new Date().toISOString(), errorCode: "WORKSPACE_INIT_BUSY", errorMessage: "此工作区已有初始化操作正在运行" });
+            return created;
+        }
+        this.activeOperationId = operationId;
+        this.generation += 1;
+        queueMicrotask(() => { void this.execute(operationId, model); });
+        return created;
+    }
+    async execute(operationId, model) {
+        let release;
+        try {
+            await this.options.operations.update(operationId, { state: "running", startedAt: new Date().toISOString() });
+            this.options.events.append(operationId, { at: new Date().toISOString(), kind: "state", state: "running", message: `正在检查并配置 ${this.options.name}` });
+            release = await (this.options.acquireLock ?? (() => acquireUpdateLock(updateLockPath(os.homedir()))))();
+            if (!release)
+                throw new Error("程序更新或其他初始化操作正在进行，请稍后重试");
+            const activity = await (this.options.readActivity ?? readInitRuntimeActivity)(this.options.repoRoot);
+            if (activity.workerProjectionError || activity.activeDagRunIds.length || activity.activeWorkerTasks || activity.activeWorkerBatches || this.options.activeChatTurnCount())
+                throw new Error("当前工作区有任务或对话正在运行，请结束后重试");
+            const operations = await this.options.operations.list();
+            if (operations.some(op => op.operationId !== operationId && !TERMINAL_OPERATION_STATES.has(op.state) && op.state !== "needs-reconcile"))
+                throw new Error("当前工作区有其他操作正在运行，请稍后重试");
+            const before = await this.inspect();
+            if (before.state === "error")
+                throw new Error(before.message);
+            if (before.state === "uninitialized") {
+                if (!model || !before.models?.some(item => item.reference === model))
+                    throw new Error("请选择一个可用的初始模型；可在模型设置中完成认证后重新检查");
+                await this.command(["init", "--profile", "full", "--merge", "--client-recovery", "project", "--model", model, "--json"], "apply");
+            }
+            else if (before.canUpdate) {
+                await this.command(["init", "update", "--apply-safe", "--client-recovery", "project", "--json"], "apply");
+            }
+            else if (before.state !== "ready")
+                throw new Error("没有可安全更新的内容；请查看待处理项的原因和下一步。");
+            const after = await this.inspect();
+            this.cached = { value: after, at: Date.now() };
+            const state = after.state === "ready" ? "succeeded" : "needs-reconcile";
+            await this.options.operations.update(operationId, { state, finishedAt: new Date().toISOString(), result: { initialization: after }, ...(state !== "succeeded" ? { errorCode: "INIT_NEEDS_RECONCILE", errorMessage: after.message } : {}) });
+            this.options.events.append(operationId, { at: new Date().toISOString(), kind: "state", state, message: after.message });
+        }
+        catch (error) {
+            this.cached = undefined;
+            const message = error instanceof Error ? error.message : "工作区初始化失败";
+            await this.options.operations.update(operationId, { state: "failed", finishedAt: new Date().toISOString(), errorCode: "WORKSPACE_INIT_FAILED", errorMessage: message });
+            this.options.events.append(operationId, { at: new Date().toISOString(), kind: "error", state: "failed", message });
+        }
+        finally {
+            this.activeOperationId = undefined;
+            await release?.().catch(() => undefined);
+        }
+    }
+}

package/dist/worker/delivery/git-transaction.js

@@ -360,6 +360,8 @@ function matchesGlob(filePath, glob) {
     let pattern = "^";
     for (let index = 0; index < normalizedGlob.length; index += 1) {
         const char = normalizedGlob[index];
+        if (char === undefined)
+            continue;
         if (char === "*" && normalizedGlob[index + 1] === "*") {
             pattern += ".*";
             index += 1;

package/dist/worker/feature/fullstack-validate.js

@@ -204,6 +204,8 @@ export function validateFullstackStructure(input) {
         for (let j = i + 1; j < writerNodes.length; j++) {
             const a = writerNodes[i];
             const b = writerNodes[j];
+            if (!a || !b)
+                continue;
             const aPaths = collectWritePaths(taskSpecs.get(a.id));
             const bPaths = collectWritePaths(taskSpecs.get(b.id));
             if (!writeSetsOverlap(aPaths, bPaths))

package/dist/worker/loop-agent/loop-agent-client.js

@@ -310,7 +310,10 @@ function findSourceScript(baseArgs, cwd) {
     // Look for the last .ts/.js/.mjs/.cjs file in baseArgs
     let scriptIdx = -1;
     for (let i = baseArgs.length - 1; i >= 0; i--) {
-        const ext = path.extname(baseArgs[i]).toLowerCase();
+        const candidate = baseArgs[i];
+        if (candidate === undefined)
+            continue;
+        const ext = path.extname(candidate).toLowerCase();
         if (ext === ".ts" || ext === ".js" || ext === ".mjs" || ext === ".cjs") {
             scriptIdx = i;
             break;
@@ -318,7 +321,10 @@ function findSourceScript(baseArgs, cwd) {
     }
     if (scriptIdx < 0)
         return undefined;
-    const scriptPath = path.resolve(cwd, baseArgs[scriptIdx]);
+    const scriptArg = baseArgs[scriptIdx];
+    if (scriptArg === undefined)
+        return undefined;
+    const scriptPath = path.resolve(cwd, scriptArg);
     try {
         const s = statSync(scriptPath);
         if (s.isFile())

package/dist/worker/materialize/harness-task-materializer.js

@@ -551,7 +551,10 @@ export function indexAcceptanceItems(raw) {
         if (!match)
             continue;
         const id = match[1];
-        const summary = compactSummary(match[2]);
+        const body = match[2];
+        if (id === undefined || body === undefined)
+            continue;
+        const summary = compactSummary(body);
         if (!map.has(id))
             map.set(id, summary);
     }

package/dist/worker/metrics/projector.js

@@ -110,7 +110,7 @@ export async function projectMonthlyMetrics(input) {
 }
 function ratio(numerator, denominator, missingData) { return { numerator, denominator, value: denominator ? numerator / denominator : null, sampleSize: denominator, missingData }; }
 function median(values) { if (!values.length)
-    return null; const middle = Math.floor(values.length / 2); return values.length % 2 ? values[middle] : (values[middle - 1] + values[middle]) / 2; }
+    return null; const middle = Math.floor(values.length / 2); return values.length % 2 ? (values[middle] ?? 0) : ((values[middle - 1] ?? 0) + (values[middle] ?? 0)) / 2; }
 function inWindow(value, start, end) { const time = new Date(value).getTime(); return time >= start.getTime() && time < end.getTime(); }
 function dedupeRuns(runs) { return [...new Map(runs.map((run) => [run.workerRunId, run])).values()]; }
 async function countBoundaryInterceptions(root, start, end) { let interceptions = 0; let audited = 0; try {

package/dist/worker/observability/event-store.js

@@ -11,7 +11,10 @@ function serializeEvent(event) {
 }
 /** Identifiers used as event-store path segments must not alter the route. */
 export function isSafeObservabilityIdentifier(value) {
-    return value !== "." && value !== ".." && !/[\\/\0]/.test(value);
+    return (typeof value === "string" &&
+        value !== "." &&
+        value !== ".." &&
+        !/[\\/\0]/.test(value));
 }
 export function createWorkerEventStore(jsonlPath) {
     return {

package/dist/worker/observability/read-model.js

@@ -1444,8 +1444,11 @@ async function loadFailureHandoffs(repoRoot) {
             const match = /^(.+)-failure-closeout-draft\.md$/.exec(entry.name);
             if (!match)
                 continue;
+            const workerRunId = match[1];
+            if (workerRunId === undefined)
+                continue;
             handoffs.push({
-                workerRunId: match[1],
+                workerRunId,
                 closeoutDraftPath: path.join(handoffDir, entry.name),
             });
         }

package/dist/worker/observe/node-transparency.js

@@ -106,6 +106,12 @@ export async function loadDagNodeContextSummary(repoRoot, dagRunId, nodeId, atte
             body: { error: "Invalid node identifier", reason: "invalid-id" },
         };
     }
+    if (!isSafeObservabilityIdentifier(dagRunId)) {
+        return {
+            status: 400,
+            body: { error: "Invalid DAG run identifier", reason: "invalid-id" },
+        };
+    }
     const loaded = await loadRunFacts(repoRoot, dagRunId);
     if (!loaded.ok)
         return loaded.failure;
@@ -242,6 +248,12 @@ export async function loadDagNodeArtifactInventory(repoRoot, dagRunId, nodeId) {
             body: { error: "Invalid node identifier", reason: "invalid-id" },
         };
     }
+    if (!isSafeObservabilityIdentifier(dagRunId)) {
+        return {
+            status: 400,
+            body: { error: "Invalid DAG run identifier", reason: "invalid-id" },
+        };
+    }
     const loaded = await loadRunFacts(repoRoot, dagRunId);
     if (!loaded.ok)
         return loaded.failure;
@@ -436,6 +448,8 @@ async function loadVerifiedArtifactBytes(repoRoot, dagRunId, nodeId, artifactId)
     }
 }
 export async function loadDagNodeArtifactPreview(repoRoot, dagRunId, nodeId, artifactId) {
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId))
+        return { status: 400, body: { error: "Invalid DAG run or node identifier", reason: "invalid-id" } };
     const verified = await loadVerifiedArtifactBytes(repoRoot, dagRunId, nodeId, artifactId);
     if (verified.status !== 200)
         return verified;
@@ -448,6 +462,8 @@ export async function loadDagNodeArtifactPreview(repoRoot, dagRunId, nodeId, art
 }
 /** Full text uses the same binding and safety checks as the bounded preview. */
 export async function loadDagNodeArtifactDownload(repoRoot, dagRunId, nodeId, artifactId) {
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId))
+        return { status: 400, body: { error: "Invalid DAG run or node identifier", reason: "invalid-id" } };
     const verified = await loadVerifiedArtifactBytes(repoRoot, dagRunId, nodeId, artifactId);
     if (verified.status !== 200)
         return verified;
@@ -469,7 +485,7 @@ async function readValidatedContextReceipt(boundaryRoot, targetPath) {
     return effectiveNodeContextV1Schema.safeParse(null);
 }
 export async function loadDagNodeContextComponent(repoRoot, dagRunId, nodeId, attempt, componentIndex) {
-    if (!isSafeObservabilityIdentifier(nodeId) || !Number.isSafeInteger(attempt) || attempt < 1 || !Number.isSafeInteger(componentIndex) || componentIndex < 0)
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId) || !Number.isSafeInteger(attempt) || attempt < 1 || !Number.isSafeInteger(componentIndex) || componentIndex < 0)
         return { status: 400, body: { error: "Invalid context selection", reason: "invalid-id" } };
     const loaded = await loadRunFacts(repoRoot, dagRunId);
     if (!loaded.ok)
@@ -502,6 +518,12 @@ function stringField(value, key) {
     return typeof value?.[key] === "string" ? value[key] : undefined;
 }
 export async function loadDagRunLineage(repoRoot, dagRunId) {
+    if (!isSafeObservabilityIdentifier(dagRunId)) {
+        return {
+            status: 400,
+            body: { error: "Invalid DAG run identifier", reason: "invalid-id" },
+        };
+    }
     const loaded = await loadRunFacts(repoRoot, dagRunId);
     if (!loaded.ok)
         return loaded.failure;

package/dist/worker/observe/routes.js

@@ -835,6 +835,10 @@ async function handleDagNodeExecutionOutput(_req, res, match, ctx) {
     const dagRunId = match.params.id;
     const nodeId = match.params.sub;
     const key = match.query.get("key");
+    if (dagRunId === undefined || nodeId === undefined) {
+        sendJson(res, 400, { error: "Invalid DAG node execution output selection", reason: "invalid-id" });
+        return;
+    }
     // Reject path-shaped inputs even if smuggled via key/query aliases.
     if (match.query.has("path") || match.query.has("artifactPath")) {
         sendJson(res, 400, {

package/dist/worker/observe/static/operator-chrome.js

@@ -26,6 +26,7 @@ export const INSPECT_TABS = Object.freeze([
 	{ id: "dashboard", label: "总览", href: "/#/inspect" },
 	{ id: "pool", label: "资源池", href: "/#/inspect/pool" },
 	{ id: "failures", label: "异常 Task", href: "/#/inspect/failures" },
+	{ id: "scheduled-goals", label: "定时任务", href: "/#/inspect/scheduled-goals" },
 ]);
 
 export const READINESS_LABELS = Object.freeze({
@@ -92,7 +93,7 @@ export function parseInspectObjectView(hashValue) {
 
 /**
  * Inspect 当前 hash 应高亮的工作区 tab href。
- * 三个一级集合视图映射到各自 tab；下钻/对象页（dag/dags/run/night 等）
+ * 一级集合视图映射到各自 tab；下钻/对象页（dag/dags/run/night 等）
  * 不高亮任何 tab——位置由面包屑与上下文 chip 表达（`#/dags` 自 0.33.0
  * 起是独立历史分页页，不再是总览滚动别名）。
  */
@@ -106,6 +107,7 @@ export function activeInspectTabHref(hashValue) {
 		return "/#/inspect/pool";
 	}
 	if (internal === "/failures") return "/#/inspect/failures";
+	if (internal === "/scheduled-goals") return "/#/inspect/scheduled-goals";
 	if (internal.startsWith("/feature/")) return "/#/inspect";
 	return null;
 }

package/dist/worker/observe/static/styles.css

@@ -1281,6 +1281,9 @@ body.is-resizing-dag-graph {
 	user-select: none;
 }
 .dag-inspector-header {
+	/* Keep the attempt menu above the content's sticky timeline toolbar. */
+	position: relative;
+	z-index: 6;
 	display: grid;
 	grid-template-columns: minmax(0, 1fr) auto;
 	gap: var(--space-3);
@@ -5401,10 +5404,10 @@ button.copy-command:focus-visible {
 .risk-dag-items { display: grid; gap: 6px; padding-top: 8px; }
 /* The hosted Console also has .panel styles; keep the reader shell flush. */
 #dag-inspector { padding: 0; gap: 0; }
-.dag-inspector-header .dag-inspector-attempt-bar { flex-wrap: nowrap; background: transparent; }
-.dag-inspector-header .dag-inspector-attempt-select { min-width: 0; flex: 0 1 126px; }
-.dag-inspector-header .dag-inspector-attempt-preview { flex: 1 1 auto; flex-wrap: nowrap; padding: 0; }
-.dag-inspector-header .dag-inspector-attempt-category,
+.dag-inspector-header .dag-inspector-attempt-bar { flex-wrap: wrap; gap: 8px; background: transparent; }
+.dag-inspector-header .dag-inspector-attempt-select { min-width: 112px; flex: 0 0 126px; }
+.dag-inspector-header .dag-inspector-attempt-preview { flex: 1 1 100px; flex-wrap: wrap; padding: 0; }
+.dag-inspector-header .dag-inspector-attempt-category { display: inline; white-space: normal; overflow-wrap: anywhere; }
 .dag-inspector-header .dag-inspector-attempt-duration { display: none; }
 @container (max-width: 560px) {
  .process-timeline-toolbar { display: grid; grid-template-columns: minmax(80px, 1fr) 32px 32px 32px; gap: 4px; }

package/dist/worker/observe/static/views/dag-inspector.js

@@ -3590,21 +3590,13 @@ function buildAttemptBar(dagRunId, node) {
 
 	const bar = el("div", "dag-inspector-attempt-bar");
 	bar.appendChild(el("label", "dag-inspector-attempt-label", "执行分次"));
-	const choose = (nextKey, source = "select") => {
+	const choose = (nextKey) => {
 		uiState.dagInspectorAttempt = { dagRunId, nodeId: node.nodeId, key: String(nextKey) };
 		inspectorNodeSelections.set(`${dagRunId}:${node.nodeId}`, uiState.dagInspectorAttempt);
 		renderDagInspectorForCurrent();
 		const nextBar = document.querySelector(".dag-inspector-header .dag-inspector-attempt-bar");
-		const control = nextBar?.querySelector(`[data-attempt-action="${source}"]`);
-		(control && !control.disabled ? control : nextBar?.querySelector(".custom-select-trigger"))?.focus({ preventScroll: true });
+		nextBar?.querySelector(".custom-select-trigger")?.focus({ preventScroll: true });
 	};
-	const selectedIndex = options.findIndex((option) => option.key === selectedKey);
-	const previous = iconButton("上一次尝试", "ri-arrow-left-s-line");
-	previous.type = "button";
-	previous.dataset.attemptAction = "previous";
-	previous.disabled = selectedIndex <= 0;
-	previous.addEventListener("click", () => choose(options[selectedIndex - 1].key, "previous"));
-	bar.appendChild(previous);
 	const select = createCustomSelect({
 		ariaLabel: "选择执行分次",
 		className: "dag-inspector-attempt-select",
@@ -3619,12 +3611,6 @@ function buildAttemptBar(dagRunId, node) {
 	// `.value` after assign + change (StubNode handler contract).
 	select.value = selectedKey;
 	bar.appendChild(select);
-	const next = iconButton("下一次尝试", "ri-arrow-right-s-line");
-	next.type = "button";
-	next.dataset.attemptAction = "next";
-	next.disabled = selectedIndex >= options.length - 1;
-	next.addEventListener("click", () => choose(options[selectedIndex + 1].key, "next"));
-	bar.appendChild(next);
 
 	const selected =
 		options.find((option) => option.key === selectedKey) ??
@@ -3636,16 +3622,16 @@ function buildAttemptBar(dagRunId, node) {
 	if (status) {
 		preview.appendChild(el("span", `badge badge-${status.cls}`, status.label));
 	}
-	if (status?.cls === "failed" && data.failureCategory) {
+	if (status?.cls === "failed") {
 		// 仅失败尝试显示原因；部分 runtime 会在成功尝试保留
 		// failureCategory="success"，不能将其误映射为「其他失败原因」。
 		// 未知失败分类仍 fail-closed，raw token 仅保留在 title 诊断中。
 		const reason = el(
 			"span",
 			"dag-inspector-attempt-category",
-			`原因 ${attemptFailureLabel(data.failureCategory)}`,
+			data.failureCategory ? `原因 ${attemptFailureLabel(data.failureCategory)}` : "未记录失败原因",
 		);
-		reason.setAttribute("title", `failureCategory ${data.failureCategory}`);
+		if (data.failureCategory) reason.setAttribute("title", `failureCategory ${data.failureCategory}`);
 		preview.appendChild(reason);
 	}
 	if (data.durationMs !== undefined) {

package/dist/worker/outcomes/declared-artifacts.js

@@ -12,6 +12,8 @@ export function matchesPathGlob(filePath, glob) {
     let pattern = "^";
     for (let index = 0; index < normalizedGlob.length; index += 1) {
         const char = normalizedGlob[index];
+        if (char === undefined)
+            continue;
         if (char === "*" && normalizedGlob[index + 1] === "*") {
             pattern += ".*";
             index += 1;

package/dist/worker/preflight.js

@@ -120,6 +120,9 @@ export async function preflightTargetRepo(input) {
     }
     if (input.runCheckRepo) {
         const [command, ...args] = input.checkRepoCommand ?? ["bash", "scripts/check-repo.sh"];
+        if (command === undefined) {
+            throw new Error("check-repo command requires a binary");
+        }
         const checkRepo = await input.client.runExternal(command, args, {
             cwd: input.repoRoot,
             artifactName: "check-repo",