@tea-agent/loop-agent 0.26.0 → 0.26.1

package/dist/executors/shell-write-guard.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { createReadStream } from "node:fs";
-import { lstat, readlink } from "node:fs/promises";
+import { constants, createReadStream } from "node:fs";
+import { access, lstat, readlink } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../shared/git-progress.js";
 async function sha256File(filePath) {
@@ -164,40 +164,176 @@ export function validateShellWriteGuard(input) {
     }
     return { ok: violations.length === 0, violations };
 }
+export class GitStatusUnavailableError extends Error {
+    diagnostics;
+    constructor(input) {
+        const last = input.attempts.at(-1);
+        const exitCode = last?.exitCode === undefined ? "unavailable" : String(last.exitCode);
+        const signal = last?.signal ?? "unavailable";
+        const phase = input.phase ?? "unspecified";
+        super(`git status failed after ${input.attempts.length} attempts (phase=${phase}, exit code=${exitCode}, exit code hex=${last?.exitCodeHex ?? "unavailable"}, signal=${signal}, cwd=${path.resolve(input.cwd)}): ${last?.detail ?? "unknown error"}`);
+        this.name = "GitStatusUnavailableError";
+        this.diagnostics = {
+            schemaVersion: 1,
+            phase,
+            cwd: path.resolve(input.cwd),
+            platform: input.platform ?? process.platform,
+            executableCandidates: input.executableCandidates ?? [],
+            requiredWindowsEnvironment: input.requiredWindowsEnvironment ?? requiredWindowsEnvironment(process.env),
+            attempts: input.attempts,
+        };
+    }
+}
+function requiredWindowsEnvironment(env) {
+    return {
+        SystemRootPresent: Boolean(env.SystemRoot ?? env.SYSTEMROOT),
+        windirPresent: Boolean(env.windir ?? env.WINDIR),
+        ComSpecPresent: Boolean(env.ComSpec ?? env.COMSPEC),
+        PATHEXTPresent: Boolean(env.PATHEXT),
+    };
+}
+function errorExitCode(error) {
+    if (error &&
+        typeof error === "object" &&
+        "exitCode" in error &&
+        typeof error.exitCode === "number") {
+        return error.exitCode;
+    }
+    return undefined;
+}
+function errorSignal(error) {
+    if (error &&
+        typeof error === "object" &&
+        "signal" in error &&
+        typeof error.signal === "string") {
+        return error.signal;
+    }
+    return null;
+}
+function formatWindowsExitCode(exitCode) {
+    if (exitCode === undefined)
+        return undefined;
+    return `0x${(exitCode >>> 0).toString(16).padStart(8, "0").toUpperCase()}`;
+}
+function isWindowsDllInitializationFailure(platform, exitCode) {
+    return platform === "win32" && exitCode !== undefined && (exitCode >>> 0) === 0xc0000142;
+}
+function boundedErrorDetail(error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return detail.length <= 1000 ? detail : `${detail.slice(0, 1000)}...[truncated]`;
+}
+export function deriveSameInstallationGitCandidates(primary) {
+    const normalized = path.win32.normalize(primary);
+    const lower = normalized.toLowerCase();
+    let fallback;
+    if (lower.endsWith("\\mingw64\\bin\\git.exe")) {
+        const root = path.win32.resolve(path.win32.dirname(normalized), "..", "..");
+        fallback = path.win32.join(root, "cmd", "git.exe");
+    }
+    else if (lower.endsWith("\\cmd\\git.exe")) {
+        const root = path.win32.resolve(path.win32.dirname(normalized), "..");
+        fallback = path.win32.join(root, "mingw64", "bin", "git.exe");
+    }
+    return Array.from(new Set([normalized, ...(fallback ? [fallback] : [])]));
+}
+async function resolveGitExecutableCandidates(platform, env) {
+    if (platform !== "win32")
+        return ["git"];
+    const pathValue = env.PATH ?? env.Path ?? "";
+    for (const rawEntry of pathValue.split(path.delimiter)) {
+        const entry = rawEntry.trim().replace(/^"|"$/g, "");
+        if (!entry)
+            continue;
+        const candidate = path.win32.join(entry, "git.exe");
+        try {
+            await access(candidate, constants.X_OK);
+            const sameInstallation = deriveSameInstallationGitCandidates(candidate);
+            const existing = [];
+            for (const executable of sameInstallation) {
+                try {
+                    await access(executable, constants.X_OK);
+                    existing.push(executable);
+                }
+                catch {
+                    // Optional same-installation fallback is absent.
+                }
+            }
+            if (existing.length > 0)
+                return existing;
+        }
+        catch {
+            // Keep searching PATH entries.
+        }
+    }
+    return ["git"];
+}
 export async function readGitStatusPorcelain(cwd, options = {}) {
-    const attempts = Math.max(1, options.attempts ?? 5);
-    const retryDelayMs = Math.max(0, options.retryDelayMs ?? 150);
-    let lastError;
-    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    return readGitStatusPorcelainWithDependencies(cwd, options, {
+        platform: process.platform,
+        resolveExecutableCandidates: () => resolveGitExecutableCandidates(process.platform, process.env),
+        runAttempt: readGitStatusPorcelainOnce,
+        sleep: async (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)),
+        now: Date.now,
+        env: process.env,
+    });
+}
+export async function readGitStatusPorcelainWithDependencies(cwd, options, dependencies) {
+    const candidates = await dependencies.resolveExecutableCandidates();
+    const executableCandidates = candidates.length > 0 ? candidates : ["git"];
+    const normalMaxAttempts = Math.max(1, options.attempts ?? 5);
+    const transientMaxAttempts = Math.max(1, options.attempts ?? 10);
+    const normalRetryBaseMs = Math.max(0, options.retryDelayMs ?? 150);
+    const transientRetryBaseMs = Math.max(0, options.retryDelayMs ?? 250);
+    const attemptDiagnostics = [];
+    for (let attempt = 1; attempt <= transientMaxAttempts; attempt += 1) {
+        const executable = executableCandidates[(attempt - 1) % executableCandidates.length];
+        const startedAt = dependencies.now();
         try {
-            return await readGitStatusPorcelainOnce(cwd);
+            return await dependencies.runAttempt(cwd, executable);
         }
         catch (error) {
-            lastError = error;
-            if (attempt < attempts && retryDelayMs > 0) {
-                await new Promise((resolve) => setTimeout(resolve, retryDelayMs * attempt));
-            }
+            const exitCode = errorExitCode(error);
+            const transient = isWindowsDllInitializationFailure(dependencies.platform, exitCode);
+            attemptDiagnostics.push({
+                attempt,
+                executable,
+                ...(exitCode === undefined ? {} : { exitCode }),
+                ...(formatWindowsExitCode(exitCode)
+                    ? { exitCodeHex: formatWindowsExitCode(exitCode) }
+                    : {}),
+                signal: errorSignal(error),
+                durationMs: Math.max(0, dependencies.now() - startedAt),
+                ...(transient
+                    ? { transientKind: "windows-dll-init-failed" }
+                    : {}),
+                detail: boundedErrorDetail(error),
+            });
+            const maxAttempts = transient ? transientMaxAttempts : normalMaxAttempts;
+            if (attempt >= maxAttempts)
+                break;
+            const delayMs = transient
+                ? Math.min(4000, transientRetryBaseMs * 2 ** (attempt - 1))
+                : normalRetryBaseMs * attempt;
+            if (delayMs > 0)
+                await dependencies.sleep(delayMs);
         }
     }
-    const detail = lastError instanceof Error ? lastError.message : String(lastError);
-    const exitCode = lastError instanceof Error &&
-        "exitCode" in lastError &&
-        typeof lastError.exitCode === "number"
-        ? String(lastError.exitCode)
-        : "unavailable";
-    const signal = lastError instanceof Error &&
-        "signal" in lastError &&
-        typeof lastError.signal === "string"
-        ? lastError.signal
-        : "unavailable";
-    throw new Error(`git status failed after ${attempts} attempts (exit code=${exitCode}, signal=${signal}, cwd=${path.resolve(cwd)}): ${detail}`, { cause: lastError });
+    throw new GitStatusUnavailableError({
+        cwd,
+        phase: options.phase,
+        platform: dependencies.platform,
+        executableCandidates,
+        requiredWindowsEnvironment: requiredWindowsEnvironment(dependencies.env ?? process.env),
+        attempts: attemptDiagnostics,
+    });
 }
-function readGitStatusPorcelainOnce(cwd) {
+function readGitStatusPorcelainOnce(cwd, executable) {
     return new Promise((resolve, reject) => {
-        const child = spawn("git", ["status", "--porcelain=v1", "--untracked-files=all"], {
+        const child = spawn(executable, ["status", "--porcelain=v1", "--untracked-files=all"], {
             cwd,
             env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
             stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
         });
         let stdout = "";
         let stderr = "";

package/dist/sidecars/cursor-prompt/executor.js

@@ -29,7 +29,7 @@ export function resolveArtifactWriteDir(options) {
 }
 export function buildArtifactPathPrompt(writeDir) {
     if (!writeDir)
-        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
+        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
 ${ARTIFACT_INSTRUCTIONS}`;
     return [
         `After changes, write the following files:`,

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

@@ -0,0 +1,215 @@
+import { TASK_CONTRACT_DRAFT_SCHEMA_VERSION } from "../contract/constants.js";
+import { taskKindSchema } from "../config-types.js";
+import { assessPreparePaths, mergeForbiddenPaths, normalizePreparePath, dedupeStable, } from "./path-policy.js";
+function trimNonEmpty(value) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function cleanStringList(values) {
+    if (values === undefined)
+        return undefined;
+    return values.map((v) => v.trim()).filter(Boolean);
+}
+function resolveTaskKind(flags, baseDraft, existing) {
+    const candidate = flags.taskKind ?? baseDraft?.taskKind ?? existing?.taskKind ?? "standard";
+    const parsed = taskKindSchema.safeParse(candidate);
+    return parsed.success ? parsed.data : String(candidate);
+}
+function resolveTitle(taskId, flags, facts, baseDraft, existing) {
+    return (trimNonEmpty(flags.title) ??
+        trimNonEmpty(baseDraft?.title) ??
+        trimNonEmpty(facts?.title) ??
+        trimNonEmpty(existing?.title) ??
+        taskId);
+}
+function resolveObjective(flags, facts, baseDraft, title) {
+    return (trimNonEmpty(flags.objective) ??
+        trimNonEmpty(baseDraft?.requirement.objective) ??
+        trimNonEmpty(facts?.objective) ??
+        title);
+}
+function resolveStringArrayField(input) {
+    if (input.explicit !== undefined) {
+        return cleanStringList(input.explicit) ?? [];
+    }
+    if (input.base && input.base.length > 0)
+        return [...input.base];
+    if (input.facts && input.facts.length > 0)
+        return [...input.facts];
+    return [];
+}
+function resolveAcceptance(input) {
+    if (input.explicit !== undefined) {
+        return input.explicit
+            .map((item) => ({ id: item.id.trim(), text: item.text.trim() }))
+            .filter((item) => item.id && item.text);
+    }
+    if (input.base && input.base.length > 0)
+        return [...input.base];
+    if (input.facts && input.facts.length > 0)
+        return [...input.facts];
+    return [];
+}
+function resolveAllowedPaths(input) {
+    const source = input.flags.allowedPaths !== undefined
+        ? (cleanStringList(input.flags.allowedPaths) ?? [])
+        : input.baseDraft?.constraints.allowedPaths?.length
+            ? [...input.baseDraft.constraints.allowedPaths]
+            : input.existing?.allowedPaths?.length
+                ? [...input.existing.allowedPaths]
+                : [];
+    return source.map((raw) => {
+        const n = normalizePreparePath(raw);
+        return n.ok ? n.value : raw.trim();
+    });
+}
+function resolveVerifyCommands(input) {
+    if (input.flags.verifyCommands !== undefined) {
+        return input.flags.verifyCommands.map((cmd) => ({
+            label: cmd.label.trim(),
+            command: cmd.command.trim(),
+            ...(cmd.timeoutMs !== undefined ? { timeoutMs: cmd.timeoutMs } : {}),
+        }));
+    }
+    if (input.baseDraft?.verification.commands?.length) {
+        return input.baseDraft.verification.commands.map((cmd) => ({
+            label: cmd.label,
+            command: cmd.command,
+            ...(cmd.timeoutMs !== undefined ? { timeoutMs: cmd.timeoutMs } : {}),
+        }));
+    }
+    if (input.existing?.verifyCommands?.length) {
+        return input.existing.verifyCommands.map((cmd) => ({
+            label: cmd.label,
+            command: cmd.command,
+            ...(cmd.timeoutMs !== undefined ? { timeoutMs: cmd.timeoutMs } : {}),
+        }));
+    }
+    return [];
+}
+/**
+ * Build a thin TaskContractDraftV1 from draft base / PRD facts / flags / task config.
+ * Engineering fields never come from PRD facts.
+ */
+export function buildPrepareDraft(input) {
+    const { taskId, existingTaskConfig, baseDraft, facts, flags, references } = input;
+    const title = resolveTitle(taskId, flags, facts, baseDraft, existingTaskConfig);
+    const taskKind = resolveTaskKind(flags, baseDraft, existingTaskConfig);
+    const featureId = trimNonEmpty(flags.featureId) ??
+        trimNonEmpty(baseDraft?.featureId) ??
+        trimNonEmpty(existingTaskConfig?.featureId) ??
+        undefined;
+    const objective = resolveObjective(flags, facts, baseDraft, title);
+    const scope = resolveStringArrayField({
+        explicit: flags.scope,
+        base: baseDraft?.requirement.scope,
+        facts: facts?.scope,
+    });
+    const nonGoals = resolveStringArrayField({
+        explicit: flags.nonGoals,
+        base: baseDraft?.requirement.nonGoals,
+        facts: facts?.nonGoals,
+    });
+    const acceptanceCriteria = resolveAcceptance({
+        explicit: flags.acceptanceCriteria,
+        base: baseDraft?.requirement.acceptanceCriteria,
+        facts: facts?.acceptanceCriteria,
+    });
+    const allowedPaths = resolveAllowedPaths({
+        flags,
+        baseDraft,
+        existing: existingTaskConfig,
+    });
+    // D12: protected defaults always merge unless explicitly disabled.
+    // Explicit --forbidden-path appends; does not replace defaults.
+    const finalForbidden = mergeForbiddenPaths({
+        existing: baseDraft?.constraints.forbiddenPaths ??
+            existingTaskConfig?.forbiddenPaths ??
+            [],
+        explicit: flags.forbiddenPaths,
+        noDefaultForbiddenPaths: flags.noDefaultForbiddenPaths,
+    });
+    const invariants = resolveStringArrayField({
+        explicit: flags.invariants,
+        base: baseDraft?.constraints.invariants,
+        facts: facts?.invariants,
+    });
+    const openQuestions = resolveStringArrayField({
+        explicit: flags.openQuestions,
+        base: baseDraft?.openQuestions,
+        facts: facts?.openQuestions,
+    });
+    const assumptions = resolveStringArrayField({
+        explicit: flags.assumptions,
+        base: baseDraft?.assumptions,
+        facts: facts?.assumptions,
+    });
+    const verifyCommands = resolveVerifyCommands({
+        flags,
+        baseDraft,
+        existing: existingTaskConfig,
+    });
+    const pathAssessment = assessPreparePaths({
+        allowedPaths,
+        forbiddenPaths: finalForbidden,
+        noDefaultForbiddenPaths: flags.noDefaultForbiddenPaths,
+    });
+    const draft = {
+        schemaVersion: TASK_CONTRACT_DRAFT_SCHEMA_VERSION,
+        taskId,
+        title,
+        taskKind: taskKind,
+        requirement: {
+            objective,
+            scope,
+            nonGoals,
+            acceptanceCriteria,
+        },
+        constraints: {
+            invariants,
+            allowedPaths: pathAssessment.allowed.length > 0
+                ? pathAssessment.allowed
+                : dedupeStable(allowedPaths),
+            forbiddenPaths: pathAssessment.forbidden.length > 0
+                ? pathAssessment.forbidden
+                : dedupeStable(finalForbidden),
+        },
+        verification: {
+            commands: verifyCommands
+                .filter((cmd) => cmd.label && cmd.command)
+                .map((cmd) => ({
+                label: cmd.label,
+                command: cmd.command,
+                ...(cmd.timeoutMs !== undefined ? { timeoutMs: cmd.timeoutMs } : {}),
+            })),
+        },
+    };
+    if (featureId)
+        draft.featureId = featureId;
+    if (references && references.length > 0) {
+        draft.references = references.map((ref) => ({
+            role: ref.role,
+            ref: ref.ref,
+        }));
+    }
+    else if (baseDraft?.references?.length) {
+        draft.references = [...baseDraft.references];
+    }
+    if (openQuestions.length > 0)
+        draft.openQuestions = openQuestions;
+    if (assumptions.length > 0)
+        draft.assumptions = assumptions;
+    if (baseDraft?.sourceResolutions?.length) {
+        draft.sourceResolutions = [...baseDraft.sourceResolutions];
+    }
+    if (baseDraft?.hardConstraints?.length && invariants.length === 0) {
+        draft.hardConstraints = [...baseDraft.hardConstraints];
+    }
+    return {
+        draft,
+        pathAssessment,
+        acceptanceConflicts: facts?.acceptanceConflicts ?? [],
+    };
+}

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

@@ -0,0 +1,195 @@
+const FRESH_SOURCE_MISSING_CODES = new Set([
+    "MISSING_REQUIREMENT",
+    "MISSING_CONSTRAINTS",
+]);
+export function isFreshLegacyUnversioned(state, sourceFilesPresent) {
+    if (state.effectiveStatus !== "legacy-unversioned")
+        return false;
+    if (state.observationErrors.some((e) => e.code === "NOT_FOUND"))
+        return false;
+    // Fresh new-task: both source files missing/empty. Any non-empty source is dirty.
+    if (sourceFilesPresent &&
+        (sourceFilesPresent.requirement || sourceFilesPresent.constraints)) {
+        return false;
+    }
+    const codes = state.observationErrors.map((e) => e.code);
+    // Allow empty errors only when caller already proved both files are empty.
+    if (codes.length === 0) {
+        return Boolean(sourceFilesPresent);
+    }
+    return codes.every((code) => FRESH_SOURCE_MISSING_CODES.has(code));
+}
+export function observationBlocksPrepare(state) {
+    if (state.observationErrors.some((e) => e.code === "NOT_FOUND")) {
+        return {
+            code: "TASK_NOT_FOUND",
+            level: "blocking",
+            message: "task not found",
+        };
+    }
+    if (state.effectiveStatus === "transaction-incomplete") {
+        return {
+            code: "TRANSACTION_INCOMPLETE",
+            level: "blocking",
+            message: "unfinished contract transaction; run task contract recover before prepare",
+        };
+    }
+    const disallowed = state.observationErrors.filter((e) => !FRESH_SOURCE_MISSING_CODES.has(e.code));
+    // EXTERNALLY_MODIFIED alone is the dirty-source signal handled by C6.
+    // Any other observation code (e.g. MANIFEST_MISSING, OBSERVE_FAILED,
+    // INVALID_CONTRACT_JSON) is independently blocking; force cannot bypass it.
+    const hard = disallowed.filter((e) => e.code !== "EXTERNALLY_MODIFIED");
+    if (hard.length > 0) {
+        return {
+            code: "OBSERVATION_ERROR",
+            level: "blocking",
+            message: hard.map((e) => e.message).join("; "),
+        };
+    }
+    return null;
+}
+export function listPrepareGaps(input) {
+    const gaps = [];
+    const risks = [];
+    const { draft } = input;
+    const obs = observationBlocksPrepare(input.state);
+    if (obs)
+        gaps.push(obs);
+    if (!draft.requirement.objective?.trim()) {
+        gaps.push({
+            code: "EMPTY_OBJECTIVE",
+            level: "blocking",
+            field: "objective",
+            message: "requirement.objective is required",
+        });
+    }
+    if (draft.requirement.acceptanceCriteria.length === 0) {
+        gaps.push({
+            code: "EMPTY_ACCEPTANCE",
+            level: "blocking",
+            field: "acceptanceCriteria",
+            message: "at least one acceptance criterion is required",
+        });
+    }
+    if (input.acceptanceConflicts && input.acceptanceConflicts.length > 0) {
+        for (const conflict of input.acceptanceConflicts) {
+            gaps.push({
+                code: "ACCEPTANCE_ID_CONFLICT",
+                level: "blocking",
+                field: "acceptanceCriteria",
+                message: `acceptance criterion id ${conflict.id} has conflicting texts`,
+            });
+        }
+    }
+    if (draft.constraints.allowedPaths.length === 0) {
+        gaps.push({
+            code: "EMPTY_ALLOWED_PATHS",
+            level: "blocking",
+            field: "allowedPaths",
+            message: "allowedPaths must be non-empty before apply",
+        });
+    }
+    if (!draft.taskKind?.trim()) {
+        gaps.push({
+            code: "EMPTY_TASK_KIND",
+            level: "blocking",
+            field: "taskKind",
+            message: "taskKind is required",
+        });
+    }
+    if (draft.taskKind === "knowledge-sync" && !draft.featureId) {
+        gaps.push({
+            code: "MISSING_FEATURE_ID",
+            level: "blocking",
+            field: "featureId",
+            message: "featureId is required when taskKind is knowledge-sync",
+        });
+    }
+    if (draft.requirement.scope.length === 0) {
+        gaps.push({
+            code: "EMPTY_SCOPE",
+            level: "warning",
+            field: "scope",
+            message: "scope is empty; projection will show (none)",
+        });
+    }
+    if (draft.requirement.nonGoals.length === 0) {
+        gaps.push({
+            code: "EMPTY_NON_GOALS",
+            level: "warning",
+            field: "nonGoals",
+            message: "nonGoals is empty; projection will show (none)",
+        });
+    }
+    if (draft.verification.commands.length === 0) {
+        gaps.push({
+            code: "EMPTY_VERIFY",
+            level: "warning",
+            field: "verifyCommands",
+            message: "verifyCommands is empty",
+        });
+    }
+    if (input.sourceIntegrity) {
+        for (const issue of input.sourceIntegrity.issues) {
+            if (issue.level === "blocking") {
+                gaps.push({
+                    code: issue.code,
+                    level: "blocking",
+                    message: issue.message,
+                    field: issue.path,
+                });
+            }
+            else {
+                gaps.push({
+                    code: issue.code,
+                    level: "warning",
+                    message: issue.message,
+                    field: issue.path,
+                });
+            }
+        }
+    }
+    if (input.pathAssessment) {
+        risks.push(...input.pathAssessment.blocking, ...input.pathAssessment.elevated, ...input.pathAssessment.warnings);
+        for (const risk of input.pathAssessment.blocking) {
+            gaps.push({
+                code: risk.code,
+                level: "blocking",
+                message: risk.message,
+                field: risk.path,
+            });
+        }
+    }
+    // Dirty source gate (C6 / D14)
+    const status = input.state.effectiveStatus;
+    const hasExistingSource = Boolean(input.sourceFilesPresent?.requirement ||
+        input.sourceFilesPresent?.constraints);
+    const hasDirtySource = status === "externally-modified" ||
+        (status === "legacy-unversioned" && hasExistingSource);
+    if (hasDirtySource && !input.forceOverwriteSource) {
+        gaps.push({
+            code: "DIRTY_SOURCE",
+            level: "blocking",
+            message: "existing non-empty or externally-modified source refuses --apply; use show/diff/adopt/recover or --force-overwrite-source",
+        });
+        risks.push({
+            code: "DIRTY_SOURCE",
+            level: "blocking",
+            message: "source is dirty/externally-modified; prepare will not overwrite without --force-overwrite-source",
+        });
+    }
+    if (!input.hasImportedPrd) {
+        gaps.push({
+            code: "NO_IMPORTED_PRD",
+            level: "warning",
+            message: "no imported PRD in use; prefer detailed PRD → import-prd → prepare (escape hatch only)",
+        });
+    }
+    return { gaps, risks };
+}
+export function hasBlockingGaps(gaps) {
+    return gaps.some((gap) => gap.level === "blocking");
+}
+export function hasBlockingRisks(risks) {
+    return risks.some((risk) => risk.level === "blocking");
+}

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

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export * from "./path-policy.js";
+export * from "./parse-intent.js";
+export * from "./reference-integrity.js";
+export * from "./completeness.js";
+export * from "./build-draft.js";
+export * from "./prepare.js";