@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.19

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).
  *
@@ -298,7 +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();
+    const browserAutomation = new BrowserAutomationService({
+        profileDir: appData.browserProfile,
+        downloadsDir: appData.browserDownloads,
+        screenshotsDir: appData.browserScreenshots,
+    });
     const chatRuntime = new ConsolePiRuntime({
         cwd: repoRoot,
         sessionDir: appData.chatSessions,
@@ -336,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,
     });
@@ -370,6 +383,7 @@ export async function createWorkspaceContext(record, deps) {
             if (disposed)
                 return;
             disposed = true;
+            scheduledGoalHost.stop();
             try {
                 goalRoundDriver.dispose();
             }
@@ -388,6 +402,7 @@ export async function createWorkspaceContext(record, deps) {
             catch {
                 // best-effort
             }
+            void browserAutomation.dispose();
             try {
                 nightAuxTicker.dispose();
             }
@@ -396,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/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/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",

package/dist/worker/scheduler/scheduled-goal-dispatch.js

@@ -0,0 +1,117 @@
+import { createHash, randomUUID } from "node:crypto";
+import { readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { getTaskPaths } from "../../task/runtime.js";
+import { computeTaskConfigSha256 } from "../../task/contract/hash.js";
+import { assessAutonomousExecutionEligibility, deriveEligibilityFactsFromDagSpec } from "../console/dag-execution-receipt.js";
+import { scheduledGoalDraftSchema } from "./scheduled-goal-types.js";
+const bindingSchema = z.object({
+    taskId: z.string(), revision: z.number().int().positive(), canonicalHash: z.string(),
+    taskConfigSha256: z.string(), projectionVersion: z.number(), canonicalizerVersion: z.number(), taskConfigSchemaVersion: z.number(),
+});
+const statusSchema = z.object({
+    taskId: z.string(), lifecycleState: z.literal("awaiting-write-set-approval"),
+    contract: z.object({ effectiveStatus: z.literal("managed"), revision: z.number().int().positive(),
+        canonicalHash: z.string(), observedCanonicalHash: z.string(), transactionIncomplete: z.literal(false),
+        taskConfigSha256: z.string(), projectionVersion: z.number(), canonicalizerVersion: z.number(), taskConfigSchemaVersion: z.number(), }),
+    dagDraft: z.object({ exists: z.literal(true), strictValidated: z.literal(true), specHash: z.string() }),
+    gate: z.object({ id: z.string().min(1), digest: z.string().min(1), type: z.literal("human-approval"),
+        bound: z.object({ taskId: z.string(), contractRevision: z.number(), contractCanonicalHash: z.string(), dagSpecHash: z.string() }), }),
+    activeRun: z.unknown().nullable().optional(), blockers: z.array(z.unknown()).length(0),
+});
+/** Freeze only a CLI-prepared managed task. This read-only intake never approves or starts a DAG. */
+export async function prepareScheduledGoalDraft(input, client) {
+    // Validate caller-controlled identity before using it in CLI arguments or paths.
+    const parsed = scheduledGoalDraftSchema.omit({ prepared: true, controllerRef: true }).parse(input);
+    const identity = client.getIdentity();
+    if (!identity)
+        throw new Error("scheduled goal requires a pinned controller");
+    const root = await realpath(parsed.worktreeRef);
+    const paths = getTaskPaths(root, parsed.managedTaskId);
+    const readBound = async (file) => {
+        const resolved = await realpath(file);
+        const relative = path.relative(root, resolved);
+        if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            throw new Error("scheduled goal prepared artifact escapes worktree");
+        return readFile(resolved, "utf8");
+    };
+    const status = await client.run(["task", "status", parsed.managedTaskId, "--json"], { cwd: root, expectJson: true, artifactName: `scheduled-goal-admission-${parsed.managedTaskId}-${randomUUID()}`, timeoutMs: 30_000 });
+    if (!status.ok || status.exitCode !== 0)
+        throw new Error("scheduled goal task status failed");
+    const envelope = z.object({ ok: z.literal(true), result: statusSchema }).parse(status.json);
+    const snapshot = envelope.result;
+    if (snapshot.taskId !== parsed.managedTaskId || snapshot.activeRun != null ||
+        snapshot.contract.canonicalHash !== snapshot.contract.observedCanonicalHash ||
+        snapshot.gate.bound.taskId !== parsed.managedTaskId ||
+        snapshot.gate.bound.contractRevision !== snapshot.contract.revision ||
+        snapshot.gate.bound.contractCanonicalHash !== snapshot.contract.canonicalHash)
+        throw new Error("scheduled goal managed contract binding mismatch");
+    const [dagBytes, configBytes] = await Promise.all([readBound(paths.dagDraftPath), readBound(paths.taskConfigPath)]);
+    const dagSpecHash = `sha256:${createHash("sha256").update(dagBytes).digest("hex")}`;
+    if (snapshot.dagDraft.specHash !== dagSpecHash || snapshot.gate.bound.dagSpecHash !== dagSpecHash)
+        throw new Error("scheduled goal validated DAG drift");
+    const dag = JSON.parse(dagBytes);
+    const binding = bindingSchema.parse(dag.taskContractBinding);
+    const expectedBinding = bindingSchema.parse({ ...snapshot.contract, taskId: parsed.managedTaskId });
+    if (dag.version !== 4 || JSON.stringify(binding) !== JSON.stringify(expectedBinding))
+        throw new Error("scheduled goal DAG contract binding mismatch");
+    const configJson = JSON.parse(configBytes);
+    if (computeTaskConfigSha256(configJson) !== binding.taskConfigSha256)
+        throw new Error("scheduled goal task configuration drift");
+    const config = z.object({ taskKind: z.string(), allowedPaths: z.array(z.string()), forbiddenPaths: z.array(z.string()) }).parse(configJson);
+    if (config.taskKind !== parsed.workflow || JSON.stringify(config.allowedPaths) !== JSON.stringify(parsed.allowedPaths) ||
+        JSON.stringify(config.forbiddenPaths) !== JSON.stringify(parsed.forbiddenPaths))
+        throw new Error("scheduled goal task scope or workflow mismatch");
+    const assessment = assessAutonomousExecutionEligibility(deriveEligibilityFactsFromDagSpec({
+        dagSpec: dag, allowedPaths: parsed.allowedPaths, forbiddenPaths: parsed.forbiddenPaths,
+    }));
+    if (!assessment.ok)
+        throw new Error(`scheduled goal ineligible: ${assessment.reason}`);
+    const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
+    return scheduledGoalDraftSchema.parse({ ...parsed, controllerRef: identity.packageFingerprint.value,
+        prepared: { gateToken: `${snapshot.gate.id}:${snapshot.gate.digest}`,
+            dagPath: path.relative(root, paths.dagDraftPath), dagHash: digest(dagBytes),
+            contractPath: path.relative(root, paths.taskConfigPath), contractHash: digest(configBytes) }, });
+}
+/** Materialize only contract/runtime inputs; execution remains owned by the operation host. */
+export async function prepareDerivedScheduledGoalTask(goalId, ownerToken, goals, client) {
+    const { mkdir, writeFile } = await import("node:fs/promises");
+    const goal = await goals.get(goalId);
+    const entry = goal.supervisions.at(-1);
+    if (goal.state !== "admitted" || !entry || entry.ownerToken !== ownerToken || entry.state !== "preparing" || !entry.proposal)
+        throw new Error("derived preparation not authorized");
+    if (client.getIdentity()?.packageFingerprint.value !== goal.frozen.controllerRef)
+        throw new Error("derived controller drift");
+    const directory = path.join(goal.frozen.worktreeRef, ".harness", "scheduled-goal-inputs");
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const prdPath = path.join(directory, `${entry.managedTaskId}.md`);
+    const content = ["# Scheduled goal continuation", "## Goal", goal.frozen.originalGoal,
+        "## Observed gap", entry.proposal.summary, "## Next task", entry.proposal.instructions,
+        "## Acceptance criteria", ...goal.frozen.acceptance.criteria.map((ac) => `- ${ac.acId}: ${ac.description}\n  Verification: ${ac.command}`),
+        "## Scope", `Workflow: ${goal.frozen.workflow}; acceptance policy: ${goal.frozen.acceptance.policy}.`,
+        `Allowed paths: ${JSON.stringify(goal.frozen.allowedPaths)}. Forbidden paths: ${JSON.stringify(goal.frozen.forbiddenPaths)}.`,
+        "Preserve the current worktree changes. Do not change acceptance, dependencies, Git history, controller or runtime configuration. Do not push or merge.",
+        `Parent evidence: ${entry.parentEvidenceId}; tree: ${entry.treeHash}.`, ""].join("\n\n");
+    await writeFile(prdPath, content, { flag: "wx", mode: 0o600 });
+    const boundaryArgs = goal.frozen.allowedPaths.flatMap((ref) => ["--allowed-path", ref])
+        .concat(goal.frozen.forbiddenPaths.flatMap((ref) => ["--forbidden-path", ref]))
+        .concat(goal.frozen.acceptance.criteria.flatMap((ac) => ["--verify", `${ac.acId}:${ac.command}`]));
+    for (const [step, args] of [
+        ["create", ["task", "advance", entry.managedTaskId, `Scheduled goal continuation ${entry.taskRevision}`, "--prd", prdPath, "--task-kind", goal.frozen.workflow, ...boundaryArgs, "--json"]],
+        ["prepare", ["task", "advance", entry.managedTaskId, "--task-kind", goal.frozen.workflow, ...boundaryArgs, "--json"]],
+    ]) {
+        const current = await goals.get(goalId);
+        if (current.state !== "admitted" || current.supervisions.at(-1)?.ownerToken !== ownerToken)
+            throw new Error("derived preparation authorization lost");
+        const remaining = Math.min(Date.parse(goal.frozen.time.stopAtUtc), Date.parse(goal.frozen.time.expiresAt)) - Date.now();
+        if (remaining <= 0)
+            throw new Error("derived preparation expired");
+        const result = await client.run([...args], { cwd: goal.frozen.worktreeRef, expectJson: true,
+            artifactName: `${entry.managedTaskId}-${step}`, timeoutMs: Math.min(remaining, 300000) });
+        if (!result.ok || result.exitCode !== 0 || result.timedOut)
+            throw new Error(`derived task ${step} failed or unknown`);
+    }
+    const { prepared: _prepared, controllerRef: _controller, ...input } = goal.frozen;
+    return prepareScheduledGoalDraft({ ...input, managedTaskId: entry.managedTaskId }, client);
+}

package/dist/worker/scheduler/scheduled-goal-evidence.js

@@ -0,0 +1,167 @@
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { lstat, readFile, readlink, realpath } from "node:fs/promises";
+import path from "node:path";
+import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { scheduledGoalDraftSchema } from "./scheduled-goal-types.js";
+const execFileAsync = promisify(execFile);
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+/** Run only frozen AC commands. A timeout is uncertain execution, never a passing or repairable failure. */
+export async function evaluateScheduledGoalCriteria(frozen, options = {}) {
+    frozen = scheduledGoalDraftSchema.pick({ worktreeRef: true, frozenBase: true, allowedPaths: true, forbiddenPaths: true, acceptance: true, time: true }).strip().parse(frozen);
+    if (options.commandTimeoutMs !== undefined && (!Number.isFinite(options.commandTimeoutMs) || options.commandTimeoutMs <= 0))
+        throw new Error("invalid acceptance command timeout");
+    const now = options.now ?? (() => new Date());
+    const startedAt = now().toISOString();
+    const capture = () => captureScheduledGoalTree(frozen.worktreeRef, frozen.frozenBase, frozen.allowedPaths, frozen.forbiddenPaths);
+    const before = await capture();
+    const criteria = [];
+    let stopped = before.scopeViolations.length ? "scope_violation" : undefined;
+    let drift = false;
+    let executionUnknown = false;
+    for (const criterion of frozen.acceptance.criteria) {
+        if (options.mayRun && !await options.mayRun())
+            stopped ??= "assessment_cancelled";
+        const current = await capture();
+        if (current.treeHash !== before.treeHash) {
+            drift = true;
+            stopped = "tree_changed_during_acceptance";
+        }
+        const remaining = Math.min(Date.parse(frozen.time.stopAtUtc), Date.parse(frozen.time.expiresAt)) - now().getTime();
+        if (remaining <= 0)
+            stopped ??= "authorization_expired";
+        const result = { acId: criterion.acId, command: criterion.command,
+            status: "pending", exitCode: null, stdout: "", stderr: "", outputHash: sha256(JSON.stringify({ stdout: "", stderr: "", exitCode: null })), };
+        if (stopped)
+            result.reason = stopped;
+        else {
+            try {
+                const output = await execFileAsync("bash", ["-lc", criterion.command], {
+                    cwd: frozen.worktreeRef, encoding: "utf8", maxBuffer: 1024 * 1024,
+                    timeout: Math.max(1, Math.min(remaining, options.commandTimeoutMs ?? 120_000)),
+                });
+                result.stdout = output.stdout;
+                result.stderr = output.stderr;
+                result.exitCode = 0;
+                result.status = "succeeded";
+            }
+            catch (error) {
+                const failure = error;
+                result.stdout = failure.stdout ?? "";
+                result.stderr = failure.stderr ?? "";
+                if (typeof failure.code === "number" && !failure.killed && !failure.signal) {
+                    result.exitCode = failure.code;
+                    result.status = "failed";
+                }
+                else {
+                    executionUnknown = true;
+                    result.reason = "command_execution_unknown";
+                    stopped = result.reason;
+                }
+            }
+            result.outputHash = sha256(JSON.stringify({ stdout: result.stdout, stderr: result.stderr, exitCode: result.exitCode }));
+            const verifiedTree = await capture();
+            if (verifiedTree.treeHash !== before.treeHash) {
+                drift = true;
+                stopped = "tree_changed_during_acceptance";
+            }
+        }
+        criteria.push(result);
+    }
+    const after = await capture();
+    drift ||= before.treeHash !== after.treeHash;
+    if (drift)
+        for (const result of criteria) {
+            if (result.reason === "command_execution_unknown")
+                continue;
+            result.status = "stale";
+            result.reason = "tree_changed_during_acceptance";
+        }
+    const finishedAt = now().toISOString();
+    const expired = Date.parse(finishedAt) >= Math.min(Date.parse(frozen.time.stopAtUtc), Date.parse(frozen.time.expiresAt));
+    const status = executionUnknown ? "pending" : drift ? "stale" : before.scopeViolations.length || after.scopeViolations.length ? "failed"
+        : expired ? "pending"
+            : criteria.some((result) => result.status === "pending") ? "pending"
+                : criteria.every((result) => result.status === "succeeded") ? "succeeded" : "failed";
+    return { before, after, criteria, status, executionUnknown, startedAt, finishedAt };
+}
+/** Hash actual delivery bytes, including nonignored untracked files; staging is not a tree change. */
+export async function captureScheduledGoalTree(worktree, base, allowedPaths, forbiddenPaths) {
+    if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(base))
+        throw new Error("invalid frozen base");
+    const root = await realpath(worktree);
+    const git = async (...args) => (await execFileAsync("git", ["-C", root, ...args], {
+        encoding: "utf8", timeout: 30_000, maxBuffer: 16 * 1024 * 1024,
+    })).stdout;
+    const [head, top, tracked, untracked, baseline, format] = await Promise.all([
+        git("rev-parse", "HEAD"), git("rev-parse", "--show-toplevel"),
+        git("ls-files", "-z", "--cached"), git("ls-files", "-z", "--others", "--exclude-standard"),
+        git("ls-tree", "-r", "-z", base), git("rev-parse", "--show-object-format"),
+    ]);
+    if (await realpath(top.trim()) !== root || head.trim() !== base)
+        throw new Error("scheduled goal worktree/base drift");
+    const entries = (value) => value.split("\0").filter(Boolean);
+    const objectFormat = format.trim();
+    if (objectFormat !== "sha1" && objectFormat !== "sha256")
+        throw new Error("unsupported Git object format");
+    const baseEntries = new Map(entries(baseline).map((entry) => {
+        const separator = entry.indexOf("\t");
+        const [mode, kind, objectId] = entry.slice(0, separator).split(" ");
+        if (separator < 0 || !mode || !kind || !objectId)
+            throw new Error("invalid Git tree entry");
+        return [entry.slice(separator + 1), { mode, kind, objectId }];
+    }));
+    const blobId = (bytes) => createHash(objectFormat).update(`blob ${bytes.length}\0`).update(bytes).digest("hex");
+    const names = [...new Set([...entries(tracked), ...entries(untracked), ...baseEntries.keys()])].sort();
+    const deliveryNames = new Set(names);
+    const files = [];
+    const changedPaths = [];
+    for (const name of names) {
+        const expected = baseEntries.get(name);
+        let actualId;
+        let actualMode;
+        const target = path.resolve(root, name);
+        const relative = path.relative(root, target);
+        if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            throw new Error("tree path escapes worktree");
+        try {
+            const parent = await realpath(path.dirname(target));
+            if (parent !== root && !parent.startsWith(`${root}${path.sep}`))
+                throw new Error("tree parent escapes worktree");
+            const stat = await lstat(target);
+            if (stat.isSymbolicLink()) {
+                const link = await readlink(target);
+                const resolved = await realpath(target).catch(() => { throw new Error(`unresolved delivery symlink: ${name}`); });
+                if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`))
+                    throw new Error(`delivery symlink escapes worktree: ${name}`);
+                if (!deliveryNames.has(path.relative(root, resolved)))
+                    throw new Error(`delivery symlink target is not fingerprinted: ${name}`);
+                files.push({ name, kind: "symlink", hash: sha256(link) });
+                actualId = blobId(Buffer.from(link));
+                actualMode = "120000";
+            }
+            else if (stat.isFile()) {
+                const bytes = await readFile(target);
+                files.push({ name, kind: "file", hash: sha256(bytes), executable: Boolean(stat.mode & 0o111) });
+                actualId = blobId(bytes);
+                actualMode = stat.mode & 0o111 ? "100755" : "100644";
+            }
+            else
+                throw new Error(`unsupported delivery entry: ${name}`);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                if (expected)
+                    files.push({ name, kind: "missing" });
+            }
+            else
+                throw error;
+        }
+        if (expected ? expected.objectId !== actualId || expected.mode !== actualMode : actualId !== undefined)
+            changedPaths.push(name);
+    }
+    const scopeViolations = changedPaths.filter((name) => !allowedPaths.some((pattern) => pathMatchesPattern(name, pattern))
+        || forbiddenPaths.some((pattern) => pathMatchesPattern(name, pattern)));
+    return { base, head: head.trim(), treeHash: sha256(JSON.stringify(files)), changedPaths, scopeViolations };
+}

package/dist/worker/scheduler/scheduled-goal-recovery.js

@@ -0,0 +1,62 @@
+import { captureScheduledGoalTree } from "./scheduled-goal-evidence.js";
+// ESRCH establishes absence only; permission errors and PID reuse never grant takeover.
+function ownerMissing(pid) {
+    if (pid === undefined)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return error.code === "ESRCH";
+    }
+}
+/** Read-only result projection. Reopening a result never authorizes another execution. */
+export async function readScheduledGoalResult(goalId, goals) {
+    const goal = await goals.get(goalId);
+    const evidence = goal.evidence.at(-1);
+    let evidenceCurrent = false;
+    let treeReadError = false;
+    if (evidence) {
+        try {
+            const tree = await captureScheduledGoalTree(goal.frozen.worktreeRef, goal.frozen.frozenBase, goal.frozen.allowedPaths, goal.frozen.forbiddenPaths);
+            evidenceCurrent = evidence.intentId === goal.intents.at(-1)?.intentId && tree.treeHash === evidence.committedTree.treeHash &&
+                tree.treeHash === evidence.assessment.after.treeHash && tree.scopeViolations.length === 0;
+        }
+        catch {
+            treeReadError = true;
+        }
+    }
+    const missingOwner = goal.intents.some((intent) => intent.state === "dispatching" && ownerMissing(intent.dispatchOwnerPid)) || Boolean(goal.assessmentAttempt && ownerMissing(goal.assessmentAttempt.ownerPid)) ||
+        goal.supervisions.some((entry) => ["requested", "preparing"].includes(entry.state) && ownerMissing(entry.ownerPid));
+    const uncertain = missingOwner || goal.state === "unknown" || goal.intents.some((intent) => intent.state === "unknown") ||
+        goal.supervisions.some((entry) => entry.state === "unknown") || Boolean(goal.assessmentAttempt && goal.acceptanceState === "pending");
+    const acceptance = evidence && !evidenceCurrent && ["accepted", "failed"].includes(goal.acceptanceState) ? "stale" : goal.acceptanceState;
+    return {
+        goalId, goalRevision: goal.goalRevision, stateVersion: goal.stateVersion,
+        state: goal.state, reasonCode: treeReadError ? "tree_unreadable" : acceptance === "stale" ? "evidence_drift" : goal.reasonCode,
+        acceptance, delivery: goal.deliveryState, evidenceCurrent,
+        budget: { limits: goal.frozen.budget, used: goal.used, tokenUsage: "unknown" },
+        supervision: goal.supervisions.map((entry) => ({ state: entry.state, taskRevision: entry.taskRevision, usageTokens: entry.usageTokens ?? null })),
+        execution: goal.intents.map((intent) => ({ taskRevision: intent.taskRevision, turnSeq: intent.turnSeq,
+            state: intent.state, operationId: intent.operationId, runId: intent.runId })),
+        evidence: goal.evidence.map((item) => ({ evidenceId: item.evidenceId, taskRevision: item.taskRevision,
+            treeHash: item.committedTree.treeHash, status: item.assessment.status, recordedAt: item.recordedAt,
+            criteria: item.assessment.criteria.map((ac) => ({ acId: ac.acId, status: ac.status, exitCode: ac.exitCode,
+                outputHash: ac.outputHash, evidenceRef: `${item.evidenceId}#${ac.acId}` })) })),
+        reconciliation: uncertain ? {
+            required: true,
+            reason: missingOwner ? "reservation_owner_missing" : goal.reasonCode ?? "execution_unknown",
+            instructions: "Inspect the associated operation/run and all descendant processes. Preserve the ledger and worktree. Do not delete ownership locks or automatically repeat an unknown action; an operator must reconcile execution before resources can be released.",
+        } : null,
+    };
+}
+/** Resolve a hash-bound output reference without exposing dispatch/owner capabilities. */
+export async function readScheduledGoalEvidence(goalId, evidenceId, acId, goals) {
+    const goal = await goals.get(goalId);
+    const evidence = goal.evidence.find((entry) => entry.evidenceId === evidenceId);
+    const criterion = evidence?.assessment.criteria.find((entry) => entry.acId === acId);
+    if (!evidence || !criterion)
+        throw new Error("scheduled goal evidence not found");
+    return { evidenceId, taskRevision: evidence.taskRevision, treeHash: evidence.committedTree.treeHash, ...criterion };
+}