@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/task/config-types.js

@@ -0,0 +1,235 @@
+import { z } from "zod";
+import { isOpenspecSpecFilePath } from "../shared/openspec-spec.js";
+export const taskFlowSchema = z.enum([
+    "auto",
+    "micro",
+    "standard",
+    "spec",
+    "loop",
+    "feature-study",
+]);
+export const taskKindSchema = z.enum([
+    "standard",
+    "feature-study",
+    "frontend-implementation",
+    "frontend-test",
+    "backend-test",
+    "knowledge-sync",
+    "knowledge-graph-bootstrap",
+]);
+export const referenceRepoConfigSchema = z.object({
+    name: z.string().min(1),
+    path: z.string().min(1),
+    focusGlobs: z.array(z.string().min(1)).optional().default([]),
+});
+export const referenceDocConfigSchema = z.object({
+    name: z.string().min(1).optional(),
+    path: z.string().min(1),
+});
+export const taskComplexitySchema = z.enum(["small", "medium", "large"]);
+export const taskCapabilitySchema = z.enum(["interactive-ui"]);
+export const contextProfileSchema = z.enum(["full", "slim"]);
+export const piSubagentModeSchema = z.enum(["off", "analyze-plan", "full"]);
+export const verifyModeSchema = z.enum(["parallel", "serial"]);
+export const verifyPresetSchema = z.enum(["auto", "quick", "standard", "full"]);
+export const verifyQuotaSchema = z.enum(["1", "3", "full"]);
+export const taskVerifyCommandSchema = z.object({
+    label: z.string().min(1),
+    command: z.string().min(1),
+    timeoutMs: z.number().int().positive().optional(),
+});
+export const dagVerifyStrategySchema = z
+    .object({
+    intermediateQuota: verifyQuotaSchema.optional(),
+    finalQuota: z.literal("full").optional().default("full"),
+    focusedCommandSource: z
+        .literal("adapter")
+        .optional()
+        .default("adapter"),
+})
+    .optional();
+export const loopAutoExecutionPolicySchema = z.enum([
+    "off",
+    "approval-required",
+    "enabled",
+]);
+export const LOOP_AUTO_WRITE_POLICY_REMOVED_ERROR = "task field loopAutoWritePolicy is no longer supported; use loopAutoExecutionPolicy (off | approval-required | enabled)";
+export const CURSOR_TASK_FIELD_REMOVED_ERROR = 'task fields "executor" and "cursorModel" are no longer supported; governed runtime is Pi-only';
+export const frontendMockPolicySchema = z.enum(["auto", "required", "disabled"]);
+export const frontendMockVerifyCommandSchema = z.object({
+    label: z.string().min(1),
+    command: z.string().min(1),
+    timeoutMs: z.number().int().positive().optional(),
+});
+export const frontendMockConfigSchema = z.object({
+    policy: frontendMockPolicySchema.optional().default("auto"),
+    serviceRoot: z.string().min(1).optional(),
+    verifyCommands: z.array(frontendMockVerifyCommandSchema).optional().default([]),
+});
+/** OpenSpec gate policy for frontend prewrite: cited (default) vs scan-strict. */
+export const frontendOpenspecPolicySchema = z.enum(["cited", "scan-strict"]);
+/**
+ * Frontend OpenSpec gate configuration. `cited` (the task-config default) makes
+ * the prewrite gate verify contract-declared requiredReadPaths plus task-source
+ * citations instead of the full generation-time directory snapshot; `scan-strict`
+ * keeps the auto-discovered full-read semantics.
+ */
+export const frontendOpenspecConfigSchema = z.object({
+    policy: frontendOpenspecPolicySchema.optional().default("cited"),
+    requiredReadPaths: z
+        .array(z
+        .string()
+        .refine((candidate) => !candidate.includes("\\") &&
+        isOpenspecSpecFilePath(candidate), "frontendOpenspec.requiredReadPaths entries must be repo-relative supported files under openspec/schemas/, openspec/project-specs/, or ai_workspace/"))
+        .optional()
+        .default([]),
+});
+/** Batch limits and gate profile for the browser-driven frontend test DAG.
+ * Token fields are post-case stop thresholds, not model-provider hard caps. */
+export const frontendTestConfigSchema = z.object({
+    maxCasesPerBatch: z.number().int().min(1).max(100).optional(),
+    maxTokensPerCase: z.number().int().positive().optional(),
+    maxTotalTokens: z.number().int().positive().optional(),
+    /**
+     * Case review topology:
+     * - off (default): mechanical checklist-shell only; no LLM review hard gate
+     * - advisory: reserved (same default path as off for now; LLM notes non-blocking)
+     * - blocking: legacy dual-review + final VERDICT: pass gate before materialize
+     */
+    reviewMode: z.enum(["off", "advisory", "blocking"]).optional(),
+    /**
+     * When true, include quality outcome gate (all cases passed, 0 blocked).
+     * Default false: pipeline success is result materialize + retrospect report, not full green.
+     */
+    strictOutcomeGate: z.boolean().optional(),
+    /**
+     * Maximum rerun attempts for blocked or missing-result frontend cases.
+     * Defaults to 1 for the lean off/advisory topology and 2 for the full
+     * reviewMode=blocking topology. An explicit value overrides either default.
+     */
+    maxRerunAttempts: z.number().int().min(0).max(4).optional(),
+    /**
+     * Report chain toggles for the lean frontend-test DAG.
+     * - retrospect: opt-in Pi retrospective node (default off). Pipeline success
+     *   is frontend-test-result-v1 + main HTML/MD report, not the retrospect.
+     * - l5: write the deterministic L-5 dashboard from the merged reports node
+     *   (default true; the merged reports node always renders the main
+     *   HTML/MD report regardless of this flag).
+     */
+    reports: z
+        .object({
+        retrospect: z.boolean().optional(),
+        l5: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
+});
+/** Backend-test artifact layout and pipeline mode configuration (plan A/B/D). */
+export const backendTestConfigSchema = z
+    .object({
+    /** Repository-relative test root. Default "testcase". */
+    testRoot: z.string().min(1).optional(),
+    /** Markdown subdirectory relative to testRoot. Default "md". */
+    markdownRel: z.string().min(1).optional(),
+    /** Pytest script subdirectory relative to testRoot. Default "." (testRoot itself). */
+    scriptRel: z.string().min(1).optional(),
+    /** User-provided shared setup document (plan B). Read-only bound source. */
+    sharedSetupDoc: z.string().min(1).optional(),
+    /** Pipeline mode: full 16-node chain (default) or gap-fill incremental DAG (plan D). */
+    mode: z.enum(["full", "gap-fill"]).optional(),
+    /** Required for mode=gap-fill: user missing-scenario document path. */
+    gapDoc: z.string().min(1).optional(),
+    /** gap-fill pytest execution scope: only affected items (default) or all eligible. */
+    executeScope: z.enum(["affected", "all"]).optional(),
+})
+    .strict()
+    .optional();
+export const convergenceConfigSchema = z.object({
+    enabled: z.boolean().optional().default(false),
+    maxPasses: z.number().int().positive().optional().default(3),
+    stopOnVerdictPass: z.boolean().optional().default(true),
+    stopOnHardVerifyPass: z.boolean().optional().default(true),
+    pauseOnRegression: z.boolean().optional().default(true),
+});
+const taskConfigObjectSchema = z.object({
+    taskId: z.string(),
+    title: z.string(),
+    sourceFiles: z.array(z.string()),
+    /** standard: 本仓库需求实现；feature-study: 参考外部代码特性并在目标仓库落地；frontend-implementation: 前端实现 DAG；backend-test: 后端测试 DAG；knowledge-sync: 最终验证后回写测试知识库 DAG；knowledge-graph-bootstrap: AI 辅助业务知识图谱初始化 */
+    taskKind: taskKindSchema.optional().default("standard"),
+    /** true = taskKind 由人类显式选择（含显式 standard）；DAG 路由必须尊重，不做语义改写。 */
+    taskKindExplicit: z.boolean().optional(),
+    /** Feature 目录 id（如 F-2026-004）。knowledge-sync 必填（也可从 hardConstraints/需求正文/taskId 解析）；用于收窄 writeSet */
+    featureId: z.string().min(1).optional(),
+    referenceRepos: z.array(referenceRepoConfigSchema).optional().default([]),
+    referenceDocs: z.array(referenceDocConfigSchema).optional().default([]),
+    referenceMaxFilesPerRepo: z.number().int().positive().optional(),
+    referenceMaxTotalFiles: z.number().int().positive().optional(),
+    allowedPaths: z.array(z.string()).optional().default([]),
+    /**
+     * Coarse repository roots used only by the frontend preflight scout. Before
+     * DAG generation, the scout must resolve these into the narrower
+     * `allowedPaths` consumed by writer nodes.
+     */
+    allowedRoots: z.array(z.string()).optional(),
+    forbiddenPaths: z.array(z.string()).optional().default([]),
+    hardConstraints: z.array(z.string()).optional().default([]),
+    autoCommitAfterVerify: z.boolean().optional().default(true),
+    autoCommitMessage: z.string().optional().default(""),
+    /** Explicit reason that a medium/large task could not use DAG before loop auto execution. */
+    dagFallbackReason: z.string().optional(),
+    /** full: attach governance bundle; slim: analyze/plan 只带最少仓库上下文（source + harness 等） */
+    contextProfile: contextProfileSchema.optional().default("full"),
+    timeoutMs: z.number().int().positive().optional(),
+    flow: taskFlowSchema.optional().default("auto"),
+    complexity: taskComplexitySchema.optional().default("medium"),
+    /** Explicit delivery capabilities that affect writer contracts/model tier without changing risk. */
+    capabilities: z.array(taskCapabilitySchema).optional(),
+    verifyMode: verifyModeSchema.optional().default("serial"),
+    verifyPreset: verifyPresetSchema.optional().default("auto"),
+    /** Task-contract commands that must be included in final DAG shell verification. */
+    verifyCommands: z.array(taskVerifyCommandSchema).optional().default([]),
+    /** Verification selection policy. Intermediate loops may use quota; final gates still run full required verification. */
+    verifyQuota: verifyQuotaSchema.optional().default("full"),
+    /** DAG supervised verify strategy. Final quota is fixed to full; intermediate quota may reduce cost. */
+    dagVerifyStrategy: dagVerifyStrategySchema,
+    verifyRetryCount: z.number().int().min(0).optional().default(0),
+    verifyFailFast: z.boolean().optional().default(false),
+    contextMaxFiles: z.number().int().min(0).optional().default(0),
+    maxFixLoops: z.number().int().min(0).optional().default(2),
+    /** Supervised DAG convergence is opt-in until runtime smoke evidence is stronger. */
+    convergence: convergenceConfigSchema.optional().default({ enabled: false }),
+    /** Outer loop auto mode never writes by default; DAG execute requires this policy plus path/writeSet gates. */
+    loopAutoExecutionPolicy: loopAutoExecutionPolicySchema
+        .optional()
+        .default("off"),
+    requireRetrospective: z.boolean().optional().default(false),
+    /** inherit: use host shell env; clean: sanitized env for deterministic verify */
+    verifyEnv: z.enum(["inherit", "clean"]).optional().default("clean"),
+    /** Max legacy goal continuation attempts before auto-pausing an active goal */
+    maxGoalContinuationsPerRun: z.number().int().positive().optional().default(5),
+    /** Pi subagent assisted mode: 'off' (default), 'analyze-plan', or 'full' */
+    piSubagentMode: piSubagentModeSchema.optional().default("off"),
+    /** Frontend mock data workflow policy, service root hint, and deterministic mock verification commands. */
+    frontendMock: frontendMockConfigSchema.optional(),
+    /** Frontend browser-test batch and post-case token-stop configuration. */
+    frontendTest: frontendTestConfigSchema.optional(),
+    /** Frontend OpenSpec gate policy and contract-declared required read paths. */
+    frontendOpenspec: frontendOpenspecConfigSchema.optional(),
+    /** Backend-test layout / shared-setup / gap-fill configuration. */
+    backendTest: backendTestConfigSchema,
+    notes: z.string().optional().default(""),
+});
+export const taskConfigSchema = z.preprocess((raw) => {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return raw;
+    }
+    const obj = raw;
+    if ("loopAutoWritePolicy" in obj) {
+        throw new Error(LOOP_AUTO_WRITE_POLICY_REMOVED_ERROR);
+    }
+    if ("executor" in obj || "cursorModel" in obj) {
+        throw new Error(CURSOR_TASK_FIELD_REMOVED_ERROR);
+    }
+    return raw;
+}, taskConfigObjectSchema);

package/dist/task/config.js

@@ -0,0 +1,2 @@
+export * from "./config-types.js";
+export * from "./workflow-state-types.js";

package/dist/task/contract/adopt.js

@@ -0,0 +1,166 @@
+import { CANONICALIZER_VERSION, PROJECTION_VERSION, TASK_CONFIG_SCHEMA_VERSION, TASK_CONTRACT_REF_SCHEMA_VERSION, } from "./constants.js";
+import { ContractMutationError } from "./apply.js";
+import { computeCanonicalHash, computeSourceHashes, computeTaskConfigSha256, } from "./hash.js";
+import { acquireTaskContractLock, assertLockHeld } from "./lock.js";
+import { loadObservedTaskBytes, logicalRevisionForState, observeTaskContractState, readStoredContractRef, } from "./observe.js";
+import { serializeTaskConfigForDisk } from "./project.js";
+import { appendRequestLedgerEntry, findRequestLedgerEntry, } from "./request-ledger.js";
+import { finalizeTransaction, runJournaledContractCommit, } from "./transaction.js";
+import { getTaskPaths, parseTaskConfigForRuntime } from "../runtime.js";
+/**
+ * Adopt current on-disk 需求.md / 执行约束.md / task.json as next managed revision.
+ * Does not rewrite reference bytes. Requires deterministic readable facts.
+ */
+export async function adoptTaskContract(input) {
+    const existing = await findRequestLedgerEntry({
+        repoRoot: input.repoRoot,
+        taskId: input.taskId,
+        requestId: input.requestId,
+    });
+    if (existing) {
+        if (existing.requestPayloadSha256 !== input.requestPayloadSha256) {
+            throw new ContractMutationError("REQUEST_ID_REUSE_CONFLICT", `requestId ${input.requestId} was used with a different payload hash`);
+        }
+        const ref = await readStoredContractRef(getTaskPaths(input.repoRoot, input.taskId).contractPath);
+        if (!ref) {
+            throw new ContractMutationError("OPERATION_NEEDS_RECONCILE", "request ledger hit but contract.json missing");
+        }
+        return {
+            ref,
+            changedFiles: [],
+            idempotentReplay: true,
+            txId: existing.txId,
+        };
+    }
+    const lock = await acquireTaskContractLock({
+        repoRoot: input.repoRoot,
+        taskId: input.taskId,
+        requestId: input.requestId,
+        operation: "contract-adopt",
+    });
+    try {
+        const existingUnderLock = await findRequestLedgerEntry({
+            repoRoot: input.repoRoot,
+            taskId: input.taskId,
+            requestId: input.requestId,
+        });
+        if (existingUnderLock) {
+            if (existingUnderLock.requestPayloadSha256 !== input.requestPayloadSha256) {
+                throw new ContractMutationError("REQUEST_ID_REUSE_CONFLICT", `requestId ${input.requestId} was used with a different payload hash`);
+            }
+            const ref = await readStoredContractRef(getTaskPaths(input.repoRoot, input.taskId).contractPath);
+            if (!ref) {
+                throw new ContractMutationError("OPERATION_NEEDS_RECONCILE", "request ledger hit but contract.json missing");
+            }
+            return {
+                ref,
+                changedFiles: [],
+                idempotentReplay: true,
+                txId: existingUnderLock.txId,
+            };
+        }
+        const state = await observeTaskContractState(input.repoRoot, input.taskId);
+        if (state.effectiveStatus === "transaction-incomplete") {
+            throw new ContractMutationError("TRANSACTION_INCOMPLETE", "unfinished transaction; re-run task advance (auto recover-contract)");
+        }
+        const currentRevision = logicalRevisionForState(state);
+        if (input.expectedRevision !== currentRevision) {
+            throw new ContractMutationError("REVISION_CONFLICT", `expectedRevision ${input.expectedRevision} does not match current ${currentRevision}`, { currentRevision, expectedRevision: input.expectedRevision });
+        }
+        const bytes = await loadObservedTaskBytes(input.repoRoot, input.taskId);
+        if (bytes.requirementBytes === null ||
+            bytes.constraintsBytes === null ||
+            bytes.taskConfigRaw === null ||
+            bytes.taskConfigSha256 === null) {
+            throw new ContractMutationError("INVALID_INPUT", "adopt requires existing 需求.md, 执行约束.md, and task.json");
+        }
+        const observedHash = state.observedCanonicalHash;
+        if (!observedHash) {
+            throw new ContractMutationError("OBSERVED_HASH_CONFLICT", "unable to observe current canonical hash for adopt");
+        }
+        if (input.expectedObservedHash !== observedHash) {
+            throw new ContractMutationError("OBSERVED_HASH_CONFLICT", "expectedObservedHash does not match current observed hash", {
+                expectedObservedHash: input.expectedObservedHash,
+                observedCanonicalHash: observedHash,
+            });
+        }
+        const fullConfig = parseTaskConfigForRuntime(bytes.taskConfigRaw);
+        const taskConfigContent = serializeTaskConfigForDisk(fullConfig);
+        const sourceHashes = computeSourceHashes({
+            requirementBytes: bytes.requirementBytes,
+            constraintsBytes: bytes.constraintsBytes,
+            referenceManifestBytes: bytes.referenceManifestBytes,
+        });
+        const taskConfigSha256 = computeTaskConfigSha256(fullConfig);
+        const canonicalHash = computeCanonicalHash({
+            sourceHashes,
+            taskConfigSha256,
+        });
+        // Sanity: observed should equal recomputed
+        if (canonicalHash !== observedHash) {
+            throw new ContractMutationError("OBSERVED_HASH_CONFLICT", "recomputed canonical hash diverged during adopt");
+        }
+        const nextRevision = currentRevision + 1;
+        const nextRef = {
+            schemaVersion: TASK_CONTRACT_REF_SCHEMA_VERSION,
+            taskId: input.taskId,
+            revision: nextRevision,
+            projectionVersion: PROJECTION_VERSION,
+            canonicalizerVersion: CANONICALIZER_VERSION,
+            taskConfigSchemaVersion: TASK_CONFIG_SCHEMA_VERSION,
+            sourceHashes,
+            taskConfigSha256,
+            canonicalHash,
+            updatedAt: new Date().toISOString(),
+            lastRequestId: input.requestId,
+        };
+        // Adopt rewrites contract.json and re-writes same source/config bytes
+        // (stable content) so journal protocol is uniform.
+        await assertLockHeld(lock);
+        const { txId, ref } = await runJournaledContractCommit({
+            repoRoot: input.repoRoot,
+            taskId: input.taskId,
+            operation: "adopt",
+            requestId: input.requestId,
+            requestPayloadSha256: input.requestPayloadSha256,
+            expectedRevision: input.expectedRevision,
+            expectedObservedCanonicalHash: input.expectedObservedHash,
+            nextRevision,
+            fencingToken: lock.record.fencingToken,
+            targets: {
+                requirementContent: bytes.requirementBytes,
+                constraintsContent: bytes.constraintsBytes,
+                taskConfigContent,
+                contractRef: nextRef,
+            },
+        });
+        await appendRequestLedgerEntry({
+            repoRoot: input.repoRoot,
+            taskId: input.taskId,
+            entry: {
+                schemaVersion: 1,
+                requestId: input.requestId,
+                requestPayloadSha256: input.requestPayloadSha256,
+                txId,
+                revision: ref.revision,
+                canonicalHash: ref.canonicalHash,
+                recordedAt: new Date().toISOString(),
+                resultSummary: { ok: true, operation: "adopt" },
+            },
+        });
+        await finalizeTransaction({
+            repoRoot: input.repoRoot,
+            taskId: input.taskId,
+            txId,
+        });
+        return {
+            ref,
+            changedFiles: ["contract.json"],
+            idempotentReplay: false,
+            txId,
+        };
+    }
+    finally {
+        await lock.release();
+    }
+}