@tea-agent/loop-agent 0.41.0-next.3 → 0.41.1-beta.0

package/dist/commands/client-recovery.js

@@ -1328,12 +1328,15 @@ export async function runClientRecovery(input) {
     }
     const plugin = await installProjectOpenCodePlugin({
         repoRoot: input.repoRoot,
+        onlyIfMissing: true,
     });
     const overflowPlugin = await installProjectOpenCodeOverflowCompactPlugin({
         repoRoot: input.repoRoot,
+        onlyIfMissing: true,
     });
     const piExtension = await installProjectPiContextOverflowExtension({
         repoRoot: input.repoRoot,
+        onlyIfMissing: true,
     });
     const pi = await applyProjectPiSettingsMerge({ repoRoot: input.repoRoot });
     if (mode !== "user") {

package/dist/commands/dag-follow-up.js

@@ -0,0 +1,138 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { FRONTEND_REVIEW_FINDINGS_PRD_REL, readFrontendReviewFindingsPrd, } from "../workflows/dag/frontend-review-findings.js";
+import { locateDagRun } from "../workflows/dag/lifecycle.js";
+import { createTask, getTaskPaths } from "../task/runtime.js";
+import { importPrdDocument } from "../task/source-references.js";
+function parseFlagValue(rawArgs, flag) {
+    const index = rawArgs.indexOf(flag);
+    if (index < 0 || index + 1 >= rawArgs.length)
+        return undefined;
+    return rawArgs[index + 1];
+}
+export function parseDagFollowUpArgs(rawArgs) {
+    const positional = rawArgs.filter((arg) => !arg.startsWith("-"));
+    const parentRunId = positional[0];
+    if (!parentRunId) {
+        throw new Error("usage: dag follow-up <parent-run-id> [--task-id <id>] [--execute] [--profile <profile>]");
+    }
+    return {
+        parentRunId,
+        taskId: parseFlagValue(rawArgs, "--task-id"),
+        execute: rawArgs.includes("--execute"),
+        profile: parseFlagValue(rawArgs, "--profile"),
+    };
+}
+export function deriveFollowUpTaskId(parentRunId) {
+    // Deterministic, valid task id derived from the parent run id.
+    return `${parentRunId}-followup`;
+}
+/** CLI entry: parse raw args and run the follow-up flow. */
+export async function runDagFollowUp(repoRoot, rawArgs) {
+    const parsed = parseDagFollowUpArgs(rawArgs);
+    const result = await runDagFollowUpInternal(repoRoot, parsed.parentRunId, {
+        taskId: parsed.taskId,
+        execute: parsed.execute,
+        profile: parsed.profile,
+    });
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.ok) {
+        process.exitCode = result.mode === "blocked" ? 2 : 1;
+    }
+}
+export async function runDagFollowUpInternal(repoRoot, parentRunId, options = {}) {
+    const located = await locateDagRun(repoRoot, parentRunId);
+    if (!located) {
+        return {
+            ok: false,
+            mode: "invalid",
+            reason: `dag run not found: ${parentRunId}`,
+        };
+    }
+    const prd = await readFrontendReviewFindingsPrd(located.runDir);
+    if (!prd) {
+        return {
+            ok: false,
+            mode: "invalid",
+            reason: `no frontend review findings PRD found in run ${parentRunId} (${FRONTEND_REVIEW_FINDINGS_PRD_REL}); the review must have committed request_review_changes`,
+        };
+    }
+    const taskId = options.taskId ?? deriveFollowUpTaskId(parentRunId);
+    try {
+        await createTask(repoRoot, taskId, `修复 review 发现（parent ${parentRunId}）`);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            mode: "blocked",
+            reason: `failed to create task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    // Materialize the PRD draft into the task's source directory so the task
+    // lifecycle can import it as its requirement.
+    const prdMaterialized = path.join(getTaskPaths(repoRoot, taskId).sourceDir, "review-findings-prd.md");
+    try {
+        await mkdir(path.dirname(prdMaterialized), { recursive: true });
+        await importPrdDocument({
+            repoRoot,
+            taskId,
+            filePath: path.join(located.runDir, FRONTEND_REVIEW_FINDINGS_PRD_REL),
+            name: "review-findings-prd",
+        });
+    }
+    catch (error) {
+        return {
+            ok: false,
+            mode: "blocked",
+            reason: `failed to import PRD into task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    if (!options.execute) {
+        return {
+            ok: true,
+            mode: "created",
+            taskId,
+            prdPath: prdMaterialized,
+            next: {
+                kind: "advance",
+                command: `loop-agent task advance ${taskId} --task-kind frontend-implementation --json`,
+            },
+        };
+    }
+    // Execute: advance through the frontend DAG.
+    const { advanceTaskLifecycle } = await import("../application/task-lifecycle/advance.js");
+    const profile = options.profile === "auto" ||
+        options.profile === "minimal" ||
+        options.profile === "standard" ||
+        options.profile === "reviewed" ||
+        options.profile === "supervised"
+        ? options.profile
+        : undefined;
+    const result = await advanceTaskLifecycle({
+        repoRoot,
+        taskId,
+        taskKind: "frontend-implementation",
+        taskKindExplicit: true,
+        ...(profile ? { profile, profileExplicit: true } : {}),
+        observer: undefined,
+    });
+    const ok = result.lifecycleState === "run-succeeded" ||
+        result.lifecycleState === "awaiting-write-set-approval";
+    return {
+        ok,
+        mode: ok ? "created" : "blocked",
+        taskId,
+        prdPath: prdMaterialized,
+        reason: ok
+            ? undefined
+            : `advance lifecycleState: ${result.lifecycleState}${result.blockers.length > 0
+                ? `; blockers: ${result.blockers.map((b) => b.code).join(", ")}`
+                : ""}`,
+        next: ok
+            ? undefined
+            : {
+                kind: "advance",
+                command: `loop-agent task advance ${taskId} --task-kind frontend-implementation --json`,
+            },
+    };
+}

package/dist/commands/init.js

@@ -14,6 +14,19 @@ const GITIGNORE_BLOCK_START = "# LOOP_AGENT_INIT_START";
 const GITIGNORE_BLOCK_END = "# LOOP_AGENT_INIT_END";
 const INIT_SURFACE_STATE_PATH = ".harness/init-surface.json";
 const DEFAULT_GOVERNANCE_ROOT = "ai_workspace/loop-agent";
+function buildSpecRegistry() {
+    return `${JSON.stringify({
+        version: 1,
+        roots: [],
+        discovery: {
+            enabled: true,
+            maxDepth: 3,
+            maxFiles: 100,
+            maxBytes: 1048576,
+            timeoutMs: 2000,
+        },
+    }, null, 2)}\n`;
+}
 const CORE_DOC_FILES = [
     { source: "README.md", target: "README.md" },
     {
@@ -610,7 +623,7 @@ if (
   (assessment.status === "passed" && assessment.currentExitCode !== 0) ||
   (assessment.status === "baseline-debt" && assessment.currentExitCode === 0)
 ) fail();
-if (!assessment.baselineRef || assessment.baselineRef.nodeId !== "frontend-lint-baseline-shell") fail();
+if (!assessment.baselineRef || assessment.baselineRef.nodeId !== "frontend-writer-admission-shell") fail();
 const baselineRaw = readContained(assessment.baselineRef.path);
 if (sha256(baselineRaw) !== assessment.baselineRef.sha256) fail();
 let baseline;
@@ -1312,6 +1325,9 @@ async function buildDesiredSurfaceContent(input) {
             }), null, 2)}\n`,
         };
     }
+    if (manifestPath === "docs/spec-registry.json") {
+        return { content: buildSpecRegistry() };
+    }
     if (manifestPath === OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH) {
         return { content: buildOpenCodeTransientRetryPluginSource() };
     }
@@ -1709,6 +1725,8 @@ async function listRelativeFiles(rootPath) {
 async function expectedLegacyInitFileSha(input) {
     if (input.legacyPath.startsWith("docs/")) {
         const doc = input.legacyPath.slice("docs/".length);
+        if (doc === "spec-registry.json")
+            return sha256Text(buildSpecRegistry());
         const generated = buildGeneratedCoreDoc({
             doc,
             projectName: input.projectName,
@@ -2707,6 +2725,14 @@ export async function initializeLoopAgentProject(options) {
         targetRelativePath: path.join(governanceRoot, "templates"),
         written,
     });
+    await writeTextIfMissing({
+        repoRoot,
+        relativePath: path.join(governanceRoot, "spec-registry.json"),
+        content: buildSpecRegistry(),
+        merge,
+        written,
+        skipped,
+    });
     if (profile === "full") {
         // Project repo-local skills live only under `.agents/skills/`.
         // The package still ships `skills/` as the built-in fallback source.

package/dist/commands/task-advance.js

@@ -377,6 +377,25 @@ export async function runTaskAdvance(repoRoot, args) {
                 intervalMs: options.progressIntervalMs,
             });
         }
+        // Idempotent client-recovery surface install before any DAG run: the Pi
+        // context-overflow extension / OpenCode plugins / project .pi settings
+        // are normally installed by `loop-agent init`, but an upgraded or
+        // non-init-created project may lack them. Installing here (missing-only)
+        // ensures the overflow compact+retry recovery path is always present,
+        // independent of how the project was created. Best-effort: a failure to
+        // install never blocks the run.
+        if (options.approveGate && !options.dryRun) {
+            try {
+                const { runClientRecovery } = await import("./client-recovery.js");
+                // mode "project" installs only project-owned surfaces
+                // (.pi/extensions + .opencode/plugins + .pi/settings.json),
+                // never the user home; installs are missing-only.
+                await runClientRecovery({ repoRoot, mode: "project" });
+            }
+            catch {
+                // best-effort; do not fail the run over a recovery-surface install
+            }
+        }
         const result = await advanceTaskLifecycle(toUseCaseInput(repoRoot, taskId, options, progress?.observer));
         const outcome = mapOutcome(result);
         const gateStop = result.lifecycleState === "awaiting-write-set-approval" &&