@tea-agent/loop-agent 0.41.1 → 0.42.0-next.10

package/dist/workflows/dag/path-safety.js

@@ -0,0 +1 @@
+export { assertReadableRegularFile, assertRealPathInsideBoundary, readFileBoundarySafe, } from "../../shared/path-safety.js";

package/dist/workflows/dag/prompt.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { DEFAULT_DAG_OUTPUT_LANGUAGE, } from "./types.js";
 import { formatStdoutPreview, formatUpstreamArtifactPointerMap, } from "./upstream-artifacts.js";
 export const MAX_UPSTREAM_CHARS = 2_000;
@@ -18,6 +19,40 @@ const RERUN_FEEDBACK_ROLES = new Set([
     "verifier",
     "reviewer",
 ]);
+function globPatternToRegExp(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    let source = "";
+    for (let index = 0; index < normalized.length; index += 1) {
+        const char = normalized[index];
+        if (char === "*" && normalized[index + 1] === "*") {
+            source += ".*";
+            index += 1;
+        }
+        else if (char === "*") {
+            source += "[^/]*";
+        }
+        else {
+            source += char.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+        }
+    }
+    return new RegExp(`^${source}$`);
+}
+function readSetAllowsArtifactPath(task, artifactPath) {
+    const readSet = task.readSet ?? [];
+    if (readSet.length === 0)
+        return true;
+    const candidate = artifactPath.replace(/\\/g, "/");
+    const candidates = [candidate];
+    for (const marker of ["/.harness/", "/source/", "/testcase/"]) {
+        const index = candidate.indexOf(marker);
+        if (index >= 0)
+            candidates.push(candidate.slice(index + 1));
+    }
+    return readSet.some((pattern) => {
+        const regex = globPatternToRegExp(pattern);
+        return candidates.some((value) => regex.test(value));
+    });
+}
 function formatBulletList(items, emptyLabel) {
     if (!items || items.length === 0)
         return emptyLabel;
@@ -45,9 +80,42 @@ function formatResolvedSkillInstructions(instructions) {
     if (!instructions || instructions.length === 0)
         return "(none)";
     return instructions
-        .map((instruction) => instruction.promptText)
+        .map((instruction) => formatSkillChecklist(instruction))
         .join("\n\n---\n\n");
 }
+/** Keep skill provenance, but turn bounded inline manuals into a small action list. */
+function formatSkillChecklist(instruction) {
+    const metadata = [
+        `Skill: ${instruction.name}`,
+        `Resolution: ${instruction.resolution}`,
+        ...(instruction.path ? [`Path: ${instruction.path}`] : []),
+        ...(instruction.sha256 ? [`Sha256: ${instruction.sha256}`] : []),
+        "Injection mode: checklist",
+    ];
+    if (instruction.resolution !== "resolved")
+        return [...metadata, instruction.promptText].join("\n");
+    const source = instruction.promptText.split("Instructions:\n")[1] ?? "";
+    const candidates = source
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^(?:#{1,3}\s+|[-*]\s+|\d+[.)]\s+)/.test(line) || line.length > 0)
+        .map((line) => line.replace(/^#{1,3}\s+/, "").replace(/^[-*]\s+/, "").replace(/^\d+[.)]\s+/, ""))
+        .filter((line) => line.length > 0);
+    const checklist = [];
+    let chars = 0;
+    for (const item of candidates) {
+        const bounded = item.slice(0, 240);
+        if (checklist.length >= 10 || chars + bounded.length > 1_600)
+            break;
+        checklist.push(`- ${bounded}`);
+        chars += bounded.length;
+    }
+    return [
+        ...metadata,
+        "Checklist (apply these actions; consult the immutable resolved file only when a listed action requires detail):",
+        ...(checklist.length > 0 ? checklist : ["- Follow the resolved skill's declared workflow."]),
+    ].join("\n");
+}
 export function formatOutputLanguageBlock(language = DEFAULT_DAG_OUTPUT_LANGUAGE) {
     if (language === "en") {
         return [
@@ -62,9 +130,10 @@ export function formatOutputLanguageBlock(language = DEFAULT_DAG_OUTPUT_LANGUAGE
         "如果当前节点任务明确要求其他语言，以节点的明确要求为准。",
     ].join("\n");
 }
-export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHARS) {
+export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHARS, runDir) {
     const sections = [];
     const toleratedFailures = new Set(task.failureAwareDependsOn ?? []);
+    const consumedArtifactIds = new Set((task.consumesArtifacts ?? []).map((binding) => binding.artifactId));
     for (const depId of task.depends_on) {
         const record = upstream[depId];
         const stdout = record?.stdout?.trim() ? record.stdout : "";
@@ -94,7 +163,7 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
                 : artifactKind === "assistant"
                     ? record.assistantArtifactPath
                     : undefined;
-            if (truncated && artifactPath) {
+            if (truncated && artifactPath && readSetAllowsArtifactPath(task, artifactPath)) {
                 section += formatUpstreamArtifactPointerMap(record, artifactKind === "stdout" ? "stdout" : "assistant");
             }
             else if (truncated && record.nodeRecordPath) {
@@ -118,6 +187,22 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
         }
         if (!record || record.status !== "FINISHED")
             continue;
+        const consumedArtifacts = (record.declaredArtifacts ?? []).filter((artifact) => consumedArtifactIds.has(artifact.artifactId));
+        const consumedArtifactSection = runDir && consumedArtifacts.length > 0
+            ? [
+                "Declared artifact bindings (read-only run evidence — use the exact paths below; do not edit):",
+                ...consumedArtifacts.flatMap((artifact) => {
+                    const absolutePath = path.resolve(runDir, ...artifact.path.split("/"));
+                    return [
+                        `- artifactId: ${artifact.artifactId}`,
+                        `  path: ${absolutePath}`,
+                        `  status: ${artifact.status}`,
+                        `  sha256: ${artifact.sha256 ?? "unknown"}`,
+                        `  mediaType: ${artifact.mediaType}`,
+                    ];
+                }),
+            ].join("\n")
+            : "";
         if (record.structuredArtifactPath &&
             record.structuredArtifactSchemaId ===
                 "frontend-implementation-contract-v1") {
@@ -130,8 +215,12 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
             ].join("\n"));
             continue;
         }
-        if (!upstreamText)
+        if (!upstreamText) {
+            if (consumedArtifactSection) {
+                sections.push(`## Upstream output: ${depId}\n${consumedArtifactSection}`);
+            }
             continue;
+        }
         const artifactKind = stdout ? "stdout" : "assistant";
         const artifactPath = stdout
             ? record.stdoutArtifactPath
@@ -147,7 +236,10 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
                 `- sha256: ${record.structuredArtifactSha256 ?? "unknown"}`,
             ].join("\n");
         }
-        if (truncated && artifactPath) {
+        if (consumedArtifactSection) {
+            section += `\n\n${consumedArtifactSection}`;
+        }
+        if (truncated && artifactPath && readSetAllowsArtifactPath(task, artifactPath)) {
             section += formatUpstreamArtifactPointerMap(record, artifactKind);
         }
         sections.push(section);
@@ -329,7 +421,7 @@ function formatProjectGovernanceContext(ctx) {
     return lines.join("\n");
 }
 export function buildDagNodePromptEnvelope(input) {
-    const { spec, task, upstream, resolvedSkills = [], resolvedSkillInstructions = [], maxUpstreamChars = MAX_UPSTREAM_CHARS, projectGovernanceContext, convergenceFeedback, } = input;
+    const { spec, task, upstream, runDir, resolvedSkills = [], resolvedSkillInstructions = [], maxUpstreamChars = MAX_UPSTREAM_CHARS, projectGovernanceContext, convergenceFeedback, } = input;
     const objective = spec.objective ?? spec.title;
     const successCriteria = formatBulletList(spec.successCriteria, "(none specified)");
     const globalConstraints = formatBulletList(spec.globalConstraints, "(none specified)");
@@ -339,7 +431,7 @@ export function buildDagNodePromptEnvelope(input) {
         ? resolvedSkills.map((skill) => `- ${skill}`).join("\n")
         : "(none)";
     const skillInstructionsSection = formatResolvedSkillInstructions(resolvedSkillInstructions);
-    const upstreamContext = buildUpstreamContext(task, upstream, maxUpstreamChars);
+    const upstreamContext = buildUpstreamContext(task, upstream, maxUpstreamChars, runDir);
     const readOnlyBoundary = buildReadOnlyBoundary(writePolicy);
     const sections = [
         `<dag_objective>\n${objective}\n</dag_objective>`,

package/dist/workflows/dag/recovery-lease.js

@@ -0,0 +1,170 @@
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { hostname as localHostname } from "node:os";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { DAG_RUNS_DIR } from "./lifecycle.js";
+function recoveryLeasePath(cwd, parentRunId) {
+    // Never derive a filesystem name directly from an externally supplied legacy
+    // run id. The content remains auditable while the filename is traversal-safe.
+    const key = createHash("sha256").update(parentRunId).digest("hex");
+    return path.join(cwd, DAG_RUNS_DIR, ".recovery-leases", `${key}.json`);
+}
+function parseLease(raw, parentRunId) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("invalid dag recovery lease: expected object");
+    }
+    const record = raw;
+    if (record.schemaVersion !== 1 ||
+        record.parentRunId !== parentRunId ||
+        typeof record.requestId !== "string" ||
+        record.requestId.length === 0 ||
+        (record.kind !== "auto-frontend-recovery" &&
+            record.kind !== "rerun-from-node" &&
+            record.kind !== "standalone-task-rerun") ||
+        typeof record.leaseToken !== "string" ||
+        record.leaseToken.length === 0 ||
+        typeof record.ownerPid !== "number" ||
+        !Number.isInteger(record.ownerPid) ||
+        record.ownerPid <= 0 ||
+        typeof record.ownerHostname !== "string" ||
+        record.ownerHostname.length === 0 ||
+        typeof record.acquiredAt !== "string" ||
+        typeof record.executionRef !== "undefined" &&
+            typeof record.executionRef !== "string") {
+        throw new Error("invalid dag recovery lease: schema mismatch");
+    }
+    return record;
+}
+const LEASE_MUTATION_LOCK_STALE_MS = 60_000;
+const LEASE_MUTATION_LOCK_RETRIES = 200;
+async function withLeaseMutationLock(leasePath, operation) {
+    const lockPath = `${leasePath}.mutation-lock`;
+    for (let attempt = 0; attempt < LEASE_MUTATION_LOCK_RETRIES; attempt += 1) {
+        try {
+            await mkdir(lockPath);
+        }
+        catch (error) {
+            if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) {
+                throw error;
+            }
+            try {
+                const lockStat = await stat(lockPath);
+                if (Date.now() - lockStat.mtimeMs >= LEASE_MUTATION_LOCK_STALE_MS) {
+                    await rm(lockPath, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            catch (statError) {
+                if (statError &&
+                    typeof statError === "object" &&
+                    "code" in statError &&
+                    statError.code === "ENOENT") {
+                    continue;
+                }
+                throw statError;
+            }
+            await delay(10);
+            continue;
+        }
+        try {
+            return await operation();
+        }
+        finally {
+            await rm(lockPath, { recursive: true, force: true });
+        }
+    }
+    throw new Error("dag recovery lease mutation lock is busy");
+}
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function leaseOwnerIsAlive(input) {
+    if (input.lease.ownerHostname !== input.hostname)
+        return true;
+    return input.isProcessAlive(input.lease.ownerPid);
+}
+export async function acquireDagRecoveryLease(input) {
+    const leasePath = recoveryLeasePath(input.cwd, input.parentRunId);
+    const lease = {
+        schemaVersion: 1,
+        parentRunId: input.parentRunId,
+        requestId: input.requestId,
+        kind: input.kind,
+        leaseToken: randomBytes(16).toString("hex"),
+        ownerPid: process.pid,
+        ownerHostname: localHostname(),
+        acquiredAt: (input.now ?? (() => new Date()))().toISOString(),
+    };
+    await mkdir(path.dirname(leasePath), { recursive: true });
+    try {
+        // `wx` is the cross-process compare-and-create primitive. The lease is
+        // parent-scoped for the full recovery lineage. Ownership may only be
+        // replaced by claimDagRecoveryLease after the recorded owner is proven dead.
+        await writeFile(leasePath, `${JSON.stringify(lease, null, 2)}\n`, {
+            encoding: "utf8",
+            flag: "wx",
+        });
+        return { kind: "acquired", leasePath, lease };
+    }
+    catch (error) {
+        if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST")) {
+            throw error;
+        }
+        const existing = parseLease(JSON.parse(await readFile(leasePath, "utf8")), input.parentRunId);
+        return { kind: "held", leasePath, lease: existing };
+    }
+}
+/**
+ * Reclaim a lease only after its recorded same-host owner is proven dead.
+ * The mutation lock serializes reclaim with execution binding, so a live owner
+ * can never race a stale-owner takeover and launch a second recovery.
+ */
+export async function claimDagRecoveryLease(input) {
+    const hostname = input.hostname ?? localHostname();
+    const isProcessAlive = input.isProcessAlive ?? defaultIsProcessAlive;
+    return withLeaseMutationLock(input.leasePath, async () => {
+        const existing = parseLease(JSON.parse(await readFile(input.leasePath, "utf8")), input.lease.parentRunId);
+        if (existing.leaseToken !== input.lease.leaseToken ||
+            leaseOwnerIsAlive({ lease: existing, hostname, isProcessAlive })) {
+            return { kind: "held", leasePath: input.leasePath, lease: existing };
+        }
+        const claimed = {
+            ...existing,
+            leaseToken: randomBytes(16).toString("hex"),
+            ownerPid: process.pid,
+            ownerHostname: hostname,
+            acquiredAt: (input.now ?? (() => new Date()))().toISOString(),
+        };
+        await writeJsonAtomic(input.leasePath, claimed);
+        return { kind: "acquired", leasePath: input.leasePath, lease: claimed };
+    });
+}
+/** Persist the operation/run identity before the caller is allowed to execute it. */
+export async function bindDagRecoveryLeaseExecution(input) {
+    if (!input.executionRef.trim()) {
+        throw new Error("dag recovery lease executionRef is required");
+    }
+    return withLeaseMutationLock(input.leasePath, async () => {
+        const existing = parseLease(JSON.parse(await readFile(input.leasePath, "utf8")), input.lease.parentRunId);
+        if (existing.leaseToken !== input.lease.leaseToken) {
+            throw new Error("dag recovery lease ownership drift");
+        }
+        if (existing.executionRef && existing.executionRef !== input.executionRef) {
+            throw new Error("dag recovery lease execution identity drift");
+        }
+        const bound = {
+            ...existing,
+            executionRef: input.executionRef,
+        };
+        await writeJsonAtomic(input.leasePath, bound);
+        return bound;
+    });
+}

package/dist/workflows/dag/report.js

@@ -125,6 +125,8 @@ const dagNodeArtifactsReportSchema = z
     humanEscalationMd: dagArtifactRefSchema,
     humanApproval: dagArtifactRefSchema,
     humanRejection: dagArtifactRefSchema,
+    changeManifest: dagArtifactRefSchema,
+    changeManifestChangedFiles: z.array(z.string()).optional(),
 })
     .strict();
 const dagNodeReportRowSchema = z
@@ -259,6 +261,20 @@ export async function probeArtifact(filePath) {
 export async function buildNodeArtifactsReport(runDir, nodeId) {
     const nodeDir = path.join(runDir, nodeId);
     const artifact = (name) => probeArtifact(path.join(nodeDir, name));
+    const changeManifestRef = await artifact("change-manifest.json");
+    let changeManifestChangedFiles;
+    if (changeManifestRef.exists) {
+        try {
+            const manifest = JSON.parse(await readFile(path.join(nodeDir, "change-manifest.json"), "utf-8"));
+            changeManifestChangedFiles = Array.isArray(manifest.changedFiles)
+                ? manifest.changedFiles
+                    .filter((item) => typeof item === "string")
+                : undefined;
+        }
+        catch {
+            // unreadable manifest → leave undefined
+        }
+    }
     return {
         resultSummary: await artifact("result.summary.md"),
         promptRedacted: await artifact("prompt.redacted.md"),
@@ -270,6 +286,8 @@ export async function buildNodeArtifactsReport(runDir, nodeId) {
         humanEscalationMd: await artifact("human-escalation.md"),
         humanApproval: await artifact("human-approval.json"),
         humanRejection: await artifact("human-rejection.json"),
+        changeManifest: changeManifestRef,
+        changeManifestChangedFiles,
     };
 }
 function taskById(spec) {
@@ -726,6 +744,12 @@ function formatArtifactFlags(artifacts) {
         flags.push("approval");
     if (artifacts.humanRejection.exists)
         flags.push("rejection");
+    if (artifacts.changeManifest.exists) {
+        const count = artifacts.changeManifestChangedFiles?.length;
+        flags.push(count !== undefined
+            ? `changed:${count}`
+            : "change-manifest");
+    }
     return flags.length > 0 ? flags.join(",") : "-";
 }
 function formatTimestamp(value) {
@@ -749,7 +773,19 @@ function summarizeNodeStatuses(nodes) {
     return `${total} total / ${finished} finished / ${failed} failed / ${skipped} skipped / ${pending} pending`;
 }
 function hasArtifact(artifacts) {
-    return Object.values(artifacts).some((artifact) => artifact.exists);
+    return [
+        artifacts.resultSummary,
+        artifacts.promptRedacted,
+        artifacts.skills,
+        artifacts.nodeRecord,
+        artifacts.decisionEnvelope,
+        artifacts.decisionEnvelopeValidation,
+        artifacts.humanEscalationJson,
+        artifacts.humanEscalationMd,
+        artifacts.humanApproval,
+        artifacts.humanRejection,
+        artifacts.changeManifest,
+    ].some((artifact) => artifact.exists);
 }
 function failureRows(run) {
     return run.nodes.filter((node) => node.status === "ERROR" ||