@tea-agent/loop-agent 0.24.10 → 0.25.0

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## [Unreleased]
 
+## [0.25.0] - 2026-07-30
+
+### 重点更新
+
+- 新增确定性 Feature Packet 脚手架，支持后端、前端及含 API 前端模板，并具备原子批量写入与预检能力
+- 新增 Feature 交付编排命令，自动串联最终验证、交付与收口流程
+- 显著提升 DAG 执行稳定性，修复超时残留子进程、重复验证及耗时记录不完整等问题
+- 新增任务级 Maven 验证规划，自动定位并仅针对相关模块执行验证
+- 后端测试节点现可自动生成指标机器计算的自包含 L-5 可视化报告
+
+### 新增
+
+- 提供 agent-worker Feature Packet 脚手架，内置 backend-only、frontend-only 和 fe-with-api 模板，支持原子批量写入与 validate-feature 预检
+- 新增 agent-worker feature advance 命令，编排 verify-final、delivery 到 closeout 的完整交付路径
+- 新增 agent-worker feature doctor 命令，提供只读的交付就绪诊断（覆盖证据、Pool 状态与工作区改动）
+- Maven 验证现支持任务级范围规划，根据任务涉及的目录自动定位并验证正确的 POM 模块
+- 后端测试 DAG 节点 7 现可确定性生成美观的自包含 L-5 可视化报告，指标完全由机器计算
+
+### 改进
+
+- Feature Delivery 在省略特定参数时，默认使用 feature verify-final 写入的标准证据路径
+- TaskConfig 持久化入口在写入前执行 schema 校验，拒绝不符合规范的数据格式
+- Dogfood 前端测试服务器在检测到旧缓存导致接口数据异常时，现会自动强制重启恢复
+
+### 修复
+
+- 显著加固 DAG 执行可靠性，修复超时或中断后子进程残留问题，降低文件占用与测试干扰概率
+- 修复受监督流程可能重复执行完整验证的问题，避免高成本检查在不同阶段反复运行
+- 修复 DAG 被放弃或替换时，运行中节点实际耗时记录不完整的问题
+- 修复 Windows 环境下因提示内容过长导致 DAG 无法启动的问题，现安全采用受控临时文件传输
+- 修复前端实现 DAG 在未确认项目 Mock 能力时误报缺失 Mock 文件的问题
+- 修复结构化任务配置中数组类型校验不严格的问题
+
 ## [0.24.10] - 2026-07-29
 
 ### 修复
@@ -53,6 +86,8 @@
 
 ### 修复
 
+- 修复前端证据校验在 Windows 下通过长 `node -e` 命令执行时的终端转义崩溃：改为由 runtime 内部直接校验，兼容 CMD、Git Bash、PowerShell 与 Unix shell
+- 修复 `frontend-implement-pi` 因复用需求发现 skill 而长时间侦查后空实现：contract 现在强制 requirement outcome 与 interaction 行为语义，implement/repair 改用不含递归 OpenSpec/AI workspace 搜索的 bounded skill，并由 `implementation-outcome-v1` 机器校验声明结果与实际 diff；只有显式 already-satisfied 才允许空 diff
 - Outcome 投影强制写出 repo-relative artifact 路径
 - Delivery `verifyArtifactRefs` 接受位于仓库内的绝对路径（兼容旧 envelope）
 - `verifyBundleTaskSpecBindings` 接受 `qa-testcode`（backend-test）与 `qa-execute`（frontend-test）

package/dist/executors/dag-pi-executor.js

@@ -130,17 +130,23 @@ export function buildDagPiUserMessage(task, persona, step) {
     const role = task.role ?? "unspecified";
     const writePolicy = task.writePolicy ?? "read-only (default)";
     if (isDagPiWriteTask(task)) {
+        const outcomeInstruction = task.writerOutcomePolicy
+            ? "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked. Use changed only after producing a non-empty bounded diff; use already-satisfied only when the contract is already met and no file changed; use blocked when implementation cannot proceed."
+            : undefined;
         return [
             `You are executing hybrid DAG node "${task.id}" (role=${role}, piStep=${step}, writePolicy=${writePolicy}).`,
             "The system prompt contains the full DAG envelope: objective, constraints, upstream context, and task.",
             "Use write tools only for the bounded implementation requested by this node.",
+            outcomeInstruction,
             `Allowed paths: ${(task.allowedPaths ?? []).join(", ") || "(none declared)"}.`,
             `Write set: ${(task.writeSet ?? []).join(", ") || "(none declared)"}.`,
             `Forbidden paths: ${(task.forbiddenPaths ?? []).join(", ") || "(none declared)"}.`,
             "Preserve unrelated files. Do not edit outside allowedPaths/writeSet. Never write forbiddenPaths, .harness/dag-runs/**, or undeclared root artifacts/**.",
             "Return concise Markdown with changed files, verification performed or still required, and residual risks.",
             "Do not wrap the output in code fences and do not add conversational preamble.",
-        ].join(" ");
+        ]
+            .filter((value) => Boolean(value))
+            .join(" ");
     }
     // Decision Gate nodes must emit a mandatory DECISION_ENVELOPE_JSON fenced block;
     // do not inject the global no-fence instruction that would conflict with outputContract.
@@ -344,21 +350,39 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
             ];
         }
     }
-    if (writeGuardOk) {
-        if (beforeStatus !== undefined && changeManifestChangedFiles !== undefined) {
-            await persistWriterChangeManifest({
-                runDir: meta.runDir,
-                nodeId: input.task.id,
-                writerNodeId: input.task.id,
-                changedFiles: changeManifestChangedFiles,
-                beforeStatus,
-                afterStatus: changeManifestAfterStatus ?? "",
-            });
+    let writerOutcomeViolation;
+    if (mapped.ok && input.task.writerOutcomePolicy) {
+        if (changeManifestChangedFiles === undefined) {
+            writerOutcomeViolation =
+                "writer outcome validation failed: actual diff is unavailable";
+        }
+        else {
+            const outcomeValidation = validateWriterImplementationOutcome(mapped.assistantText || mapped.stdout, changeManifestChangedFiles);
+            if (!outcomeValidation.ok) {
+                writerOutcomeViolation = outcomeValidation.reason;
+            }
         }
+    }
+    if (writeGuardOk && beforeStatus !== undefined && changeManifestChangedFiles !== undefined) {
+        await persistWriterChangeManifest({
+            runDir: meta.runDir,
+            nodeId: input.task.id,
+            writerNodeId: input.task.id,
+            changedFiles: changeManifestChangedFiles,
+            beforeStatus,
+            afterStatus: changeManifestAfterStatus ?? "",
+        });
+    }
+    if (writeGuardOk && !writerOutcomeViolation) {
         return mapped;
     }
     const stderrParts = [mapped.stderr];
-    stderrParts.push(`write guard failed: ${writeGuardViolations.join(", ")}`);
+    if (!writeGuardOk) {
+        stderrParts.push(`write guard failed: ${writeGuardViolations.join(", ")}`);
+    }
+    if (writerOutcomeViolation) {
+        stderrParts.push(writerOutcomeViolation);
+    }
     if (meta.writeGuardAttribution === "best-effort") {
         stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
     }
@@ -366,10 +390,47 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         ...mapped,
         ok: false,
         stderr: stderrParts.filter(Boolean).join("\n\n"),
-        failureCategory: mapped.ok ? "write-guard" : mapped.failureCategory,
+        failureCategory: mapped.ok
+            ? writeGuardOk
+                ? "invalid-output"
+                : "write-guard"
+            : mapped.failureCategory,
         durationMs: mapped.durationMs || Date.now() - started,
     };
 }
+export function validateWriterImplementationOutcome(text, changedFiles) {
+    const firstLine = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+    const match = firstLine?.match(/^IMPLEMENTATION_OUTCOME: (changed|already-satisfied|blocked)$/);
+    if (!match) {
+        return {
+            ok: false,
+            reason: "writer outcome validation failed: missing or invalid first line; expected IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked",
+        };
+    }
+    const outcome = match[1];
+    if (outcome === "blocked") {
+        return {
+            ok: false,
+            reason: "writer outcome validation failed: IMPLEMENTATION_OUTCOME: blocked cannot complete successfully",
+        };
+    }
+    if (outcome === "changed" && changedFiles.length === 0) {
+        return {
+            ok: false,
+            reason: "writer outcome validation failed: changed outcome has an empty diff",
+        };
+    }
+    if (outcome === "already-satisfied" && changedFiles.length > 0) {
+        return {
+            ok: false,
+            reason: "writer outcome validation failed: already-satisfied outcome has a non-empty diff",
+        };
+    }
+    return { ok: true, outcome };
+}
 export function mapPiResultToDagNodeResult(result, firstProtocolLine) {
     const assistantText = canonicalizeProtocolFirstLine(result.assistantText, firstProtocolLine);
     return {

package/dist/executors/pi-executor.js

@@ -3,6 +3,8 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { PI_REUSE_RUNTIME_ENV, isPiReuseRuntimeEffective, resolvePiReuseRuntimeMode as resolveConfiguredPiReuseRuntimeMode, } from './pi-runtime-reuse.js';
+import { cleanupPiPromptTransport, createPiPromptTransport, } from './pi-prompt-transport.js';
+import { processTreeSpawnOptions, terminateProcessTree } from './process-tree.js';
 export function extractSubagentStats(stdout) {
     let totalCalls = 0;
     let failedCalls = 0;
@@ -507,12 +509,24 @@ function withCliBackend(result) {
 }
 /** CLI-only orchestration: primary attempt + optional fallback model retry. */
 async function runCliOrchestration(options, meta) {
+    const promptTransport = createPiPromptTransport(options.prompt);
+    try {
+        return await runCliOrchestrationWithPromptFile(options, promptTransport.filePath, meta);
+    }
+    finally {
+        const cleanup = cleanupPiPromptTransport(promptTransport);
+        for (const warning of cleanup.warnings) {
+            process.stderr.write(`${warning}\n`);
+        }
+    }
+}
+async function runCliOrchestrationWithPromptFile(options, promptFilePath, meta) {
     const primary = options.modelConfig ?? {};
     const attemptedModels = [];
     if (meta?.prependAttemptedModel) {
         attemptedModels.push(meta.prependAttemptedModel);
     }
-    const primaryResult = await executeSingleCliAttempt(options, primary);
+    const primaryResult = await executeSingleCliAttempt(options, primary, promptFilePath);
     attemptedModels.push(primaryResult.modelDisplay);
     let primaryIssues = [];
     if (primaryResult.ok && options.validateOutput) {
@@ -525,7 +539,7 @@ async function runCliOrchestration(options, meta) {
         && shouldRetryWithFallback(primaryResult.stderr, primaryResult.stdout))
         || primaryInvalidOutput);
     if (shouldFallback) {
-        const fallbackResult = await executeSingleCliAttempt(options, primary.fallback);
+        const fallbackResult = await executeSingleCliAttempt(options, primary.fallback, promptFilePath);
         attemptedModels.push(fallbackResult.modelDisplay);
         const combinedStderr = [primaryResult.stderr, fallbackResult.stderr].filter(Boolean).join('\n--- fallback ---\n');
         const combinedStdout = [primaryResult.stdout, fallbackResult.stdout].filter(Boolean).join('\n--- fallback ---\n');
@@ -659,7 +673,7 @@ export async function executePiStep(options) {
     });
     return { ...cliResult, reuseRuntimeActive };
 }
-async function executeSingleCliAttempt(options, modelConfig) {
+async function executeSingleCliAttempt(options, modelConfig, promptFilePath) {
     const modelDisplay = modelConfig.provider && modelConfig.model
         ? `${modelConfig.provider}/${modelConfig.model}`
         : modelConfig.model ?? 'default';
@@ -687,13 +701,17 @@ async function executeSingleCliAttempt(options, modelConfig) {
         piArgs.push('--thinking', modelConfig.thinking);
     }
     piArgs.push('--tools', options.toolNames.join(','));
-    piArgs.push('--append-system-prompt', options.prompt);
+    piArgs.push('--append-system-prompt', promptFilePath);
     piArgs.push(...options.attachedFiles.map((file) => `@${file}`));
     piArgs.push(options.userMessage);
+    const recordedPiArgs = piArgs.map((arg, index) => index > 0 && piArgs[index - 1] === '--append-system-prompt'
+        ? '<system-prompt-file>'
+        : arg);
     const startedAt = Date.now();
     return await new Promise((resolve, reject) => {
         const child = spawn(process.execPath, [getPiCliPath(), ...piArgs], {
             cwd: options.repoRoot,
+            ...processTreeSpawnOptions(),
             env: {
                 ...process.env,
                 // Explicitly propagate API keys that pi needs to recognise providers.
@@ -748,7 +766,7 @@ async function executeSingleCliAttempt(options, modelConfig) {
                 });
             resolve({
                 assistantText: collected.assistantText,
-                command: ['pi', ...piArgs],
+                command: ['pi', ...recordedPiArgs],
                 durationMs,
                 exitCode: code,
                 failureCategory,
@@ -771,7 +789,7 @@ async function executeSingleCliAttempt(options, modelConfig) {
                 return;
             timedOut = true;
             supervisionStderr = reason;
-            child.kill('SIGTERM');
+            terminateProcessTree(child, 'SIGTERM');
             sigkillHandle = setTimeout(() => {
                 if (settled)
                     return;
@@ -779,7 +797,7 @@ async function executeSingleCliAttempt(options, modelConfig) {
                     finish(child.exitCode);
                     return;
                 }
-                child.kill('SIGKILL');
+                terminateProcessTree(child, 'SIGKILL');
                 exitConfirmationHandle = setTimeout(() => {
                     if (settled)
                         return;

package/dist/executors/pi-prompt-transport.js

@@ -0,0 +1,198 @@
+import { closeSync, fstatSync, fsyncSync, ftruncateSync, lstatSync, mkdtempSync, openSync, realpathSync, rmdirSync, unlinkSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+const PROMPT_DIRECTORY_PREFIX = "loop-agent-pi-prompt-";
+const PROMPT_FILE_NAME = "system-prompt.md";
+function identityOf(stats) {
+    return { dev: stats.dev, ino: stats.ino };
+}
+function hasIdentity(stats, identity) {
+    return stats.dev === identity.dev && stats.ino === identity.ino;
+}
+function normalizedPath(value) {
+    const resolved = path.resolve(value);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function assertOwnedPromptPaths(transport) {
+    const tempRoot = normalizedPath(transport.tempRoot);
+    const directoryPath = normalizedPath(transport.directoryPath);
+    const filePath = normalizedPath(transport.filePath);
+    const tempRootStats = lstatSync(transport.tempRoot, { bigint: true });
+    if (!tempRootStats.isDirectory() ||
+        tempRootStats.isSymbolicLink() ||
+        !hasIdentity(tempRootStats, transport.tempRootIdentity)) {
+        throw new Error("Pi prompt cleanup refused: temporary root identity changed");
+    }
+    if (normalizedPath(path.dirname(transport.directoryPath)) !== tempRoot) {
+        throw new Error("Pi prompt cleanup refused: temporary directory escaped its recorded root");
+    }
+    if (!path.basename(directoryPath).startsWith(PROMPT_DIRECTORY_PREFIX)) {
+        throw new Error("Pi prompt cleanup refused: unexpected temporary directory name");
+    }
+    if (normalizedPath(path.dirname(transport.filePath)) !== directoryPath) {
+        throw new Error("Pi prompt cleanup refused: prompt file escaped its recorded directory");
+    }
+    if (path.basename(filePath) !== PROMPT_FILE_NAME) {
+        throw new Error("Pi prompt cleanup refused: unexpected prompt file name");
+    }
+}
+export function createPiPromptTransport(prompt) {
+    const tempRoot = realpathSync.native(tmpdir());
+    const tempRootStats = lstatSync(tempRoot, { bigint: true });
+    if (!tempRootStats.isDirectory() || tempRootStats.isSymbolicLink()) {
+        throw new Error("Pi prompt transport requires a real temporary directory");
+    }
+    const tempRootIdentity = identityOf(tempRootStats);
+    const directoryPath = mkdtempSync(path.join(tempRoot, PROMPT_DIRECTORY_PREFIX));
+    const currentTempRootStats = lstatSync(tempRoot, { bigint: true });
+    if (!hasIdentity(currentTempRootStats, tempRootIdentity)) {
+        throw new Error("Pi prompt transport temporary root changed during creation");
+    }
+    const directoryStats = lstatSync(directoryPath, { bigint: true });
+    if (!directoryStats.isDirectory() || directoryStats.isSymbolicLink()) {
+        throw new Error("Pi prompt transport did not create a private directory");
+    }
+    const filePath = path.join(directoryPath, PROMPT_FILE_NAME);
+    let fileDescriptor;
+    let fileIdentity;
+    try {
+        fileDescriptor = openSync(filePath, "wx", 0o600);
+        fileIdentity = identityOf(fstatSync(fileDescriptor, { bigint: true }));
+        writeFileSync(fileDescriptor, prompt, { encoding: "utf-8" });
+        fsyncSync(fileDescriptor);
+        return {
+            directoryPath,
+            filePath,
+            fileDescriptor,
+            tempRoot,
+            tempRootIdentity,
+            directoryIdentity: identityOf(directoryStats),
+            fileIdentity,
+        };
+    }
+    catch (error) {
+        if (fileDescriptor !== undefined && fileIdentity !== undefined) {
+            try {
+                cleanupPiPromptTransport({
+                    directoryPath,
+                    filePath,
+                    fileDescriptor,
+                    tempRoot,
+                    tempRootIdentity,
+                    directoryIdentity: identityOf(directoryStats),
+                    fileIdentity,
+                });
+            }
+            catch {
+                // Creation failed; the original error remains authoritative.
+            }
+        }
+        else {
+            try {
+                if (fileDescriptor !== undefined)
+                    closeSync(fileDescriptor);
+            }
+            catch {
+                // Best effort before rethrowing the creation error.
+            }
+            try {
+                const currentDirectory = lstatSync(directoryPath, { bigint: true });
+                if (hasIdentity(currentDirectory, identityOf(directoryStats))) {
+                    rmdirSync(directoryPath);
+                }
+            }
+            catch {
+                // Never recursively remove a transport directory.
+            }
+        }
+        throw error;
+    }
+}
+/**
+ * Clear and remove only the exact prompt file created by this transport.
+ * The directory is removed only when it is still the same empty directory.
+ */
+export function cleanupPiPromptTransport(transport) {
+    const warnings = [];
+    let contentCleared = false;
+    let fileRemoved = false;
+    let directoryRemoved = false;
+    let truncateError;
+    try {
+        ftruncateSync(transport.fileDescriptor, 0);
+        fsyncSync(transport.fileDescriptor);
+        contentCleared = true;
+    }
+    catch (error) {
+        truncateError = error;
+    }
+    finally {
+        try {
+            closeSync(transport.fileDescriptor);
+        }
+        catch {
+            // A closed descriptor is acceptable; identity checks still guard deletion.
+        }
+    }
+    let pathsOwned = false;
+    try {
+        assertOwnedPromptPaths(transport);
+        const directoryStats = lstatSync(transport.directoryPath, { bigint: true });
+        const fileStats = lstatSync(transport.filePath, { bigint: true });
+        pathsOwned =
+            directoryStats.isDirectory() &&
+                !directoryStats.isSymbolicLink() &&
+                hasIdentity(directoryStats, transport.directoryIdentity) &&
+                fileStats.isFile() &&
+                !fileStats.isSymbolicLink() &&
+                hasIdentity(fileStats, transport.fileIdentity);
+        if (!pathsOwned) {
+            warnings.push("Pi prompt cleanup refused deletion because path identity changed");
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            fileRemoved = true;
+        }
+        else {
+            warnings.push(`Pi prompt cleanup could not verify the exact prompt path: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (pathsOwned) {
+        try {
+            unlinkSync(transport.filePath);
+            fileRemoved = true;
+        }
+        catch (error) {
+            warnings.push(`Pi prompt cleanup could not unlink the exact prompt file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (!contentCleared && !fileRemoved) {
+        throw new Error(`Pi prompt cleanup could not prove prompt removal: ${truncateError instanceof Error ? truncateError.message : String(truncateError ?? "unknown truncate failure")}`);
+    }
+    if (fileRemoved) {
+        try {
+            const directoryStats = lstatSync(transport.directoryPath, { bigint: true });
+            if (directoryStats.isDirectory() &&
+                !directoryStats.isSymbolicLink() &&
+                hasIdentity(directoryStats, transport.directoryIdentity)) {
+                rmdirSync(transport.directoryPath);
+                directoryRemoved = true;
+            }
+            else {
+                warnings.push("Pi prompt cleanup refused directory removal because identity changed");
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT") {
+                directoryRemoved = true;
+            }
+            else {
+                warnings.push(`Pi prompt cleanup left an empty or non-empty transport directory: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    return { contentCleared, fileRemoved, directoryRemoved, warnings };
+}

package/dist/executors/pi-sdk-executor.js

@@ -296,7 +296,7 @@ export async function executeSingleSdkAttempt(options) {
         '--model', modelConfig.model ?? '(default)',
         ...(modelConfig.thinking ? ['--thinking', modelConfig.thinking] : []),
         '--tools', options.toolNames.join(','),
-        '--append-system-prompt', options.prompt,
+        '--append-system-prompt', '<in-memory-system-prompt>',
         ...options.attachedFiles.map((file) => `@${file}`),
         options.userMessage,
     ];

package/dist/executors/process-tree.js

@@ -0,0 +1,33 @@
+import { spawnSync } from "node:child_process";
+/** Terminate a command and all descendants that it started. */
+export function terminateProcessTree(child, signal, dependencies = {}) {
+    if (child.exitCode !== null && child.exitCode !== undefined)
+        return true;
+    const pid = child.pid;
+    if (!pid)
+        return child.kill(signal);
+    const platform = dependencies.platform ?? process.platform;
+    if (platform === "win32") {
+        const runTaskkill = dependencies.runTaskkill ?? ((targetPid) => {
+            const result = spawnSync("taskkill.exe", ["/pid", String(targetPid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
+            return !result.error && result.status === 0;
+        });
+        return runTaskkill(pid) || child.kill(signal);
+    }
+    try {
+        const killProcessGroup = dependencies.killProcessGroup ?? ((targetPid, targetSignal) => {
+            process.kill(-targetPid, targetSignal);
+        });
+        killProcessGroup(pid, signal);
+        return true;
+    }
+    catch {
+        return child.kill(signal);
+    }
+}
+export function processTreeSpawnOptions() {
+    return {
+        detached: process.platform !== "win32",
+        windowsHide: true,
+    };
+}