@martinloop/mcp 0.7.1 → 0.8.0

package/dist/vendor/contracts/swarm.js

@@ -0,0 +1,550 @@
+import { createHash } from "node:crypto";
+import { FAILURE_CLASSES } from "./index.js";
+export const SWARM_SCHEMA_VERSION = "martin.swarm.v1";
+export const SWARM_EVENT_TYPES = [
+    "SWARM_CREATED",
+    "SWARM_PLAN_CREATED",
+    "SWARM_PLAN_APPROVED",
+    "TASK_READY",
+    "TASK_ASSIGNED",
+    "CHILD_STARTED",
+    "CHILD_PROGRESS",
+    "CHILD_VERIFIER_STARTED",
+    "CHILD_VERIFIED",
+    "CHILD_STOPPED",
+    "CHILD_NEEDS_REVIEW",
+    "CHILD_PATCH_PROPOSED",
+    "CHILD_PATCH_REJECTED",
+    "CHILD_PATCH_ADMITTED",
+    "ACTION_BLOCKED",
+    "TASK_REASSIGNED",
+    "DEPENDENCY_SATISFIED",
+    "INTEGRATION_STARTED",
+    "INTEGRATION_CONFLICT",
+    "INTEGRATION_COMPLETED",
+    "GLOBAL_VERIFIER_STARTED",
+    "GLOBAL_VERIFIER_PASSED",
+    "GLOBAL_VERIFIER_FAILED",
+    "SWARM_CANCEL_REQUESTED",
+    "SWARM_STOPPED",
+    "SWARM_NEEDS_REVIEW",
+    "SWARM_VERIFIED"
+];
+export const SWARM_ORCHESTRATION_STRATEGIES = [
+    "hierarchical_dag",
+    "pipeline_dag",
+    "parallel_dag",
+    "hybrid"
+];
+export const SWARM_LIVE_ENGINES = ["claude", "codex", "gemini", "openai"];
+export const SWARM_PARENT_RECEIPT_SCHEMA_VERSION = "martin.swarm-receipt.v1";
+export function validateSwarmChildReceiptLink(value) {
+    const errors = [];
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        addError(errors, "INVALID_SWARM_CHILD_RECEIPT_LINK", "swarmChild", "must be an object");
+        return { ok: false, errors };
+    }
+    const link = value;
+    requireText(link.parentSwarmId, "parentSwarmId", errors);
+    requireText(link.agentId, "agentId", errors);
+    requireText(link.attemptId, "attemptId", errors);
+    if (!Array.isArray(link.taskIds) || link.taskIds.length === 0) {
+        addError(errors, "EMPTY_SWARM_CHILD_TASKS", "taskIds", "at least one task ID is required");
+    }
+    else {
+        link.taskIds.forEach((taskId, index) => requireText(taskId, `taskIds[${index}]`, errors));
+        addDuplicateErrors(link.taskIds, "DUPLICATE_SWARM_CHILD_TASK_ID", "taskIds", errors);
+    }
+    return errors.length === 0 ? { ok: true, errors: [] } : { ok: false, errors };
+}
+export function createSwarmLivePlan(draft) {
+    const planWithoutHash = {
+        ...cloneLivePlanDraft(draft),
+        schemaVersion: SWARM_SCHEMA_VERSION
+    };
+    return {
+        ...planWithoutHash,
+        planHash: computeSwarmLivePlanHash(planWithoutHash)
+    };
+}
+export function computeSwarmLivePlanHash(plan) {
+    const { planHash: _ignored, ...hashInput } = plan;
+    return createHash("sha256").update(canonicalJson(hashInput)).digest("hex");
+}
+export function validateSwarmLiveRevision(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+export function validateSwarmLivePlan(plan) {
+    const errors = [];
+    if (plan.schemaVersion !== SWARM_SCHEMA_VERSION) {
+        addError(errors, "UNKNOWN_SCHEMA_VERSION", "schemaVersion", "unknown swarm schema version");
+    }
+    for (const key of ["planId", "swarmId", "workspaceId", "projectId"]) {
+        requireText(plan[key], key, errors);
+    }
+    if (!/^[0-9a-f]{40,64}$/iu.test(plan.baselineCommit)) {
+        addError(errors, "INVALID_BASELINE_COMMIT", "baselineCommit", "must be an immutable 40-64 character Git object id");
+    }
+    if (!SWARM_LIVE_ENGINES.includes(plan.engine.engine)) {
+        addError(errors, "INVALID_LIVE_ENGINE", "engine.engine", "must select exactly one concrete live engine");
+    }
+    requireText(plan.engine.model, "engine.model", errors);
+    if (!isPositiveInteger(plan.childMaxIterations)) {
+        addError(errors, "INVALID_CHILD_ITERATION_LIMIT", "childMaxIterations", "must be a positive integer");
+    }
+    if (!isCanonicalIsoDate(plan.createdAt)) {
+        addError(errors, "INVALID_CREATED_AT", "createdAt", "must be a canonical ISO timestamp");
+    }
+    errors.push(...validateSwarmParentContract(plan.parentContract).errors);
+    if (plan.tasks.length === 0) {
+        addError(errors, "EMPTY_TASK_GRAPH", "tasks", "at least one task is required");
+    }
+    if (plan.agents.length === 0) {
+        addError(errors, "EMPTY_AGENT_POOL", "agents", "at least one agent is required");
+    }
+    addDuplicateErrors(plan.tasks.map((task) => task.taskId), "DUPLICATE_TASK_ID", "tasks", errors);
+    addDuplicateErrors(plan.agents.map((agent) => agent.agentId), "DUPLICATE_AGENT_ID", "agents", errors);
+    const taskIds = new Set(plan.tasks.map((task) => task.taskId));
+    const agentIds = new Set(plan.agents.map((agent) => agent.agentId));
+    plan.tasks.forEach((task, index) => {
+        requireText(task.taskId, `tasks[${index}].taskId`, errors);
+        if (!hasText(task.assignedAgentId)) {
+            addError(errors, "MISSING_TASK_AGENT", `tasks[${index}].assignedAgentId`, "every task must have one assigned agent");
+        }
+        if (task.dependsOn.some((dependency) => !taskIds.has(dependency))) {
+            addError(errors, "UNKNOWN_TASK_DEPENDENCY", `tasks[${index}].dependsOn`, "every dependency must name a plan task");
+        }
+        if (task.assignedAgentId !== undefined && !agentIds.has(task.assignedAgentId)) {
+            addError(errors, "UNKNOWN_TASK_AGENT", `tasks[${index}].assignedAgentId`, "assigned agent must be present in the plan");
+        }
+        const assignedAgent = plan.agents.find((agent) => agent.agentId === task.assignedAgentId);
+        if (assignedAgent && !assignedAgent.contract.taskIds.includes(task.taskId)) {
+            addError(errors, "TASK_ASSIGNMENT_NOT_COVERED", `tasks[${index}].assignedAgentId`, "assigned agent contract must include the exact task");
+        }
+    });
+    plan.agents.forEach((agent, index) => {
+        const child = validateSwarmChildContract(plan.parentContract, agent.contract);
+        errors.push(...child.errors.map((error) => ({ ...error, path: `agents[${index}].contract.${error.path}` })));
+        if (agent.contract.taskIds.some((taskId) => !taskIds.has(taskId))) {
+            addError(errors, "UNKNOWN_CHILD_TASK", `agents[${index}].contract.taskIds`, "every child task must be present in the plan");
+        }
+    });
+    if (!/^[0-9a-f]{64}$/u.test(plan.planHash) || computeSwarmLivePlanHash(plan) !== plan.planHash) {
+        addError(errors, "LIVE_PLAN_HASH_MISMATCH", "planHash", "plan hash must bind the complete canonical live plan");
+    }
+    return validationResult(errors);
+}
+export function validateSwarmLiveEvent(event, plan) {
+    const errors = [];
+    if (event.schemaVersion !== SWARM_SCHEMA_VERSION) {
+        addError(errors, "UNKNOWN_SCHEMA_VERSION", "schemaVersion", "unknown swarm schema version");
+    }
+    if (!Number.isSafeInteger(event.sequence) || event.sequence <= 0) {
+        addError(errors, "INVALID_EVENT_SEQUENCE", "sequence", "must be a positive safe integer");
+    }
+    requireText(event.idempotencyKey, "idempotencyKey", errors);
+    if (!SWARM_EVENT_TYPES.includes(event.type)) {
+        addError(errors, "INVALID_EVENT_TYPE", "type", "must use a canonical swarm event type");
+    }
+    if (event.swarmId !== plan.swarmId) {
+        addError(errors, "EVENT_SWARM_MISMATCH", "swarmId", "must match the live plan");
+    }
+    if (event.parentPolicyVersion !== plan.parentContract.policyVersion) {
+        addError(errors, "EVENT_POLICY_MISMATCH", "parentPolicyVersion", "must match the live plan");
+    }
+    if (event.planHash !== plan.planHash) {
+        addError(errors, "EVENT_PLAN_HASH_MISMATCH", "planHash", "must match the approved live plan hash");
+    }
+    if (!isCanonicalIsoDate(event.timestamp)) {
+        addError(errors, "INVALID_EVENT_TIMESTAMP", "timestamp", "must be a canonical ISO timestamp");
+    }
+    if (event.failureClass !== undefined && !FAILURE_CLASSES.includes(event.failureClass)) {
+        addError(errors, "INVALID_FAILURE_CLASS", "failureClass", "must use a canonical MartinLoop failure class");
+    }
+    if (event.payload === null || typeof event.payload !== "object" || Array.isArray(event.payload)) {
+        addError(errors, "INVALID_EVENT_PAYLOAD", "payload", "must be a JSON object");
+    }
+    return validationResult(errors);
+}
+export function validateSwarmConcretePath(value) {
+    if (value.length === 0) {
+        return { ok: false, error: "concrete path must not be empty" };
+    }
+    if (value.includes("\0")) {
+        return { ok: false, error: "concrete path must not contain NUL" };
+    }
+    if (value.includes("\\")) {
+        return { ok: false, error: "concrete path must use repository-relative slash separators" };
+    }
+    if (/^(?:[a-z]:|\/)/iu.test(value)) {
+        return { ok: false, error: "concrete path must be repository-relative" };
+    }
+    if (value !== value.normalize("NFC")) {
+        return { ok: false, error: "concrete path must use Unicode NFC normalization" };
+    }
+    const segments = value.split("/");
+    if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+        return { ok: false, error: "concrete path contains an empty or traversal segment" };
+    }
+    if (segments.some((segment) => segment.toLowerCase() === ".git")) {
+        return { ok: false, error: "concrete path must not enter Git metadata" };
+    }
+    return { ok: true, value: segments.join("/") };
+}
+export function swarmConcretePathMatchesPattern(concretePath, pattern) {
+    const validatedPath = validateSwarmConcretePath(concretePath);
+    const normalizedPattern = normalizeSwarmPathPattern(pattern);
+    if (!validatedPath.ok || !normalizedPattern.ok)
+        return false;
+    return matchConcretePathSegments(validatedPath.value.split("/"), normalizedPattern.value.split("/"), 0, 0, new Map());
+}
+export function normalizeSwarmPathPattern(value) {
+    const candidate = value.trim().replaceAll("\\", "/");
+    if (candidate.length === 0) {
+        return { ok: false, error: "path pattern must not be empty" };
+    }
+    if (/^(?:[a-z]:|\/)/iu.test(candidate)) {
+        return { ok: false, error: "path pattern must be repository-relative" };
+    }
+    const segments = candidate.split("/");
+    if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+        return { ok: false, error: "path pattern contains an empty or traversal segment" };
+    }
+    for (const segment of segments) {
+        if (segment === "*" || segment === "**")
+            continue;
+        if (!/^[a-z0-9._@+-]+$/iu.test(segment)) {
+            return { ok: false, error: `malformed path pattern segment: ${segment}` };
+        }
+    }
+    return { ok: true, value: segments.join("/") };
+}
+export function swarmPathPatternContains(parent, child) {
+    const normalizedParent = normalizeSwarmPathPattern(parent);
+    const normalizedChild = normalizeSwarmPathPattern(child);
+    if (!normalizedParent.ok || !normalizedChild.ok)
+        return false;
+    if (normalizedParent.value === "**" || normalizedParent.value === normalizedChild.value)
+        return true;
+    if (normalizedParent.value.endsWith("/**")) {
+        const prefix = normalizedParent.value.slice(0, -3);
+        return normalizedChild.value === prefix || normalizedChild.value.startsWith(`${prefix}/`);
+    }
+    if (normalizedParent.value.startsWith("**/")) {
+        const suffix = normalizedParent.value.slice(3);
+        return normalizedChild.value === suffix || normalizedChild.value.endsWith(`/${suffix}`);
+    }
+    return false;
+}
+export function swarmPathPatternsOverlap(left, right) {
+    const normalizedLeft = normalizeSwarmPathPattern(left);
+    const normalizedRight = normalizeSwarmPathPattern(right);
+    if (!normalizedLeft.ok || !normalizedRight.ok)
+        return true;
+    if (swarmPathPatternContains(normalizedLeft.value, normalizedRight.value)
+        || swarmPathPatternContains(normalizedRight.value, normalizedLeft.value)) {
+        return true;
+    }
+    const leftPrefix = literalPatternPrefix(normalizedLeft.value);
+    const rightPrefix = literalPatternPrefix(normalizedRight.value);
+    if (leftPrefix.length === 0 || rightPrefix.length === 0)
+        return true;
+    return leftPrefix.startsWith(`${rightPrefix}/`) || rightPrefix.startsWith(`${leftPrefix}/`);
+}
+export function validateSwarmParentContract(parent) {
+    const errors = [];
+    requireText(parent.policyVersion, "policyVersion", errors);
+    requireText(parent.objective, "objective", errors);
+    if (parent.definitionOfDone.length === 0 || parent.definitionOfDone.some((item) => !hasText(item))) {
+        addError(errors, "INVALID_DEFINITION_OF_DONE", "definitionOfDone", "at least one non-empty criterion is required");
+    }
+    validateBudget(parent.budget, "budget", errors);
+    if (!isPositiveInteger(parent.maxConcurrency)) {
+        addError(errors, "INVALID_CONCURRENCY", "maxConcurrency", "must be a positive integer");
+    }
+    if (!isPositiveFinite(parent.maxWallClockMs)) {
+        addError(errors, "INVALID_WALL_CLOCK", "maxWallClockMs", "must be a positive finite number");
+    }
+    if (parent.scope.allowedPaths.length === 0) {
+        addError(errors, "INVALID_SCOPE", "scope.allowedPaths", "at least one non-empty allowed path is required");
+    }
+    validatePathPatterns(parent.scope.allowedPaths, "scope.allowedPaths", errors);
+    validatePathPatterns(parent.scope.deniedPaths, "scope.deniedPaths", errors);
+    if (parent.globalVerifierStack.length === 0) {
+        addError(errors, "INVALID_GLOBAL_VERIFIER", "globalVerifierStack", "at least one global verifier step is required");
+    }
+    if (!SWARM_ORCHESTRATION_STRATEGIES.includes(parent.orchestrationStrategy)) {
+        addError(errors, "INVALID_ORCHESTRATION_STRATEGY", "orchestrationStrategy", "must use a canonical swarm orchestration strategy");
+    }
+    if (!Number.isInteger(parent.recoveryPolicy.maxReassignmentsPerTask) || parent.recoveryPolicy.maxReassignmentsPerTask < 0) {
+        addError(errors, "INVALID_RECOVERY_POLICY", "recoveryPolicy.maxReassignmentsPerTask", "must be a nonnegative integer");
+    }
+    return validationResult(errors);
+}
+export function validateSwarmDeterministicDemoReceiptEvidence(evidence) {
+    const errors = [];
+    if (evidence.evidenceKind !== "deterministic_demo") {
+        addError(errors, "INVALID_DEMO_EVIDENCE_KIND", "evidenceKind", "must identify deterministic demo evidence");
+    }
+    for (const key of ["swarmId", "agentId", "childRunId"]) {
+        requireText(evidence[key], key, errors);
+    }
+    if (!Array.isArray(evidence.taskIds)
+        || evidence.taskIds.length === 0
+        || evidence.taskIds.some((taskId) => !hasText(taskId))
+        || new Set(evidence.taskIds).size !== evidence.taskIds.length) {
+        addError(errors, "INVALID_DEMO_TASK_BINDING", "taskIds", "must contain a non-empty, duplicate-free assigned task set");
+    }
+    if (!["passed", "failed", "unknown"].includes(evidence.referentialBinding)) {
+        addError(errors, "INVALID_DEMO_REFERENTIAL_BINDING", "referentialBinding", "must be passed, failed, or unknown");
+    }
+    if (evidence.signedIntegrity !== "not_evaluated") {
+        addError(errors, "DEMO_SIGNED_INTEGRITY_FORBIDDEN", "signedIntegrity", "deterministic demo evidence does not evaluate signed receipt integrity");
+    }
+    return validationResult(errors);
+}
+export function validateSwarmChildContract(parent, child) {
+    const errors = [];
+    requireText(child.agentId, "agentId", errors);
+    if (child.taskIds.length === 0 || child.taskIds.some((taskId) => !hasText(taskId))) {
+        addError(errors, "INVALID_CHILD_TASKS", "taskIds", "at least one non-empty task identifier is required");
+    }
+    validateBudget(child.budget, "budget", errors);
+    if (child.hardMaxUsd !== undefined && (!isNonnegativeFinite(child.hardMaxUsd) || child.hardMaxUsd > parent.budget.maxUsd)) {
+        addError(errors, "CHILD_HARD_USD_CAP_INVALID", "hardMaxUsd", "child hard USD cap must be finite, nonnegative, and within the parent cap");
+    }
+    if (child.hardMaxTokens !== undefined && (!isPositiveInteger(child.hardMaxTokens)
+        || parent.budget.maxTokens === undefined
+        || child.hardMaxTokens > parent.budget.maxTokens)) {
+        addError(errors, "CHILD_HARD_TOKEN_CAP_INVALID", "hardMaxTokens", "child hard token cap must be positive and within the parent token cap");
+    }
+    validatePathPatterns(child.scope.allowedPaths, "scope.allowedPaths", errors);
+    validatePathPatterns(child.scope.deniedPaths, "scope.deniedPaths", errors);
+    if (child.scope.allowedPaths.some((path) => !parent.scope.allowedPaths.some((allowed) => swarmPathPatternContains(allowed, path)))) {
+        addError(errors, "CHILD_SCOPE_WIDENED", "scope.allowedPaths", "child allowed paths must be contained by parent scope");
+    }
+    if (parent.scope.deniedPaths.some((denied) => !child.scope.deniedPaths.includes(denied))) {
+        addError(errors, "CHILD_DENIAL_DROPPED", "scope.deniedPaths", "child must inherit every parent denied path");
+    }
+    if (budgetWidened(parent.budget, child.budget)) {
+        addError(errors, "CHILD_BUDGET_WIDENED", "budget", "child budget must not exceed parent budget");
+    }
+    if (!isPositiveFinite(child.maxWallClockMs) || child.maxWallClockMs > parent.maxWallClockMs) {
+        addError(errors, "CHILD_WALL_CLOCK_WIDENED", "maxWallClockMs", "child wall-clock cap must not exceed parent cap");
+    }
+    if (!isSubset(child.permissions.networkDomains, parent.permissions.networkDomains)) {
+        addError(errors, "CHILD_NETWORK_WIDENED", "permissions.networkDomains", "child network permissions must be a parent subset");
+    }
+    if (!isSubset(child.permissions.commands, parent.permissions.commands)) {
+        addError(errors, "CHILD_COMMAND_WIDENED", "permissions.commands", "child commands must be a parent subset");
+    }
+    if (approvalWidened(parent.approvalPolicy, child.approvalPolicy)) {
+        addError(errors, "CHILD_APPROVAL_WIDENED", "approvalPolicy", "child approval authority must not exceed parent authority");
+    }
+    if (child.verifierAuthority !== "child_only") {
+        addError(errors, "CHILD_GLOBAL_VERIFIER_FORBIDDEN", "verifierAuthority", "only the parent may hold global verifier authority");
+    }
+    return validationResult(errors);
+}
+export function createSwarmRunRecord(draft, options = {}) {
+    const now = options.now ?? new Date().toISOString();
+    const events = draft.events
+        ? draft.events.map((event) => ({ ...event, payload: { ...event.payload } }))
+        : [{
+                type: "SWARM_CREATED",
+                swarmId: draft.swarmId,
+                timestamp: now,
+                parentPolicyVersion: draft.parentContract.policyVersion,
+                payload: {}
+            }];
+    return {
+        schemaVersion: SWARM_SCHEMA_VERSION,
+        swarmId: draft.swarmId,
+        workspaceId: draft.workspaceId,
+        projectId: draft.projectId,
+        parentContract: cloneParentContract(draft.parentContract),
+        tasks: draft.tasks.map(cloneTask),
+        agents: draft.agents.map(cloneAgent),
+        dependencyWaivers: (draft.dependencyWaivers ?? []).map((waiver) => ({ ...waiver })),
+        budgetLedger: draft.budgetLedger
+            ? cloneBudgetLedger(draft.budgetLedger)
+            : {
+                capUsd: draft.parentContract.budget.maxUsd,
+                settledUsd: 0,
+                settledTokens: 0,
+                leases: [],
+                ...(draft.parentContract.budget.maxTokens !== undefined
+                    ? { capTokens: draft.parentContract.budget.maxTokens }
+                    : {})
+            },
+        conflicts: (draft.conflicts ?? []).map((conflict) => ({ ...conflict, taskIds: [...conflict.taskIds], paths: [...conflict.paths] })),
+        verification: (draft.verification ?? []).map((item) => ({ ...item, steps: item.steps.map((step) => ({ ...step })) })),
+        outcome: { ...(draft.outcome ?? { state: "running", reason: "Swarm execution has not reached a parent terminal decision." }) },
+        events,
+        createdAt: draft.createdAt ?? now,
+        updatedAt: draft.updatedAt ?? now
+    };
+}
+export function validateSwarmRunRecord(record) {
+    const errors = [];
+    requireText(record.swarmId, "swarmId", errors);
+    requireText(record.workspaceId, "workspaceId", errors);
+    requireText(record.projectId, "projectId", errors);
+    errors.push(...validateSwarmParentContract(record.parentContract).errors);
+    addDuplicateErrors(record.tasks.map((task) => task.taskId), "DUPLICATE_TASK_ID", "tasks", errors);
+    addDuplicateErrors(record.agents.map((agent) => agent.agentId), "DUPLICATE_AGENT_ID", "agents", errors);
+    for (const [index, agent] of record.agents.entries()) {
+        const childResult = validateSwarmChildContract(record.parentContract, agent.contract);
+        errors.push(...childResult.errors.map((error) => ({ ...error, path: `agents[${index}].contract.${error.path}` })));
+    }
+    if (record.schemaVersion !== SWARM_SCHEMA_VERSION) {
+        addError(errors, "UNKNOWN_SCHEMA_VERSION", "schemaVersion", "unknown swarm schema version");
+    }
+    return validationResult(errors);
+}
+function cloneParentContract(parent) {
+    return {
+        ...parent,
+        definitionOfDone: [...parent.definitionOfDone],
+        budget: { ...parent.budget },
+        scope: { allowedPaths: [...parent.scope.allowedPaths], deniedPaths: [...parent.scope.deniedPaths] },
+        permissions: { networkDomains: [...parent.permissions.networkDomains], commands: [...parent.permissions.commands] },
+        globalVerifierStack: parent.globalVerifierStack.map((step) => ({ ...step })),
+        stopPolicy: { ...parent.stopPolicy },
+        recoveryPolicy: { ...parent.recoveryPolicy },
+        approvalPolicy: { ...parent.approvalPolicy }
+    };
+}
+function cloneTask(task) {
+    return { ...task, dependsOn: [...task.dependsOn], writeScope: [...task.writeScope] };
+}
+function cloneAgent(agent) {
+    return {
+        ...agent,
+        contract: {
+            ...agent.contract,
+            taskIds: [...agent.contract.taskIds],
+            scope: { allowedPaths: [...agent.contract.scope.allowedPaths], deniedPaths: [...agent.contract.scope.deniedPaths] },
+            budget: { ...agent.contract.budget },
+            permissions: { networkDomains: [...agent.contract.permissions.networkDomains], commands: [...agent.contract.permissions.commands] },
+            approvalPolicy: { ...agent.contract.approvalPolicy }
+        }
+    };
+}
+function cloneLivePlanDraft(draft) {
+    return {
+        ...draft,
+        parentContract: cloneParentContract(draft.parentContract),
+        tasks: draft.tasks.map(cloneTask),
+        agents: draft.agents.map(cloneAgent),
+        engine: { ...draft.engine }
+    };
+}
+function cloneBudgetLedger(ledger) {
+    return { ...ledger, leases: ledger.leases.map((lease) => ({ ...lease, ...(lease.actualUsage ? { actualUsage: { ...lease.actualUsage } } : {}) })) };
+}
+function validateBudget(budget, path, errors) {
+    if (!isNonnegativeFinite(budget.maxUsd) || !isNonnegativeFinite(budget.softLimitUsd) || budget.softLimitUsd > budget.maxUsd || !isPositiveInteger(budget.maxIterations) || (budget.maxTokens !== undefined && !isPositiveInteger(budget.maxTokens))) {
+        addError(errors, "INVALID_BUDGET", path, "budget caps must be finite, nonnegative, ordered, and use positive iteration/token limits");
+    }
+}
+function budgetWidened(parent, child) {
+    return child.maxUsd > parent.maxUsd
+        || child.softLimitUsd > parent.softLimitUsd
+        || child.maxIterations > parent.maxIterations
+        || (parent.maxTokens !== undefined
+            && (child.maxTokens === undefined || child.maxTokens > parent.maxTokens));
+}
+function approvalWidened(parent, child) {
+    const keys = ["dependencyAdds", "migrations", "configChanges", "externalWrites"];
+    return keys.some((key) => child[key] === true && parent[key] !== true);
+}
+function addDuplicateErrors(values, code, path, errors) {
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
+            addError(errors, code, path, `duplicate identifier: ${value}`);
+        }
+        seen.add(value);
+    }
+}
+function isSubset(values, allowed) {
+    return values.every((value) => allowed.includes(value));
+}
+function validationResult(errors) {
+    return errors.length === 0 ? { ok: true, errors: [] } : { ok: false, errors };
+}
+function requireText(value, path, errors) {
+    if (!hasText(value))
+        addError(errors, "REQUIRED_FIELD", path, "non-empty text is required");
+}
+function addError(errors, code, path, message) {
+    errors.push({ code, path, message });
+}
+function hasText(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isNonnegativeFinite(value) {
+    return Number.isFinite(value) && value >= 0;
+}
+function isPositiveFinite(value) {
+    return Number.isFinite(value) && value > 0;
+}
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && value > 0;
+}
+function isCanonicalIsoDate(value) {
+    if (typeof value !== "string")
+        return false;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) && new Date(parsed).toISOString() === value;
+}
+function canonicalJson(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+    const entries = Object.entries(value)
+        .filter(([, item]) => item !== undefined)
+        .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+}
+function validatePathPatterns(patterns, path, errors) {
+    patterns.forEach((pattern, index) => {
+        const result = normalizeSwarmPathPattern(pattern);
+        if (!result.ok) {
+            addError(errors, "INVALID_SCOPE_PATTERN", `${path}[${index}]`, result.error);
+        }
+    });
+}
+function literalPatternPrefix(pattern) {
+    const segments = [];
+    for (const segment of pattern.split("/")) {
+        if (segment === "*" || segment === "**")
+            break;
+        segments.push(segment);
+    }
+    return segments.join("/");
+}
+function matchConcretePathSegments(pathSegments, patternSegments, pathIndex, patternIndex, memo) {
+    const key = `${pathIndex}:${patternIndex}`;
+    const cached = memo.get(key);
+    if (cached !== undefined)
+        return cached;
+    let matched;
+    if (patternIndex === patternSegments.length) {
+        matched = pathIndex === pathSegments.length;
+    }
+    else if (patternSegments[patternIndex] === "**") {
+        matched = matchConcretePathSegments(pathSegments, patternSegments, pathIndex, patternIndex + 1, memo)
+            || (pathIndex < pathSegments.length
+                && matchConcretePathSegments(pathSegments, patternSegments, pathIndex + 1, patternIndex, memo));
+    }
+    else {
+        matched = pathIndex < pathSegments.length
+            && (patternSegments[patternIndex] === "*" || patternSegments[patternIndex] === pathSegments[pathIndex])
+            && matchConcretePathSegments(pathSegments, patternSegments, pathIndex + 1, patternIndex + 1, memo);
+    }
+    memo.set(key, matched);
+    return matched;
+}

package/dist/vendor/core/external-outcome.d.ts

@@ -0,0 +1,34 @@
+import { type ExternalOutcomeContract, type ExternalOutcomeEvidenceReference, type ExternalOutcomeResult } from "../contracts/index.js";
+export declare class ExternalOutcomeContractError extends Error {
+    readonly errors: Array<{
+        path: string;
+        message: string;
+    }>;
+    constructor(errors: Array<{
+        path: string;
+        message: string;
+    }>);
+}
+export declare class ExternalOutcomePolicyError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface VerifyExternalOutcomesOptions {
+    env?: NodeJS.ProcessEnv;
+    allowLocal?: boolean;
+    signal?: AbortSignal;
+    now?: () => Date;
+}
+export interface WriteExternalOutcomeEvidenceOptions {
+    runsRoot: string;
+    runId?: string;
+}
+export interface ExternalOutcomeEvidenceWrite {
+    path: string;
+    relativePath: string;
+    sha256: string;
+    reference: ExternalOutcomeEvidenceReference;
+}
+export declare function hashExternalOutcomeContract(contract: ExternalOutcomeContract): string;
+export declare function verifyExternalOutcomes(contract: ExternalOutcomeContract, options?: VerifyExternalOutcomesOptions): Promise<ExternalOutcomeResult>;
+export declare function writeExternalOutcomeEvidence(result: ExternalOutcomeResult, options: WriteExternalOutcomeEvidenceOptions): Promise<ExternalOutcomeEvidenceWrite>;