@tea-agent/loop-agent 0.43.0-next.13 → 0.43.0-next.15

package/dist/worker/console/workspace-initialization.js

@@ -0,0 +1,174 @@
+import { lstat, readFile } from "node:fs/promises";
+import path from "node:path";
+import { acquireUpdateLock, updateLockPath } from "../../shared/update/state.js";
+import os from "node:os";
+import { TERMINAL_OPERATION_STATES } from "../../infrastructure/console/operation-store.js";
+import { readInitRuntimeActivity } from "../observability/init-runtime-activity.js";
+const record = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("初始化检查返回了无效数据");
+    return value;
+};
+const entries = (value) => {
+    if (!Array.isArray(value))
+        throw new Error("初始化检查缺少状态清单");
+    return value.map(record);
+};
+/** A single registered workspace owns checks, CLI cwd and durable operations. */
+export class WorkspaceInitializationService {
+    options;
+    cached;
+    pending;
+    activeOperationId;
+    generation = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    snapshot(state, message, pendingPaths = []) {
+        const { workspaceId, name, repoRoot } = this.options;
+        return { workspaceId, name, displayPath: repoRoot, state, message, pendingPaths };
+    }
+    async jsonFile(relative) {
+        const file = path.join(this.options.repoRoot, relative);
+        try {
+            const stat = await lstat(file);
+            if (!stat.isFile() || stat.isSymbolicLink())
+                throw new Error(`${relative} 不是普通配置文件`);
+            return record(JSON.parse(await readFile(file, "utf8")));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw new Error(`${relative} 无法读取，请检查文件内容与权限`);
+        }
+    }
+    async command(args, name) {
+        const result = await this.options.client.run(args, {
+            cwd: this.options.repoRoot, artifactName: `workspace-init-${name}`,
+            expectJson: true, timeoutMs: 120_000,
+        });
+        if (!result.ok || result.exitCode !== 0 || result.timedOut || result.parseFailure) {
+            throw new Error(`工作区配置${name === "check" ? "检查" : "操作"}失败，请查看操作记录或检查模型与初始化配置`);
+        }
+        return record(result.json);
+    }
+    async catalog() {
+        const catalog = await this.command(["init", "model-catalog", "--json"], "models");
+        return entries(catalog.models).filter(item => item.eligibleForHarness === true && typeof item.reference === "string")
+            .map(item => ({ reference: item.reference, name: typeof item.name === "string" ? item.name : item.reference }));
+    }
+    async inspect() {
+        try {
+            try {
+                const harnessDir = await lstat(path.join(this.options.repoRoot, ".harness"));
+                if (!harnessDir.isDirectory() || harnessDir.isSymbolicLink())
+                    throw new Error(".harness 必须是仓库内的普通目录");
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            const surface = await this.jsonFile(".harness/init-surface.json");
+            const harness = await this.jsonFile("harness.json");
+            if (surface && (surface.schemaVersion !== 1 || !surface.files || typeof surface.files !== "object" || Array.isArray(surface.files))) {
+                throw new Error("初始化记录不完整，请检查 .harness/init-surface.json");
+            }
+            if (!surface && !harness) {
+                const snapshot = this.snapshot("uninitialized", "此仓库尚未初始化。初始化后可使用项目任务与工作流配置。");
+                try {
+                    snapshot.models = await this.catalog();
+                }
+                catch {
+                    snapshot.message = "此仓库尚未初始化；可用模型读取失败，请检查模型设置后重新检查。";
+                }
+                return snapshot;
+            }
+            const report = await this.command(["init", "check-update", "--json"], "check");
+            if (!["recorded", "inferred-baseline", "missing"].includes(String(report.surfaceState)) || typeof report.ok !== "boolean") {
+                throw new Error("初始化检查返回了未知状态");
+            }
+            const actions = entries(report.deterministicActions);
+            const merges = entries(report.modelMergeTasks);
+            const decisions = entries(report.humanDecisions);
+            const pendingPaths = [...new Set([...actions, ...merges, ...decisions].map(item => item.path).filter((p) => typeof p === "string"))];
+            const modelsReady = record(report.modelReadiness).status === "ready";
+            if (merges.length || decisions.length || !modelsReady || !report.ok && !actions.length) {
+                return this.snapshot("needs-attention", !modelsReady ? "项目模型配置需要处理，请在模型设置中检查；已有配置不会被覆盖。" : "部分配置需要合并或确认，请处理以下文件后重新检查。", pendingPaths);
+            }
+            if (actions.length || report.surfaceState !== "recorded")
+                return this.snapshot("update-available", "有可安全更新的项目配置。更新会保留用户修改。", pendingPaths);
+            return this.snapshot("ready", "工作区配置已就绪");
+        }
+        catch (error) {
+            return this.snapshot("error", error instanceof Error ? error.message : "初始化状态检查失败");
+        }
+    }
+    async check(refresh = false) {
+        const latest = (await this.options.operations.list()).filter(op => op.action === "workspaceInitialize").at(-1);
+        const running = latest && !TERMINAL_OPERATION_STATES.has(latest.state) && latest.state !== "needs-reconcile";
+        if (!running && (refresh || !this.cached || Date.now() - this.cached.at > 30_000)) {
+            const generation = this.generation;
+            this.pending ??= this.inspect().then(value => { if (generation === this.generation)
+                this.cached = { value, at: Date.now() }; return value; }).finally(() => { this.pending = undefined; });
+            await this.pending;
+        }
+        const value = this.cached?.value ?? this.snapshot("uninitialized", "正在初始化工作区…");
+        return { ...value, ...(latest ? { operation: { operationId: latest.operationId, state: latest.state, ...(latest.errorMessage ? { message: latest.errorMessage } : {}) } } : {}) };
+    }
+    async start(clientRequestId, model) {
+        const created = await this.options.operations.create({ clientRequestId, action: "workspaceInitialize", actionParams: { ...(model ? { model } : {}) } });
+        if (created.kind !== "created")
+            return created;
+        const operationId = created.operation.operationId;
+        if (this.activeOperationId) {
+            await this.options.operations.update(operationId, { state: "failed", finishedAt: new Date().toISOString(), errorCode: "WORKSPACE_INIT_BUSY", errorMessage: "此工作区已有初始化操作正在运行" });
+            return created;
+        }
+        this.activeOperationId = operationId;
+        this.generation += 1;
+        queueMicrotask(() => { void this.execute(operationId, model); });
+        return created;
+    }
+    async execute(operationId, model) {
+        let release;
+        try {
+            await this.options.operations.update(operationId, { state: "running", startedAt: new Date().toISOString() });
+            this.options.events.append(operationId, { at: new Date().toISOString(), kind: "state", state: "running", message: `正在检查并配置 ${this.options.name}` });
+            release = await (this.options.acquireLock ?? (() => acquireUpdateLock(updateLockPath(os.homedir()))))();
+            if (!release)
+                throw new Error("程序更新或其他初始化操作正在进行，请稍后重试");
+            const activity = await (this.options.readActivity ?? readInitRuntimeActivity)(this.options.repoRoot);
+            if (activity.workerProjectionError || activity.activeDagRunIds.length || activity.activeWorkerTasks || activity.activeWorkerBatches || this.options.activeChatTurnCount())
+                throw new Error("当前工作区有任务或对话正在运行，请结束后重试");
+            const operations = await this.options.operations.list();
+            if (operations.some(op => op.operationId !== operationId && !TERMINAL_OPERATION_STATES.has(op.state) && op.state !== "needs-reconcile"))
+                throw new Error("当前工作区有其他操作正在运行，请稍后重试");
+            const before = await this.inspect();
+            if (before.state === "error" || before.state === "needs-attention")
+                throw new Error(before.message);
+            if (before.state === "uninitialized") {
+                if (!model || !before.models?.some(item => item.reference === model))
+                    throw new Error("请选择一个可用的初始模型；可在模型设置中完成认证后重新检查");
+                await this.command(["init", "--profile", "full", "--merge", "--client-recovery", "project", "--model", model, "--json"], "apply");
+            }
+            else if (before.state === "update-available") {
+                await this.command(["init", "update", "--apply-safe", "--client-recovery", "project", "--json"], "apply");
+            }
+            const after = await this.inspect();
+            this.cached = { value: after, at: Date.now() };
+            const state = after.state === "ready" ? "succeeded" : "needs-reconcile";
+            await this.options.operations.update(operationId, { state, finishedAt: new Date().toISOString(), result: { initialization: after }, ...(state !== "succeeded" ? { errorCode: "INIT_NEEDS_RECONCILE", errorMessage: after.message } : {}) });
+            this.options.events.append(operationId, { at: new Date().toISOString(), kind: "state", state, message: after.message });
+        }
+        catch (error) {
+            this.cached = undefined;
+            const message = error instanceof Error ? error.message : "工作区初始化失败";
+            await this.options.operations.update(operationId, { state: "failed", finishedAt: new Date().toISOString(), errorCode: "WORKSPACE_INIT_FAILED", errorMessage: message });
+            this.options.events.append(operationId, { at: new Date().toISOString(), kind: "error", state: "failed", message });
+        }
+        finally {
+            this.activeOperationId = undefined;
+            await release?.().catch(() => undefined);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.43.0-next.13",
+  "version": "0.43.0-next.15",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",
@@ -98,8 +98,6 @@
   },
   "devDependencies": {
     "@remixicon/react": "^4.9.0",
-    "@stryker-mutator/core": "^10.0.0",
-    "@stryker-mutator/vitest-runner": "^10.0.0",
     "@types/node": "^24.6.0",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",

package/dist/commands/new-task.js

@@ -1,5 +0,0 @@
-import { createTask } from '../task/runtime.js';
-export async function runNewTask(repoRoot, taskId, title) {
-    const taskDir = await createTask(repoRoot, taskId, title);
-    console.log(taskDir);
-}

package/dist/commands/status.js

@@ -1,57 +0,0 @@
-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

@@ -1,269 +0,0 @@
-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);
-    }
-}

package/dist/shared/prompts.js

@@ -1,26 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { isFeatureStudyTask } from './reference-context.js';
-export async function loadPrompt(repoRoot, step, taskConfig) {
-    const filename = resolvePromptFilename(step, taskConfig);
-    const promptPath = path.join(repoRoot, '.harness', 'prompts', filename);
-    try {
-        return await readFile(promptPath, 'utf-8');
-    }
-    catch {
-        if (filename !== `${step}.md`) {
-            return readFile(path.join(repoRoot, '.harness', 'prompts', `${step}.md`), 'utf-8');
-        }
-        throw new Error(`prompt not found: ${promptPath}`);
-    }
-}
-function resolvePromptFilename(step, taskConfig) {
-    if (!taskConfig || !isFeatureStudyTask(taskConfig)) {
-        return `${step}.md`;
-    }
-    if (step === 'analyze')
-        return 'feature-study-analyze.md';
-    if (step === 'plan')
-        return 'feature-study-plan.md';
-    return `${step}.md`;
-}

package/dist/task/config.js

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

package/dist/task/contract/validate-draft.js

@@ -1,106 +0,0 @@
-import path from "node:path";
-import { safeParseTaskContractDraft } from "./schema.js";
-import { getTaskContractPaths } from "./paths.js";
-import { readSourceManifest } from "../source-references.js";
-function isPathOutsideRepoHint(p) {
-    if (path.isAbsolute(p))
-        return true;
-    if (p.includes("\0"))
-        return true;
-    const normalized = p.replace(/\\/g, "/");
-    if (normalized.startsWith("../") || normalized.includes("/../"))
-        return true;
-    return false;
-}
-export async function validateTaskContractDraft(input) {
-    const errors = [];
-    const warnings = [];
-    const parsed = safeParseTaskContractDraft(input.draft);
-    if (!parsed.success) {
-        for (const issue of parsed.error.issues) {
-            errors.push({
-                code: issue.message.includes("schemaVersion") ||
-                    issue.path[0] === "schemaVersion"
-                    ? "UNSUPPORTED_SCHEMA_VERSION"
-                    : "INVALID_INPUT",
-                path: issue.path.join("."),
-                message: issue.message,
-            });
-        }
-        return {
-            taskId: input.taskId,
-            valid: false,
-            errors,
-            warnings,
-        };
-    }
-    const draft = parsed.data;
-    if (draft.taskId !== input.taskId) {
-        errors.push({
-            code: "INVALID_INPUT",
-            path: "taskId",
-            message: `draft.taskId (${draft.taskId}) does not match task (${input.taskId})`,
-        });
-    }
-    for (const p of draft.constraints.allowedPaths) {
-        if (isPathOutsideRepoHint(p) && !p.includes("*")) {
-            // globs may be relative; absolute is out of repo
-            if (path.isAbsolute(p)) {
-                errors.push({
-                    code: "PATH_OUTSIDE_REPO",
-                    path: "constraints.allowedPaths",
-                    message: `absolute path not allowed: ${p}`,
-                });
-            }
-        }
-    }
-    for (const p of draft.constraints.forbiddenPaths) {
-        if (path.isAbsolute(p)) {
-            errors.push({
-                code: "PATH_OUTSIDE_REPO",
-                path: "constraints.forbiddenPaths",
-                message: `absolute path not allowed: ${p}`,
-            });
-        }
-    }
-    if (draft.references && draft.references.length > 0) {
-        const paths = getTaskContractPaths(input.repoRoot, input.taskId);
-        const manifest = await readSourceManifest(paths.sourceDir);
-        if (!manifest) {
-            warnings.push({
-                code: "MISSING_SOURCE_MANIFEST",
-                message: "draft references present but source-manifest.json is missing; import-prd first for immutable evidence",
-            });
-        }
-        else {
-            for (const ref of draft.references) {
-                const normalized = ref.ref.replace(/\\/g, "/");
-                const hit = manifest.documents.some((doc) => {
-                    const mat = doc.materializedPath.replace(/\\/g, "/");
-                    return (mat === normalized ||
-                        `source/${mat}` === normalized ||
-                        normalized.endsWith(mat));
-                });
-                if (!hit) {
-                    warnings.push({
-                        code: "REFERENCE_NOT_IN_MANIFEST",
-                        message: `reference not found in source-manifest: ${ref.ref}`,
-                    });
-                }
-            }
-        }
-    }
-    if (draft.sourceResolutions &&
-        draft.sourceResolutions.some((r) => r.decidedBy !== "human")) {
-        warnings.push({
-            code: "NON_HUMAN_SOURCE_RESOLUTION",
-            message: "one or more sourceResolutions are not decidedBy=human; blocking conflicts require human resolution before apply",
-        });
-    }
-    return {
-        taskId: input.taskId,
-        valid: errors.length === 0,
-        errors,
-        warnings,
-    };
-}

package/dist/task/goal.js

@@ -1,3 +0,0 @@
-export { clearTaskGoal, consumeTaskGoalNotices, getTaskGoal, incrementGoalContinuationRuns, markTaskGoalComplete, recordTaskGoalProgress, setTaskGoal, updateTaskGoalStatus, } from "./runtime.js";
-export * from "./goal-audit.js";
-export * from "./goal-policy.js";