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

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 };
+}