@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.3

package/dist/commands/status.js

@@ -0,0 +1,57 @@
+import { getTaskDir, getTaskPaths, getTaskStatus, loadTaskConfig, } from "../task/runtime.js";
+import { getArtifactPath } from "../shared/artifacts-core.js";
+import { buildTaskReadModel } from "../task/read-model.js";
+export async function runStatus(repoRoot, taskId) {
+    // Read-only: do not refresh/repair/migrate. Mutations belong to task advance.
+    const state = await getTaskStatus(repoRoot, taskId);
+    const taskConfig = await loadTaskConfig(repoRoot, taskId);
+    const taskDir = getTaskDir(repoRoot, taskId);
+    const taskPaths = getTaskPaths(repoRoot, taskId);
+    const readModel = await buildTaskReadModel(repoRoot, taskId);
+    console.log(JSON.stringify({
+        taskId,
+        taskDir,
+        taskRoot: taskDir,
+        sourceOfTruth: "task",
+        artifactPaths: {
+            taskConfig: taskPaths.taskConfigPath,
+            workflowState: taskPaths.statePath,
+            sourceDir: taskPaths.sourceDir,
+            artifactsDir: `${taskDir}/artifacts`,
+            analysis: getArtifactPath(taskDir, "analyze"),
+            plan: getArtifactPath(taskDir, "plan"),
+            modifyLog: getArtifactPath(taskDir, "implement"),
+            verifyResult: getArtifactPath(taskDir, "verify"),
+            retrospective: getArtifactPath(taskDir, "retrospective"),
+        },
+        runRefs: {
+            oneShotRuns: readModel.runRefs.oneShotRuns,
+            dagRuns: readModel.runRefs.dagRuns,
+        },
+        readModel,
+        actionContext: {
+            mode: "dag",
+            allowedEditRoots: taskConfig.allowedPaths,
+            forbiddenPaths: taskConfig.forbiddenPaths,
+            constraints: taskConfig.hardConstraints,
+            requiresPromotion: readModel.promotion.required && !readModel.promotion.ready,
+        },
+        currentStep: state.currentStep,
+        status: state.status,
+        complexity: taskConfig.complexity,
+        maxFixLoops: taskConfig.maxFixLoops,
+        verifyEnv: taskConfig.verifyEnv ?? "clean",
+        maxGoalContinuationsPerRun: taskConfig.maxGoalContinuationsPerRun ?? 5,
+        goal: state.goal,
+        sourceState: state.sourceState,
+        completedSteps: state.completedSteps,
+        decisionLogSize: state.decisionLog.length,
+        artifacts: state.artifacts,
+        // Prefer task advance/status; keep single next action (no parallel command arrays).
+        next: {
+            kind: "advance-or-status",
+            command: readModel.nextAction.command,
+            reason: readModel.nextAction.reason,
+        },
+    }, null, 2));
+}

package/dist/commands/task-contract.js

@@ -0,0 +1,269 @@
+import { ContractMutationError, adoptTaskContract, applyTaskContract, diffTaskContract, doctorTaskContract, loadDraftFromPath, observeTaskContractState, recoverTaskContract, validateDraftForTask, } from "../task/contract/index.js";
+import { operatorFailed, operatorSucceeded, processExitCodeForOutcome, writeOperatorJson, } from "../shared/operator/index.js";
+const USAGE = `usage:
+  task contract validate --task <id> --input <path> [--json]
+  task contract diff --task <id> --input <path> [--json]
+
+Advanced-only public leaves. Managed apply/show/adopt/doctor/recover are internal services
+reached via task advance / task status (or application APIs), not public CLI subcommands.`;
+export function parseTaskContractArgs(args) {
+    const options = {};
+    const positional = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const token = args[i];
+        if (token === "--json") {
+            options.json = true;
+            continue;
+        }
+        if (token === "--task") {
+            options.task = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--input") {
+            options.input = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--expected-revision") {
+            const raw = args[i + 1];
+            const n = Number(raw);
+            if (!Number.isInteger(n) || n < 0) {
+                throw new Error(`invalid --expected-revision: ${raw}`);
+            }
+            options.expectedRevision = n;
+            i += 1;
+            continue;
+        }
+        if (token === "--expected-observed-hash") {
+            options.expectedObservedHash = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--request-id") {
+            options.requestId = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--request-payload-sha256") {
+            options.requestPayloadSha256 = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--tx-id") {
+            options.txId = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token.startsWith("-")) {
+            throw new Error(`unknown flag ${token}\n${USAGE}`);
+        }
+        positional.push(token);
+    }
+    const subcommand = positional[0];
+    if (!subcommand) {
+        throw new Error(USAGE);
+    }
+    // show takes positional taskId; others prefer --task
+    let taskId = options.task;
+    if (subcommand === "show") {
+        taskId = positional[1] ?? options.task;
+    }
+    return { subcommand, taskId, options };
+}
+function mutationOutcome(code) {
+    switch (code) {
+        case "REVISION_CONFLICT":
+        case "OBSERVED_HASH_CONFLICT":
+        case "REQUEST_ID_REUSE_CONFLICT":
+        case "LEASE_HELD":
+            return "conflict";
+        case "NOT_FOUND":
+            return "not-found";
+        case "TRANSACTION_INCOMPLETE":
+        case "OPERATION_NEEDS_RECONCILE":
+            return "needs-reconcile";
+        case "EXTERNALLY_MODIFIED":
+        case "NOT_MANAGED":
+        case "BINDING_DRIFT":
+            return "blocked";
+        case "INVALID_INPUT":
+        case "PATH_OUTSIDE_REPO":
+        case "UNSUPPORTED_SCHEMA_VERSION":
+            return "invalid";
+        default:
+            return "rejected";
+    }
+}
+function emit(result, json) {
+    // Machine envelope is the default for task contract when --json is set;
+    // without --json still print the same document for dogfood consistency.
+    writeOperatorJson(result);
+    if (!json) {
+        // already wrote JSON; human path same for Phase 0.5
+    }
+    process.exitCode = processExitCodeForOutcome(result.outcome);
+}
+export async function runTaskContract(repoRoot, args) {
+    let subcommand;
+    let taskId;
+    let options;
+    try {
+        ({ subcommand, taskId, options } = parseTaskContractArgs(args));
+    }
+    catch (error) {
+        const result = operatorFailed({
+            command: "task contract",
+            outcome: "invalid",
+            code: "INVALID_INPUT",
+            message: error instanceof Error ? error.message : String(error),
+        });
+        emit(result, true);
+        return;
+    }
+    const command = `task contract ${subcommand}`;
+    try {
+        switch (subcommand) {
+            case "show": {
+                if (!taskId) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract show requires <taskId>");
+                }
+                const state = await observeTaskContractState(repoRoot, taskId);
+                const result = operatorSucceeded(command, { taskId, state });
+                emit(result, options.json);
+                return;
+            }
+            case "validate": {
+                if (!taskId || !options.input) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract validate requires --task and --input");
+                }
+                const { draft } = await loadDraftFromPath(options.input, repoRoot);
+                const validation = await validateDraftForTask({
+                    repoRoot,
+                    taskId,
+                    draft,
+                });
+                if (!validation.ok) {
+                    const result = operatorFailed({
+                        command,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: validation.errors.join("; "),
+                        details: { errors: validation.errors },
+                    });
+                    emit(result, options.json);
+                    return;
+                }
+                const result = operatorSucceeded(command, {
+                    taskId,
+                    valid: true,
+                    warnings: validation.warnings,
+                });
+                emit(result, options.json);
+                return;
+            }
+            case "diff": {
+                if (!taskId || !options.input) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract diff requires --task and --input");
+                }
+                const { draft } = await loadDraftFromPath(options.input, repoRoot);
+                const diff = await diffTaskContract({ repoRoot, taskId, draft });
+                const result = operatorSucceeded(command, diff);
+                emit(result, options.json);
+                return;
+            }
+            case "apply": {
+                if (!taskId ||
+                    !options.input ||
+                    options.expectedRevision === undefined ||
+                    !options.expectedObservedHash ||
+                    !options.requestId ||
+                    !options.requestPayloadSha256) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract apply requires --task --input --expected-revision --expected-observed-hash --request-id --request-payload-sha256");
+                }
+                const loaded = await loadDraftFromPath(options.input, repoRoot);
+                // Client-supplied payload hash must match file bytes
+                if (loaded.payloadSha256 !== options.requestPayloadSha256) {
+                    throw new ContractMutationError("INVALID_INPUT", `request-payload-sha256 does not match input file hash (expected ${loaded.payloadSha256})`);
+                }
+                const applyResult = await applyTaskContract({
+                    repoRoot,
+                    taskId,
+                    draft: loaded.draft,
+                    expectedRevision: options.expectedRevision,
+                    expectedObservedHash: options.expectedObservedHash,
+                    requestId: options.requestId,
+                    requestPayloadSha256: options.requestPayloadSha256,
+                    rawDraftText: loaded.rawText,
+                });
+                const result = operatorSucceeded(command, applyResult);
+                emit(result, options.json);
+                return;
+            }
+            case "adopt": {
+                if (!taskId ||
+                    options.expectedRevision === undefined ||
+                    !options.expectedObservedHash ||
+                    !options.requestId ||
+                    !options.requestPayloadSha256) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract adopt requires --task --expected-revision --expected-observed-hash --request-id --request-payload-sha256");
+                }
+                const adoptResult = await adoptTaskContract({
+                    repoRoot,
+                    taskId,
+                    expectedRevision: options.expectedRevision,
+                    expectedObservedHash: options.expectedObservedHash,
+                    requestId: options.requestId,
+                    requestPayloadSha256: options.requestPayloadSha256,
+                });
+                const result = operatorSucceeded(command, adoptResult);
+                emit(result, options.json);
+                return;
+            }
+            case "doctor": {
+                if (!taskId) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract doctor requires --task");
+                }
+                const doctor = await doctorTaskContract({ repoRoot, taskId });
+                const result = operatorSucceeded(command, doctor);
+                emit(result, options.json);
+                return;
+            }
+            case "recover": {
+                if (!taskId) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract recover requires --task");
+                }
+                const recover = await recoverTaskContract({
+                    repoRoot,
+                    taskId,
+                    txId: options.txId,
+                });
+                const result = operatorSucceeded(command, recover);
+                emit(result, options.json);
+                return;
+            }
+            default:
+                throw new ContractMutationError("INVALID_INPUT", `unknown task contract subcommand: ${subcommand}\n${USAGE}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ContractMutationError) {
+            const result = operatorFailed({
+                command,
+                outcome: mutationOutcome(error.code),
+                code: error.code,
+                message: error.message,
+                details: error.details,
+            });
+            emit(result, options.json);
+            return;
+        }
+        const result = operatorFailed({
+            command,
+            outcome: "rejected",
+            code: "INTERNAL_ERROR",
+            message: error instanceof Error ? error.message : String(error),
+        });
+        emit(result, options.json);
+    }
+}