@tea-agent/loop-agent 0.25.6 → 0.26.1

package/dist/executors/model-routing.js

@@ -1,4 +1,5 @@
-import { DEFAULT_DAG_EXECUTOR_MODELS, } from '../workflows/dag/types.js';
+import { DEFAULT_DAG_EXECUTOR_MODELS, } from "../workflows/dag/types.js";
+import { normalizeExecutorTierValue, } from "../governance/manifest-types.js";
 export const DEFAULT_DAG_MODELS = {
     HIGH: "gpt-5.5",
     MED: "gpt-5.5",
@@ -8,6 +9,16 @@ export const DEFAULT_DAG_MODELS = {
  * DAG executor model tier keys that may carry a per-complexity override.
  */
 const EXECUTOR_MODEL_TIERS = ["LOW", "MED", "HIGH"];
+/** Resolve one tier to a model and optional explicit thinking override. */
+export function resolveExecutorTierSelection(execConfig, tier) {
+    const tierSelection = normalizeExecutorTierValue(execConfig?.[tier]);
+    if (tierSelection)
+        return tierSelection;
+    const defaultModel = execConfig?.defaultModel;
+    if (defaultModel && defaultModel !== "default")
+        return { model: defaultModel };
+    return { model: DEFAULT_DAG_EXECUTOR_MODELS.pi[tier] };
+}
 /**
  * Resolve the DAG executor model matrix for Pi from harness `executors.pi`.
  *
@@ -19,22 +30,23 @@ const EXECUTOR_MODEL_TIERS = ["LOW", "MED", "HIGH"];
  * The "default" literal (injected by the schema `.default("default")`) and
  * absent/undefined both mean "no override, fall through".
  */
-export function resolveExecutorModelMatrix(executor, execConfig) {
-    const tierValue = (tier) => {
-        const tierOverride = execConfig?.[tier];
-        if (tierOverride && tierOverride !== "default")
-            return tierOverride;
-        const defaultModel = execConfig?.defaultModel;
-        if (defaultModel && defaultModel !== "default")
-            return defaultModel;
-        return DEFAULT_DAG_EXECUTOR_MODELS[executor][tier];
-    };
+export function resolveExecutorModelMatrix(_executor, execConfig) {
     return {
-        LOW: tierValue("LOW"),
-        MED: tierValue("MED"),
-        HIGH: tierValue("HIGH"),
+        LOW: resolveExecutorTierSelection(execConfig, "LOW").model,
+        MED: resolveExecutorTierSelection(execConfig, "MED").model,
+        HIGH: resolveExecutorTierSelection(execConfig, "HIGH").model,
     };
 }
+/** Resolve only explicitly configured per-tier thinking values. */
+export function resolveExecutorThinkingMatrix(execConfig) {
+    const result = {};
+    for (const tier of EXECUTOR_MODEL_TIERS) {
+        const selection = normalizeExecutorTierValue(execConfig?.[tier]);
+        if (selection?.thinking)
+            result[tier] = selection.thinking;
+    }
+    return result;
+}
 /**
  * Resolve the Pi DAG executor model matrix from a harness manifest.
  */
@@ -55,7 +67,9 @@ export function resolveModelSelection(manifest, taskConfig, step, options) {
         };
     }
     const profileName = resolveProfileName(manifest, taskConfig.complexity, step, retryAttempt);
-    const profile = profileName ? manifest.modelProfiles?.[profileName] : undefined;
+    const profile = profileName
+        ? manifest.modelProfiles?.[profileName]
+        : undefined;
     if (!profile) {
         return {
             modelConfig: manifest.models?.[step],
@@ -74,7 +88,9 @@ export function resolveModelSelection(manifest, taskConfig, step, options) {
     };
 }
 function resolveProfileName(manifest, complexity, step, retryAttempt) {
-    if (step === 'implement' && retryAttempt > 0 && manifest.modelRouting?.implementRetry) {
+    if (step === "implement" &&
+        retryAttempt > 0 &&
+        manifest.modelRouting?.implementRetry) {
         return manifest.modelRouting.implementRetry;
     }
     const route = manifest.modelRouting?.[step];
@@ -85,11 +101,11 @@ function resolveProfileName(manifest, complexity, step, retryAttempt) {
 }
 export function formatModelSelectionLabel(modelConfig, profileName) {
     if (!modelConfig) {
-        return profileName ? `${profileName}` : 'default';
+        return profileName ? `${profileName}` : "default";
     }
     const base = modelConfig.provider && modelConfig.model
         ? `${modelConfig.provider}/${modelConfig.model}`
-        : modelConfig.model ?? 'default';
+        : (modelConfig.model ?? "default");
     return profileName ? `${profileName}:${base}` : base;
 }
 export function formatFallbackLabel(profile) {

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/governance/manifest-types.js

@@ -18,6 +18,34 @@ export const worktreeManifestConfigSchema = z.object({
 });
 export const taskExecutorSchema = z.enum(["pi"]);
 export const CURSOR_TASK_EXECUTOR_REMOVED_ERROR = 'task executor "cursor" is no longer supported; governed runtime is Pi-only';
+/** Per-tier model override: bare model id string, or `{ model, thinking? }`. */
+export const executorTierModelSchema = z.union([
+    z.string(),
+    z.object({
+        model: z.string().min(1),
+        thinking: z.string().optional(),
+    }),
+]);
+/** Normalize an executors.pi LOW|MED|HIGH value. */
+export function normalizeExecutorTierValue(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (typeof value === "string") {
+        if (value === "default" || value.length === 0)
+            return undefined;
+        return { model: value };
+    }
+    if (typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const model = value.model;
+    if (typeof model !== "string" || model.length === 0 || model === "default") {
+        return undefined;
+    }
+    const thinking = value.thinking;
+    return typeof thinking === "string" && thinking.length > 0
+        ? { model, thinking }
+        : { model };
+}
 export const executorManifestSchema = z.object({
     description: z.string().optional(),
     enabled: z.boolean().optional(),
@@ -27,9 +55,9 @@ export const executorManifestSchema = z.object({
      * these take priority over defaultModel for the matching DAG executor tier.
      * "default" literal and absent/undefined both mean "no override, fall through".
      */
-    LOW: z.string().optional(),
-    MED: z.string().optional(),
-    HIGH: z.string().optional(),
+    LOW: executorTierModelSchema.optional(),
+    MED: executorTierModelSchema.optional(),
+    HIGH: executorTierModelSchema.optional(),
     requiresApiKey: z.string().optional(),
 });
 export const workflowPolicyProfileNameSchema = z.enum([
@@ -98,7 +126,7 @@ export const workflowPolicySchema = z
 })
     .optional()
     .default({});
-export const CURSOR_HARNESS_EXECUTOR_REMOVED_ERROR = 'harness executors.cursor is no longer supported; remove it and use executors.pi only (Cursor is available only via cursor-prompt sidecar)';
+export const CURSOR_HARNESS_EXECUTOR_REMOVED_ERROR = "harness executors.cursor is no longer supported; remove it and use executors.pi only (Cursor is available only via cursor-prompt sidecar)";
 export const harnessManifestSchema = z
     .object({
     version: z.number(),
@@ -160,7 +188,7 @@ export const harnessManifestSchema = z
     if ("cursorExecutorUsage" in entrypoints) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: 'entrypoints.cursorExecutorUsage is no longer supported; remove it (Cursor is cursor-prompt sidecar only)',
+            message: "entrypoints.cursorExecutorUsage is no longer supported; remove it (Cursor is cursor-prompt sidecar only)",
             path: ["entrypoints", "cursorExecutorUsage"],
         });
     }

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 ?? [],
+    };
+}