@tea-agent/loop-agent 0.26.5-beta.1 → 0.27.0

package/dist/task/contract/adopt.js

@@ -61,7 +61,7 @@ export async function adoptTaskContract(input) {
         }
         const state = await observeTaskContractState(input.repoRoot, input.taskId);
         if (state.effectiveStatus === "transaction-incomplete") {
-            throw new ContractMutationError("TRANSACTION_INCOMPLETE", "unfinished transaction; run task contract recover first");
+            throw new ContractMutationError("TRANSACTION_INCOMPLETE", "unfinished transaction; re-run task advance (auto recover-contract)");
         }
         const currentRevision = logicalRevisionForState(state);
         if (input.expectedRevision !== currentRevision) {

package/dist/task/contract/apply.js

@@ -180,7 +180,7 @@ export async function applyTaskContract(input) {
         }
         const state = await observeTaskContractState(input.repoRoot, input.taskId);
         if (state.effectiveStatus === "transaction-incomplete") {
-            throw new ContractMutationError("TRANSACTION_INCOMPLETE", "unfinished transaction; run task contract recover first", { errors: state.observationErrors });
+            throw new ContractMutationError("TRANSACTION_INCOMPLETE", "unfinished transaction; re-run task advance (auto recover-contract)", { errors: state.observationErrors });
         }
         const currentRevision = logicalRevisionForState(state);
         if (input.expectedRevision !== currentRevision) {

package/dist/task/contract/import-revision.js

@@ -17,7 +17,7 @@ export async function refreshManagedContractAfterImport(input) {
         return null;
     }
     if (state.effectiveStatus === "transaction-incomplete") {
-        throw new Error(`TRANSACTION_INCOMPLETE: cannot refresh contract after import-prd for ${input.taskId}; run task contract recover first`);
+        throw new Error(`TRANSACTION_INCOMPLETE: cannot refresh contract after import-prd for ${input.taskId}; re-run task advance (auto recover-contract)`);
     }
     const requestId = input.requestId ??
         `import-prd-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;

package/dist/task/contract/recover.js

@@ -27,10 +27,10 @@ export async function doctorTaskContract(input) {
     }
     const recommendations = [];
     if (state.effectiveStatus === "transaction-incomplete") {
-        recommendations.push("Run: loop-agent task contract recover --task <id> --json");
+        recommendations.push("Re-run: loop-agent task advance <id> --json");
     }
     if (state.effectiveStatus === "legacy-unversioned") {
-        recommendations.push("Run apply with expectedRevision=0 or: loop-agent task contract adopt --task <id> ...");
+        recommendations.push("Re-run: loop-agent task advance <id> --from-draft <draft.json> --json");
     }
     if (state.effectiveStatus === "externally-modified") {
         recommendations.push("Review out-of-band edits, then apply a new Draft or adopt current facts");

package/dist/task/read-model.js

@@ -1,7 +1,7 @@
 import { access } from "node:fs/promises";
 import path from "node:path";
 import { queryCursorRuns } from "../records/one-shot-runs.js";
-import { listAllDagRunEntries, readDagRunSpec, } from "../workflows/dag/lifecycle.js";
+import { listExplicitlyAssociatedRuns } from "../application/task-lifecycle/observe.js";
 import { getTaskDir, getTaskPaths, getTaskStatus } from "./runtime.js";
 async function exists(filePath) {
     try {
@@ -13,19 +13,14 @@ async function exists(filePath) {
     }
 }
 async function listRelatedDagRuns(repoRoot, taskId) {
-    const entries = await listAllDagRunEntries(repoRoot);
-    const related = [];
-    for (const entry of entries) {
-        if (entry.runId.includes(taskId)) {
-            related.push(entry);
-            continue;
-        }
-        const spec = await readDagRunSpec(entry.runDir).catch(() => null);
-        if (spec && JSON.stringify(spec).includes(taskId)) {
-            related.push(entry);
-        }
-    }
-    return related;
+    // Explicit association only (taskContractBinding / sourceBinding /
+    // workerAssociation / lifecycle.json). No taskId substring or JSON scan.
+    const related = await listExplicitlyAssociatedRuns(repoRoot, taskId);
+    return related.map((entry) => ({
+        runId: entry.runId,
+        lifecycle: entry.lifecycle,
+        runDir: entry.runDir,
+    }));
 }
 function closeoutPath(repoRoot, taskId) {
     return path.join(repoRoot, "docs", "progress", `${taskId}.md`);
@@ -33,42 +28,42 @@ function closeoutPath(repoRoot, taskId) {
 function deriveNextAction(input) {
     if (!input.sourceReady) {
         return {
-            command: `npm run dev -- instructions source --task ${input.taskId} --json`,
-            reason: "source materials are not ready",
+            command: `loop-agent task advance ${input.taskId} --prd <path> --allowed-path <glob> --json`,
+            reason: "source materials are not ready; advance from PRD + boundaries",
         };
     }
     if (!input.dagDraftExists && !input.latestDagRun) {
         return {
-            command: `npm run dev -- dag run-task ${input.taskId} --profile auto --strict-models`,
+            command: `loop-agent task advance ${input.taskId} --json`,
             reason: "source ready; DAG draft/run evidence not found",
         };
     }
     if (input.dagDraftExists && !input.latestDagRun) {
         return {
-            command: `npm run dev -- dag validate --dag ${input.dagDraftPath} --strict-models --strict-governance`,
-            reason: "DAG draft exists and needs validation/execution",
+            command: `loop-agent task advance ${input.taskId} --json`,
+            reason: "DAG draft exists; advance to writeSet gate or continue lifecycle",
         };
     }
     if (input.latestDagRun && input.latestDagRun.lifecycle !== "completed") {
         return {
-            command: `npm run dev -- dag status --run-id ${input.latestDagRun.runId}`,
+            command: `loop-agent task status ${input.taskId} --json`,
             reason: "DAG run exists but is not completed",
         };
     }
     if (input.latestDagRun && input.promotionRequired && !input.promotionReady) {
         return {
-            command: `npm run dev -- promote-run ${input.taskId} --run-id ${input.latestDagRun.runId}`,
+            command: `loop-agent task advance ${input.taskId} --json`,
             reason: "completed run evidence needs promotion into task artifacts",
         };
     }
     if (!input.closeoutExists) {
         return {
-            command: `npm run dev -- closeout task ${input.taskId}`,
+            command: `loop-agent task advance ${input.taskId} --json`,
             reason: "promoted task evidence needs closeout",
         };
     }
     return {
-        command: `npm run dev -- dag report --task ${input.taskId}`,
+        command: `loop-agent task status ${input.taskId} --json`,
         reason: "task has source, run evidence, promotion, and closeout records",
     };
 }

package/dist/task/runtime.js

@@ -299,7 +299,7 @@ export function getSupportedNextCommand(step, taskId, status, options) {
         return `npm run dev -- loop status ${taskId}`;
     }
     if (step === 'analyze' || step === 'plan' || step === 'spec' || step === 'implement' || step === 'verify' || step === 'retrospective') {
-        return `npm run dev -- dag run-task ${taskId} --profile auto --strict-models`;
+        return `npm run dev -- task advance ${taskId} --profile auto --json`;
     }
     return `${step} step not yet implemented in this prototype; human intervention required`;
 }

package/dist/task/source-prepare/completeness.js

@@ -31,7 +31,7 @@ export function observationBlocksPrepare(state) {
         return {
             code: "TRANSACTION_INCOMPLETE",
             level: "blocking",
-            message: "unfinished contract transaction; run task contract recover before prepare",
+            message: "unfinished contract transaction; re-run task advance (auto recover-contract) before prepare",
         };
     }
     const disallowed = state.observationErrors.filter((e) => !FRESH_SOURCE_MISSING_CODES.has(e.code));

package/dist/task/source-prepare/parse-intent.js

@@ -335,7 +335,12 @@ export function fillMissingRequirementFacts(base, supplemental) {
             ...base.sourceLabels,
             ...supplemental.sourceLabels,
         ]),
-        acceptanceConflicts: base.acceptanceConflicts ?? [],
+        acceptanceConflicts: [
+            ...(base.acceptanceConflicts ?? []),
+            ...(base.acceptanceCriteria.length === 0
+                ? (supplemental.acceptanceConflicts ?? [])
+                : []),
+        ],
     };
 }
 export function parseVerifyFlag(raw) {

package/dist/task/source-prepare/prepare.js

@@ -65,16 +65,16 @@ function buildNextSteps(input) {
         next.push(`loop-agent task source prepare ${input.taskId} --use-imported-prd ... --apply --json`);
     }
     if (input.ok && input.mode === "apply") {
-        next.push(`loop-agent task contract show ${input.taskId} --json`);
-        next.push(`loop-agent dag run-task ${input.taskId} --profile auto --strict-models`);
-        next.push("审查 DAG writeSet 后再 run-dag");
+        next.push(`loop-agent task status ${input.taskId} --json`);
+        next.push(`loop-agent task advance ${input.taskId} --profile auto --json`);
+        next.push("审查 DAG writeSet 后再 task advance --approve-gate ...");
     }
     if (input.gaps.some((g) => g.code === "DIRTY_SOURCE")) {
-        next.push("loop-agent task contract show|diff|adopt|recover");
+        next.push("loop-agent task status --json | task advance --from-draft ...");
         next.push("或显式 --force-overwrite-source 后重跑 prepare");
     }
     if (input.gaps.some((g) => g.code === "TRANSACTION_INCOMPLETE")) {
-        next.push(`loop-agent task contract recover --task ${input.taskId}`);
+        next.push(`loop-agent task advance ${input.taskId} --json`);
     }
     return next;
 }
@@ -321,10 +321,18 @@ export async function prepareTaskSource(input) {
         ok: !blocking,
         gaps,
     });
+    const blockingCodes = gaps
+        .filter((gap) => gap.level === "blocking")
+        .map((gap) => gap.code);
+    const transactionIncomplete = blockingCodes.includes("TRANSACTION_INCOMPLETE");
     if (input.mode !== "apply") {
         return {
             ok: !blocking,
-            outcome: blocking ? "invalid" : "succeeded",
+            outcome: blocking
+                ? transactionIncomplete
+                    ? "needs-reconcile"
+                    : "invalid"
+                : "succeeded",
             mode: "dry-run",
             taskId,
             taskKind: built.draft.taskKind,
@@ -339,13 +347,11 @@ export async function prepareTaskSource(input) {
             ...(blocking
                 ? {
                     error: {
-                        code: "INVALID_INPUT",
+                        code: transactionIncomplete
+                            ? "TRANSACTION_INCOMPLETE"
+                            : "INVALID_INPUT",
                         message: "task source draft has blocking gaps",
-                        details: {
-                            gaps: gaps
-                                .filter((g) => g.level === "blocking")
-                                .map((g) => g.code),
-                        },
+                        details: { gaps: blockingCodes },
                     },
                 }
                 : {}),
@@ -365,19 +371,16 @@ export async function prepareTaskSource(input) {
             gaps,
             risks,
             projected,
-            next: [`loop-agent task contract recover --task ${taskId}`],
+            next: [`loop-agent task advance ${taskId} --json`],
             contractStatus: state.effectiveStatus,
             warnings,
             error: {
                 code: "TRANSACTION_INCOMPLETE",
-                message: "unfinished transaction; run task contract recover first",
+                message: "unfinished transaction; re-run task advance (auto recover-contract)",
             },
         };
     }
     if (blocking) {
-        const blockingCodes = gaps
-            .filter((g) => g.level === "blocking")
-            .map((g) => g.code);
         const outcome = blockingCodes.includes("DIRTY_SOURCE")
             ? "blocked"
             : "invalid";
@@ -417,7 +420,7 @@ export async function prepareTaskSource(input) {
             gaps,
             risks,
             projected,
-            next: [`loop-agent task contract doctor --task ${taskId}`],
+            next: [`loop-agent task status ${taskId} --details --json`],
             error: {
                 code: "OBSERVED_HASH_CONFLICT",
                 message: "unable to determine expectedObservedHash",
@@ -477,8 +480,8 @@ export async function prepareTaskSource(input) {
                 risks,
                 projected,
                 next: [
-                    `loop-agent task contract show ${taskId} --json`,
-                    `loop-agent task contract doctor --task ${taskId}`,
+                    `loop-agent task status ${taskId} --json`,
+                    `loop-agent task status ${taskId} --details --json`,
                 ],
                 error: {
                     code: error.code,