@treeseed/sdk 0.13.0-rc.8 → 0.13.0-rc.80

package/dist/guarantees/contracts/create-agent-guarantee-proof-template.js

@@ -1,21 +0,0 @@
-import { AGENT_GUARANTEE_PROOF_SCHEMA_VERSION } from "./agent-guarantee-contracts.js";
-const idFor = (action, index) => `${action.replaceAll(".", "-")}-${index + 1}`;
-const ref = (commandId, path) => ({ commandId, path });
-function createAgentGuaranteeProofTemplate(input) {
-  const commands = input.contract.proof.requiredCommands.map((action, index) => {
-    const [root, operation] = action.split(".");
-    return { id: idFor(action, index), args: [root, operation, "<add-exact-scope-and-identity-options>"], kind: "read", expectedExitCode: 0 };
-  });
-  const assignmentCleanup = commands.find((entry) => entry.args[0] === "capacity" && entry.args[1] === "assignment");
-  if (!assignmentCleanup && !commands.some((entry) => entry.args[0] === "platform" && entry.args[1] === "status")) commands.push({ id: "platform-status-cleanup", args: ["platform", "status"], kind: "read", expectedExitCode: 0 });
-  const evidenceCommand = commands[0].id;
-  const cleanupCommand = (assignmentCleanup ?? commands.find((entry) => entry.args[0] === "platform" && entry.args[1] === "status")).id;
-  const entityRef = (subject) => ref(evidenceCommand, `<path-to-${subject}>`);
-  const outcomes = input.contract.outcomes.filter((outcome) => !outcome.variants?.length || outcome.variants.includes(input.variant)).map((outcome) => ({ outcomeId: outcome.id, evidenceCommands: [evidenceCommand], entityRefs: Object.fromEntries((outcome.authoritativeSubjects ?? []).map((subject) => [subject, entityRef(subject)])), predicates: (input.contract.proof.outcomePredicates[outcome.id] ?? []).map((id) => ({ id, ...ref(evidenceCommand, `<path-for-${id}>`), operator: "exists" })) }));
-  const repositoryPostconditions = Array.from({ length: input.contract.proof.minimumRepositoryPostconditions }, (_, index) => ({ repository: `<repository-${index + 1}>`, baseRef: ref(evidenceCommand, "<path-to-base-ref>"), effectiveRef: ref(evidenceCommand, "<path-to-effective-ref>"), targetRef: ref(evidenceCommand, "<path-to-target-ref>"), changedPaths: ref(evidenceCommand, "<path-to-changed-paths>"), readBackVerified: ref(evidenceCommand, "<path-to-read-back-verification>") }));
-  const cleanup = { commandId: cleanupCommand, verified: ref(cleanupCommand, "<path-to-cleanup-verified>"), activeAssignments: ref(cleanupCommand, "<path-to-active-assignments>"), activeLeases: ref(cleanupCommand, "<path-to-active-leases>"), activeReservations: ref(cleanupCommand, "<path-to-active-reservations>"), activeDemands: ref(cleanupCommand, "<path-to-active-demands>"), activeWorkspaces: ref(cleanupCommand, "<path-to-active-workspaces>"), activeWorktrees: ref(cleanupCommand, "<path-to-active-worktrees>"), unpublishedBranches: ref(cleanupCommand, "<path-to-unpublished-branches>"), staleAuthorities: ref(cleanupCommand, "<path-to-stale-authorities>") };
-  return { schemaVersion: AGENT_GUARANTEE_PROOF_SCHEMA_VERSION, capabilityId: input.contract.capabilityId, variant: input.variant, sourceGeneration: "<pinned-source-generation>", commands, outcomes, repositoryPostconditions, cleanup };
-}
-export {
-  createAgentGuaranteeProofTemplate
-};

package/dist/guarantees/contracts/parse-agent-guarantee-contract.d.ts

@@ -1,19 +0,0 @@
-import type { GuaranteeDiagnostic } from '../index/guarantee-schema-version.js';
-import { type GuaranteeCatalogContract, type GuaranteeVerifierResult } from './agent-guarantee-contracts.js';
-export declare function parseGuaranteeCatalogContract(value: Record<string, unknown>, diagnostics: GuaranteeDiagnostic[], sourcePath: string): GuaranteeCatalogContract;
-export declare function validateGuaranteeVerifierResult(input: {
-    stdout: string;
-    guaranteeId: string;
-    contract: GuaranteeCatalogContract;
-    sourceGeneration: string;
-    expectedVariant?: string;
-    workspaceRoot?: string;
-}): {
-    ok: false;
-    error: string;
-    result?: undefined;
-} | {
-    ok: true;
-    result: GuaranteeVerifierResult;
-    error?: undefined;
-};

package/dist/guarantees/contracts/parse-agent-guarantee-contract.js

@@ -1,131 +0,0 @@
-import { diagnostic, isRecord, stringArray, stringValue } from "../index/guarantee-journey-audit-item.js";
-import { existsSync } from "node:fs";
-import { isAbsolute, relative, resolve } from "node:path";
-import { GUARANTEE_VERIFIER_RESULT_SCHEMA_VERSION } from "./agent-guarantee-contracts.js";
-const ID = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/u;
-function positiveInteger(value) {
-  return Number.isInteger(value) && Number(value) > 0 ? Number(value) : 0;
-}
-function assertions(value, diagnostics, sourcePath) {
-  if (!Array.isArray(value) || value.length === 0) {
-    diagnostics.push(diagnostic("error", "guarantee.v2_outcomes_required", "v2 guarantees require at least one structured outcome.", "outcomes", sourcePath));
-    return [];
-  }
-  const parsed = [];
-  for (const [index, candidate] of value.entries()) {
-    const path = `outcomes[${index}]`;
-    if (!isRecord(candidate)) {
-      diagnostics.push(diagnostic("error", "guarantee.v2_outcome_invalid", "Outcome assertions must be objects.", path, sourcePath));
-      continue;
-    }
-    const id = stringValue(candidate.id);
-    const kind = stringValue(candidate.kind);
-    const description = stringValue(candidate.description);
-    const evidenceKinds = stringArray(candidate.evidenceKinds);
-    if (!ID.test(id)) diagnostics.push(diagnostic("error", "guarantee.v2_outcome_id_invalid", `Invalid outcome id "${id}".`, `${path}.id`, sourcePath));
-    if (kind !== "required" && kind !== "forbidden") diagnostics.push(diagnostic("error", "guarantee.v2_outcome_kind_invalid", "Outcome kind must be required or forbidden.", `${path}.kind`, sourcePath));
-    if (!description) diagnostics.push(diagnostic("error", "guarantee.v2_outcome_description_required", "Outcome description is required.", `${path}.description`, sourcePath));
-    if (evidenceKinds.length === 0) diagnostics.push(diagnostic("error", "guarantee.v2_outcome_evidence_required", "Outcome evidenceKinds cannot be empty.", `${path}.evidenceKinds`, sourcePath));
-    parsed.push({ id, kind, description, evidenceKinds, authoritativeSubjects: stringArray(candidate.authoritativeSubjects), variants: stringArray(candidate.variants) });
-  }
-  if (new Set(parsed.map((entry) => entry.id)).size !== parsed.length) diagnostics.push(diagnostic("error", "guarantee.v2_duplicate_outcome", "Outcome ids must be unique within a guarantee.", "outcomes", sourcePath));
-  return parsed;
-}
-function parseGuaranteeCatalogContract(value, diagnostics, sourcePath) {
-  const capabilityId = stringValue(value.capabilityId);
-  const catalog = stringValue(value.catalog);
-  const activation = isRecord(value.activation) ? value.activation : {};
-  const minimumConsecutivePasses = positiveInteger(activation.minimumConsecutivePasses);
-  const requiredVariants = stringArray(activation.requiredVariants);
-  const distinctEntityRefs = (Array.isArray(activation.distinctEntityRefs) ? activation.distinctEntityRefs : []).map((entry, index) => {
-    const row = isRecord(entry) ? entry : {};
-    const subject = stringValue(row.subject);
-    const variants = stringArray(row.variants);
-    if (!subject || variants.length < 2) diagnostics.push(diagnostic("error", "guarantee.v2_activation_distinct_refs_invalid", "Distinct entity refs require one subject and at least two variants.", `activation.distinctEntityRefs[${index}]`, sourcePath));
-    for (const variant of variants) if (!requiredVariants.includes(variant)) diagnostics.push(diagnostic("error", "guarantee.v2_activation_distinct_variant_invalid", `Distinct entity ref references unadmitted variant ${variant}.`, `activation.distinctEntityRefs[${index}].variants`, sourcePath));
-    return { subject, variants };
-  });
-  if (!ID.test(capabilityId)) diagnostics.push(diagnostic("error", "guarantee.v2_capability_id_invalid", `Invalid capabilityId "${capabilityId}".`, "capabilityId", sourcePath));
-  if (!ID.test(catalog)) diagnostics.push(diagnostic("error", "guarantee.v2_catalog_invalid", `Invalid catalog "${catalog}".`, "catalog", sourcePath));
-  if (!minimumConsecutivePasses) diagnostics.push(diagnostic("error", "guarantee.v2_activation_passes_invalid", "minimumConsecutivePasses must be a positive integer.", "activation.minimumConsecutivePasses", sourcePath));
-  if (requiredVariants.length === 0) diagnostics.push(diagnostic("error", "guarantee.v2_activation_variants_required", "requiredVariants cannot be empty.", "activation.requiredVariants", sourcePath));
-  if (activation.invalidateOnSourceChange !== true) diagnostics.push(diagnostic("error", "guarantee.v2_source_invalidation_required", "v2 activation must invalidate on source change.", "activation.invalidateOnSourceChange", sourcePath));
-  const proof = isRecord(value.proof) ? value.proof : {};
-  const requiredCommands = stringArray(proof.requiredCommands);
-  const outcomePredicateRows = isRecord(proof.outcomePredicates) ? proof.outcomePredicates : {};
-  const outcomePredicates = Object.fromEntries(Object.entries(outcomePredicateRows).map(([id, predicates]) => [id, stringArray(predicates)]));
-  const minimumRepositoryPostconditions = Number(proof.minimumRepositoryPostconditions);
-  if (!requiredCommands.length) diagnostics.push(diagnostic("error", "guarantee.v2_proof_commands_required", "v2 guarantees require proof.requiredCommands.", "proof.requiredCommands", sourcePath));
-  if (!Number.isInteger(minimumRepositoryPostconditions) || minimumRepositoryPostconditions < 0) diagnostics.push(diagnostic("error", "guarantee.v2_proof_repository_count_invalid", "proof.minimumRepositoryPostconditions must be a nonnegative integer.", "proof.minimumRepositoryPostconditions", sourcePath));
-  const parsedOutcomes = assertions(value.outcomes, diagnostics, sourcePath);
-  for (const outcome of parsedOutcomes) for (const variant of outcome.variants ?? []) if (!requiredVariants.includes(variant)) diagnostics.push(diagnostic("error", "guarantee.v2_outcome_variant_invalid", `Outcome ${outcome.id} references unadmitted variant ${variant}.`, `outcomes.${outcome.id}.variants`, sourcePath));
-  for (const outcome of parsedOutcomes) if (!outcomePredicates[outcome.id]?.length) diagnostics.push(diagnostic("error", "guarantee.v2_proof_predicates_required", `Outcome ${outcome.id} requires named proof predicates.`, `proof.outcomePredicates.${outcome.id}`, sourcePath));
-  return {
-    capabilityId,
-    catalog,
-    outcomes: parsedOutcomes,
-    activation: { minimumConsecutivePasses, requiredVariants, invalidateOnSourceChange: activation.invalidateOnSourceChange === true, distinctEntityRefs },
-    proof: { requiredCommands, outcomePredicates, minimumRepositoryPostconditions: Number.isInteger(minimumRepositoryPostconditions) ? minimumRepositoryPostconditions : 0 },
-    supersedes: stringArray(value.supersedes),
-    ...stringValue(value.supersededBy) ? { supersededBy: stringValue(value.supersededBy) } : {}
-  };
-}
-function resultPayload(stdout) {
-  try {
-    const parsed = JSON.parse(stdout.trim());
-    if (!isRecord(parsed)) return null;
-    if (isRecord(parsed.verifierResult)) return parsed.verifierResult;
-    if (isRecord(parsed.report) && isRecord(parsed.report.verifierResult)) return parsed.report.verifierResult;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function validateGuaranteeVerifierResult(input) {
-  const value = resultPayload(input.stdout);
-  if (!value) return { ok: false, error: "Verifier stdout did not contain one JSON result object." };
-  if (value.schemaVersion !== GUARANTEE_VERIFIER_RESULT_SCHEMA_VERSION) return { ok: false, error: `Verifier result must use ${GUARANTEE_VERIFIER_RESULT_SCHEMA_VERSION}.` };
-  if (value.guaranteeId !== input.guaranteeId || value.capabilityId !== input.contract.capabilityId) return { ok: false, error: "Verifier result identifies a different guarantee or capability." };
-  if (value.sourceGeneration !== input.sourceGeneration) return { ok: false, error: "Verifier result source generation is stale or divergent." };
-  if (!input.contract.activation.requiredVariants.includes(String(value.variant))) return { ok: false, error: `Verifier result variant "${String(value.variant)}" is not admitted by the guarantee.` };
-  if (input.expectedVariant && value.variant !== input.expectedVariant) return { ok: false, error: `Verifier result variant "${String(value.variant)}" does not match requested variant "${input.expectedVariant}".` };
-  if (!Array.isArray(value.assertions)) return { ok: false, error: "Verifier result assertions are required." };
-  const assertions2 = value.assertions.filter(isRecord);
-  const byId = new Map(assertions2.map((entry) => [stringValue(entry.id), entry]));
-  for (const outcome of input.contract.outcomes.filter((entry) => !entry.variants?.length || entry.variants.includes(String(value.variant)))) {
-    const result = byId.get(outcome.id);
-    if (!result || result.status !== "passed") return { ok: false, error: `Required outcome ${outcome.id} did not pass.` };
-    const evidence = stringArray(result.evidence);
-    if (evidence.length === 0) return { ok: false, error: `Outcome ${outcome.id} has no evidence.` };
-    if (input.workspaceRoot && evidence.some((path) => !admissibleEvidencePath(input.workspaceRoot, path))) return { ok: false, error: `Outcome ${outcome.id} refers to missing or unsafe evidence.` };
-    if (outcome.authoritativeSubjects?.length) {
-      if (!isRecord(result.entityRefs) || outcome.authoritativeSubjects.some((subject) => !stringValue(result.entityRefs?.[subject]))) {
-        return { ok: false, error: `Outcome ${outcome.id} omits authoritative subject identities.` };
-      }
-    }
-  }
-  if (!Array.isArray(value.repositoryPostconditions)) return { ok: false, error: "Verifier repository postconditions are required." };
-  for (const [index, candidate] of value.repositoryPostconditions.entries()) {
-    if (!isRecord(candidate) || !stringValue(candidate.repository) || !stringValue(candidate.baseRef) || !stringValue(candidate.effectiveRef)) return { ok: false, error: `Repository postcondition ${index} omits exact repository or ref identity.` };
-    if (!Array.isArray(candidate.changedPaths) || candidate.changedPaths.some((path) => !stringValue(path))) return { ok: false, error: `Repository postcondition ${index} has invalid changed paths.` };
-    if (candidate.readBackVerified !== true) return { ok: false, error: `Repository postcondition ${index} lacks authoritative read-back.` };
-  }
-  const rootEvidence = stringArray(value.evidence);
-  if (rootEvidence.length === 0) return { ok: false, error: "Verifier result evidence paths are required." };
-  if (input.workspaceRoot && rootEvidence.some((path) => !admissibleEvidencePath(input.workspaceRoot, path))) return { ok: false, error: "Verifier result refers to missing or unsafe evidence." };
-  if (!isRecord(value.cleanup) || value.cleanup.verified !== true) return { ok: false, error: "Verifier result does not prove cleanup." };
-  for (const field of ["activeAssignments", "activeLeases", "activeReservations", "activeDemands", "activeWorkspaces", "activeWorktrees", "unpublishedBranches", "staleAuthorities"]) {
-    if (value.cleanup[field] !== 0) return { ok: false, error: `Verifier cleanup field ${field} is not zero.` };
-  }
-  return { ok: true, result: value };
-}
-function admissibleEvidencePath(workspaceRoot, path) {
-  if (!path || isAbsolute(path)) return false;
-  const target = resolve(workspaceRoot, path);
-  const traversal = relative(resolve(workspaceRoot), target);
-  return traversal !== "" && !traversal.startsWith("..") && !isAbsolute(traversal) && existsSync(target);
-}
-export {
-  parseGuaranteeCatalogContract,
-  validateGuaranteeVerifierResult
-};

package/dist/guarantees/contracts/parse-agent-guarantee-proof.d.ts

@@ -1,10 +0,0 @@
-import { type AgentGuaranteeProofInput, type GuaranteeCatalogContract } from './agent-guarantee-contracts.js';
-export declare function parseAgentGuaranteeProofInput(value: unknown, contract: GuaranteeCatalogContract, expectedVariant: string, expectedSourceGeneration?: string): {
-    ok: false;
-    issues: string[];
-    proof?: undefined;
-} | {
-    ok: true;
-    proof: AgentGuaranteeProofInput;
-    issues?: undefined;
-};

package/dist/guarantees/contracts/parse-agent-guarantee-proof.js

@@ -1,133 +0,0 @@
-import { isRecord, stringArray, stringValue } from "../index/guarantee-journey-audit-item.js";
-import {
-  AGENT_GUARANTEE_PROOF_SCHEMA_VERSION
-} from "./agent-guarantee-contracts.js";
-const ID = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*$/u;
-const COMMAND_KINDS = /* @__PURE__ */ new Set(["read", "operator-mutation", "simulated-human-mutation", "recovery"]);
-const OPERATORS = /* @__PURE__ */ new Set(["exists", "absent", "equals", "not-equals", "includes", "matches", "length-at-least", "distinct"]);
-const ALLOWED_ROOTS = /* @__PURE__ */ new Set(["capacity", "dev", "governance", "platform", "projects"]);
-const FORBIDDEN_ROOTS = /* @__PURE__ */ new Set(["release", "save", "stage"]);
-const GOVERNANCE_READS = /* @__PURE__ */ new Set(["proposal-list", "proposal-show", "proposal-events", "decision-list", "decision-show", "decision-events"]);
-const PLACEHOLDER = /<[^>]+>/u;
-const GENERATION = /^[a-f0-9]{64}$/u;
-const EXACT_SELECTORS = {
-  "capacity.context-query-checks": ["--team", "--project"],
-  "capacity.context-query-test": ["--team", "--project", "--agent-test"],
-  "capacity.workday": ["--workday"],
-  "capacity.assignment": ["--assignment"],
-  "capacity.mode-runs": ["--assignment"],
-  "capacity.audit-events": ["--resource-type", "--resource-id"],
-  "capacity.treedx-proxy-audit": ["--assignment"],
-  "capacity.workday-summary": ["--workday"],
-  "capacity.workday-log": ["--workday"],
-  "capacity.decision-planning": ["--decision"],
-  "capacity.execution-inputs": ["--decision"],
-  "capacity.capacity-plan": ["--capacity-plan"],
-  "capacity.checkpoint-integrate": ["--assignment"],
-  "capacity.assignment-authority-probe": ["--assignment"],
-  "capacity.assignment-explanation": ["--assignment"],
-  "governance.proposal-show": ["--project", "--proposal"],
-  "projects.list": ["--team"]
-};
-function ref(value, path, issues) {
-  const row = isRecord(value) ? value : {};
-  const commandId = stringValue(row.commandId);
-  const valuePath = stringValue(row.path);
-  if (!ID.test(commandId)) issues.push(`${path}.commandId must be a stable command id.`);
-  if (!valuePath) issues.push(`${path}.path is required.`);
-  if (PLACEHOLDER.test(valuePath)) issues.push(`${path}.path contains an unresolved placeholder.`);
-  return { commandId, path: valuePath };
-}
-function command(value, index, variant, issues) {
-  const row = isRecord(value) ? value : {};
-  const id = stringValue(row.id);
-  const args = stringArray(row.args);
-  const kind = stringValue(row.kind);
-  const expectedExitCode = Number(row.expectedExitCode);
-  const path = `commands[${index}]`;
-  if (!ID.test(id)) issues.push(`${path}.id must be stable lowercase kebab-case.`);
-  if (!args.length || !ALLOWED_ROOTS.has(args[0]) || FORBIDDEN_ROOTS.has(args[0])) issues.push(`${path}.args must start with an allowed trsd command.`);
-  if (args.some((entry) => PLACEHOLDER.test(entry))) issues.push(`${path}.args contains unresolved placeholders.`);
-  const action = `${args[0]}.${args[1] ?? ""}`;
-  for (const selector of EXACT_SELECTORS[action] ?? []) if (!args.includes(selector)) issues.push(`${path} ${action} requires exact selector ${selector}.`);
-  if (["capacity", "governance", "projects"].includes(args[0]) && !args.includes("--server")) issues.push(`${path} must name the exact --server.`);
-  if (!COMMAND_KINDS.has(kind)) issues.push(`${path}.kind is invalid.`);
-  if (!Number.isInteger(expectedExitCode) || expectedExitCode < 0) issues.push(`${path}.expectedExitCode must be a nonnegative integer.`);
-  if (kind === "read" && args.includes("--execute")) issues.push(`${path} classifies an executing mutation as a read.`);
-  if (args[0] === "governance" && !GOVERNANCE_READS.has(args[1]) && kind !== "simulated-human-mutation") issues.push(`${path} governance mutations must be classified as simulated-human-mutation.`);
-  if (kind === "operator-mutation" && (!args.includes("--execute") || !args.includes("--idempotency-key"))) issues.push(`${path} operator mutations require --execute and --idempotency-key.`);
-  if (kind === "simulated-human-mutation") {
-    for (const flag of ["--simulate-human", "--workday", "--reason", "--idempotency-key"]) if (!args.includes(flag)) issues.push(`${path} simulated-human mutations require ${flag}.`);
-    if (args[0] === "governance" && ["proposal-vote", "proposal-evaluate", "proposal-admin-decide"].includes(args[1]) && !args.includes("--yes")) issues.push(`${path} binding governance requires --yes.`);
-  }
-  if (kind === "recovery" && (variant !== "interruption-resume" || args[0] !== "dev" || args[1] !== "restart" || !args.includes("--app"))) issues.push(`${path} recovery commands are limited to an explicit app restart in the interruption variant.`);
-  return { id, args, kind, expectedExitCode };
-}
-function predicate(value, path, issues) {
-  const row = isRecord(value) ? value : {};
-  const id = stringValue(row.id);
-  const operator = stringValue(row.operator);
-  if (!ID.test(id)) issues.push(`${path}.id must be stable lowercase kebab-case.`);
-  if (!OPERATORS.has(operator)) issues.push(`${path}.operator is invalid.`);
-  if (!("expected" in row) && !row.expectedRef && !["exists", "absent", "distinct"].includes(operator)) issues.push(`${path} requires expected or expectedRef.`);
-  return { id, ...ref(row, path, issues), operator, ..."expected" in row ? { expected: row.expected } : {}, ...row.expectedRef ? { expectedRef: ref(row.expectedRef, `${path}.expectedRef`, issues) } : {} };
-}
-function outcome(value, index, issues) {
-  const row = isRecord(value) ? value : {};
-  const outcomeId = stringValue(row.outcomeId);
-  const path = `outcomes[${index}]`;
-  const entityRows = isRecord(row.entityRefs) ? row.entityRefs : {};
-  return {
-    outcomeId,
-    evidenceCommands: stringArray(row.evidenceCommands),
-    entityRefs: Object.fromEntries(Object.entries(entityRows).map(([key, value2]) => [key, ref(value2, `${path}.entityRefs.${key}`, issues)])),
-    predicates: (Array.isArray(row.predicates) ? row.predicates : []).map((entry, predicateIndex) => predicate(entry, `${path}.predicates[${predicateIndex}]`, issues))
-  };
-}
-function parseAgentGuaranteeProofInput(value, contract, expectedVariant, expectedSourceGeneration) {
-  const issues = [];
-  const row = isRecord(value) ? value : {};
-  if (row.schemaVersion !== AGENT_GUARANTEE_PROOF_SCHEMA_VERSION) issues.push(`schemaVersion must be ${AGENT_GUARANTEE_PROOF_SCHEMA_VERSION}.`);
-  if (row.capabilityId !== contract.capabilityId) issues.push("capabilityId does not match the selected guarantee.");
-  if (row.variant !== expectedVariant) issues.push("variant does not match the requested guarantee run.");
-  const sourceGeneration = stringValue(row.sourceGeneration);
-  if (!GENERATION.test(sourceGeneration)) issues.push("sourceGeneration must be one pinned 64-character lowercase hex digest.");
-  if (expectedSourceGeneration && sourceGeneration !== expectedSourceGeneration) issues.push("sourceGeneration is stale or divergent from the current guarantee run.");
-  const commands = (Array.isArray(row.commands) ? row.commands : []).map((entry, index) => command(entry, index, expectedVariant, issues));
-  const outcomes = (Array.isArray(row.outcomes) ? row.outcomes : []).map((entry, index) => outcome(entry, index, issues));
-  if (!commands.length) issues.push("commands cannot be empty.");
-  const commandIds = new Set(commands.map((entry) => entry.id));
-  if (commandIds.size !== commands.length) issues.push("command ids must be unique.");
-  const expectedOutcomes = contract.outcomes.filter((entry) => !entry.variants?.length || entry.variants.includes(expectedVariant));
-  const outcomeIds = new Set(outcomes.map((entry) => entry.outcomeId));
-  for (const expected of expectedOutcomes) if (!outcomeIds.has(expected.id)) issues.push(`Missing proof outcome ${expected.id}.`);
-  for (const candidate of outcomes) {
-    const outcomeContract = expectedOutcomes.find((entry) => entry.id === candidate.outcomeId);
-    if (!outcomeContract) issues.push(`Unknown proof outcome ${candidate.outcomeId}.`);
-    if (!candidate.evidenceCommands.length || !candidate.predicates.length) issues.push(`Proof outcome ${candidate.outcomeId} requires evidence commands and predicates.`);
-    for (const id of candidate.evidenceCommands) if (!commandIds.has(id)) issues.push(`Proof outcome ${candidate.outcomeId} references unknown command ${id}.`);
-    for (const subject of outcomeContract?.authoritativeSubjects ?? []) if (!candidate.entityRefs[subject]) issues.push(`Proof outcome ${candidate.outcomeId} omits authoritative subject ${subject}.`);
-    const predicateIds = new Set(candidate.predicates.map((entry) => entry.id));
-    for (const predicateId of contract.proof.outcomePredicates[candidate.outcomeId] ?? []) if (!predicateIds.has(predicateId)) issues.push(`Proof outcome ${candidate.outcomeId} omits required predicate ${predicateId}.`);
-  }
-  const commandActions = new Set(commands.map((entry) => `${entry.args[0]}.${entry.args[1] ?? ""}`));
-  for (const action of contract.proof.requiredCommands) if (!commandActions.has(action)) issues.push(`Proof omits required CLI command ${action}.`);
-  const cleanupRow = isRecord(row.cleanup) ? row.cleanup : {};
-  const cleanupFields = ["verified", "activeAssignments", "activeLeases", "activeReservations", "activeDemands", "activeWorkspaces", "activeWorktrees", "unpublishedBranches", "staleAuthorities"];
-  const cleanup = { commandId: stringValue(cleanupRow.commandId), ...Object.fromEntries(cleanupFields.map((field) => [field, ref(cleanupRow[field], `cleanup.${field}`, issues)])) };
-  if (!commandIds.has(cleanup.commandId)) issues.push(`Cleanup references unknown command ${cleanup.commandId}.`);
-  const repositoryPostconditions = (Array.isArray(row.repositoryPostconditions) ? row.repositoryPostconditions : []).map((entry, index) => {
-    const item = isRecord(entry) ? entry : {};
-    const path = `repositoryPostconditions[${index}]`;
-    const repository = stringValue(item.repository);
-    if (PLACEHOLDER.test(repository)) issues.push(`${path}.repository contains an unresolved placeholder.`);
-    return { repository, baseRef: ref(item.baseRef, `${path}.baseRef`, issues), effectiveRef: ref(item.effectiveRef, `${path}.effectiveRef`, issues), ...item.targetRef ? { targetRef: ref(item.targetRef, `${path}.targetRef`, issues) } : {}, changedPaths: ref(item.changedPaths, `${path}.changedPaths`, issues), readBackVerified: ref(item.readBackVerified, `${path}.readBackVerified`, issues) };
-  });
-  if (repositoryPostconditions.length < contract.proof.minimumRepositoryPostconditions) issues.push(`Proof requires at least ${contract.proof.minimumRepositoryPostconditions} repository postconditions.`);
-  const proof = { schemaVersion: AGENT_GUARANTEE_PROOF_SCHEMA_VERSION, capabilityId: stringValue(row.capabilityId), variant: stringValue(row.variant), sourceGeneration, commands, outcomes, repositoryPostconditions, cleanup };
-  for (const candidate of [...outcomes.flatMap((entry) => [...Object.values(entry.entityRefs), ...entry.predicates, ...entry.predicates.flatMap((entry2) => entry2.expectedRef ? [entry2.expectedRef] : [])]), ...repositoryPostconditions.flatMap((entry) => [entry.baseRef, entry.effectiveRef, ...entry.targetRef ? [entry.targetRef] : [], entry.changedPaths, entry.readBackVerified]), ...cleanupFields.map((field) => cleanup[field])]) if (!commandIds.has(candidate.commandId)) issues.push(`Proof references unknown command ${candidate.commandId}.`);
-  return issues.length ? { ok: false, issues } : { ok: true, proof };
-}
-export {
-  parseAgentGuaranteeProofInput
-};

package/dist/guarantees/features/guarantee-source-closure.d.ts

@@ -1,9 +0,0 @@
-export declare function guaranteeSourceClosure(workspaceRoot: string): {
-    schemaVersion: "treeseed.guarantee-source-closure/v1";
-    web: string | null;
-    api: string | null;
-    agent: string | null;
-    cli: string | null;
-    contracts: string;
-};
-export declare function guaranteeSourceGeneration(closure: ReturnType<typeof guaranteeSourceClosure>): string;

package/dist/guarantees/features/guarantee-source-closure.js

@@ -1,50 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
-import { relative, resolve } from "node:path";
-import { managedDevSourceClosureDigest } from "../../local-dev/source-closure.js";
-function filesUnder(path) {
-  if (!existsSync(path)) return [];
-  const stat = lstatSync(path);
-  if (stat.isSymbolicLink()) return [];
-  if (stat.isFile()) return [path];
-  if (!stat.isDirectory()) return [];
-  return readdirSync(path).sort().flatMap((entry) => filesUnder(resolve(path, entry)));
-}
-function guaranteeContractDigest(workspaceRoot) {
-  const packagesRoot = resolve(workspaceRoot, "packages");
-  const roots = [
-    resolve(workspaceRoot, "guarantees"),
-    resolve(workspaceRoot, "scripts/guarantees"),
-    ...(existsSync(packagesRoot) ? readdirSync(packagesRoot, { withFileTypes: true }) : []).filter((entry) => entry.isDirectory()).map((entry) => resolve(packagesRoot, entry.name, "guarantees"))
-  ];
-  const hash = createHash("sha256");
-  for (const file of roots.flatMap(filesUnder).sort()) {
-    hash.update(relative(workspaceRoot, file));
-    hash.update("\0");
-    hash.update(readFileSync(file));
-    hash.update("\0");
-  }
-  return hash.digest("hex");
-}
-function guaranteeSourceClosure(workspaceRoot) {
-  return {
-    schemaVersion: "treeseed.guarantee-source-closure/v1",
-    web: managedDevSourceClosureDigest({ tenantRoot: workspaceRoot, surface: "web" }),
-    api: managedDevSourceClosureDigest({ tenantRoot: workspaceRoot, surface: "api" }),
-    agent: managedDevSourceClosureDigest({ tenantRoot: workspaceRoot, surface: "agent" }),
-    cli: managedDevSourceClosureDigest({ tenantRoot: workspaceRoot, surface: "cli" }),
-    contracts: guaranteeContractDigest(workspaceRoot)
-  };
-}
-function guaranteeSourceGeneration(closure) {
-  const hash = createHash("sha256");
-  for (const value of [closure.schemaVersion, closure.web ?? "", closure.api ?? "", closure.agent ?? "", closure.cli ?? "", closure.contracts]) {
-    hash.update(value);
-    hash.update("\0");
-  }
-  return hash.digest("hex");
-}
-export {
-  guaranteeSourceClosure,
-  guaranteeSourceGeneration
-};

package/dist/guarantees/features/ui-feature-contract.d.ts

@@ -1,35 +0,0 @@
-import type { GuaranteeDevice, GuaranteeDiagnostic, GuaranteeManifest, LoadedGuarantee } from '../index/guarantee-schema-version.js';
-export declare const UI_FEATURE_SCHEMA_VERSION: "treeseed.ui-feature/v1";
-export type UiFeatureCapability = {
-    id: string;
-    routes: string[];
-    actions: string[];
-    states: string[];
-    allowedActors: string[];
-    forbiddenActors: string[];
-    guaranteeIds: string[];
-};
-export type UiFeatureContract = {
-    schemaVersion: typeof UI_FEATURE_SCHEMA_VERSION;
-    id: string;
-    ownerPackage: string;
-    routes: string[];
-    devices: GuaranteeDevice[];
-    states: string[];
-    capabilities: UiFeatureCapability[];
-    requiredGuarantees: string[];
-    requirements: {
-        accessibility: boolean;
-        console: boolean;
-        network: boolean;
-        visual: boolean;
-        durableState: boolean;
-        cleanup: boolean;
-    };
-};
-export declare function parseUiFeatureContract(value: unknown): UiFeatureContract | null;
-export declare function validateUiFeatureContracts(input: {
-    guarantees: Array<LoadedGuarantee & {
-        manifest: GuaranteeManifest;
-    }>;
-}): GuaranteeDiagnostic[];

package/dist/guarantees/features/ui-feature-contract.js

@@ -1,133 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { parse as parseYaml } from "yaml";
-import {
-  arrayOrEmpty,
-  diagnostic,
-  isRecord,
-  stringArray,
-  stringValue
-} from "../index/guarantee-journey-audit-item.js";
-import { readSceneYaml, sceneManifestPathForGuarantee } from "../index/parse-verifier-registry.js";
-const UI_FEATURE_SCHEMA_VERSION = "treeseed.ui-feature/v1";
-function parseCapability(value) {
-  if (!isRecord(value) || !stringValue(value.id)) return null;
-  const actors = isRecord(value.actors) ? value.actors : {};
-  return {
-    id: stringValue(value.id),
-    routes: stringArray(value.routes),
-    actions: stringArray(value.actions),
-    states: stringArray(value.states),
-    allowedActors: stringArray(actors.allowed),
-    forbiddenActors: stringArray(actors.forbidden),
-    guaranteeIds: stringArray(value.guaranteeIds)
-  };
-}
-function parseUiFeatureContract(value) {
-  if (!isRecord(value) || value.schemaVersion !== UI_FEATURE_SCHEMA_VERSION) return null;
-  const requirements = isRecord(value.requirements) ? value.requirements : {};
-  return {
-    schemaVersion: UI_FEATURE_SCHEMA_VERSION,
-    id: stringValue(value.id),
-    ownerPackage: stringValue(value.ownerPackage),
-    routes: stringArray(value.routes),
-    devices: stringArray(value.devices),
-    states: stringArray(value.states),
-    capabilities: arrayOrEmpty(value.capabilities).map(parseCapability).filter(Boolean),
-    requiredGuarantees: stringArray(value.requiredGuarantees),
-    requirements: {
-      accessibility: requirements.accessibility === true,
-      console: requirements.console === true,
-      network: requirements.network === true,
-      visual: requirements.visual === true,
-      durableState: requirements.durableState === true,
-      cleanup: requirements.cleanup === true
-    }
-  };
-}
-function sceneProves(entry) {
-  const path = sceneManifestPathForGuarantee(entry);
-  const scene = path && existsSync(path) ? readSceneYaml(path) : null;
-  const journey = isRecord(scene?.journey) ? scene.journey : {};
-  return stringArray(journey.proves);
-}
-function error(message, path, sourcePath) {
-  return diagnostic("error", "guarantee.ui_feature_contract_invalid", message, path, sourcePath);
-}
-function validateUiFeatureContracts(input) {
-  const diagnostics = [];
-  const byId = new Map(input.guarantees.map((entry) => [entry.manifest.id, entry]));
-  const loaded = /* @__PURE__ */ new Map();
-  for (const entry of input.guarantees) {
-    const reference = entry.manifest.uiFeature;
-    if (!reference) continue;
-    const sourcePath = resolve(dirname(entry.sourcePath), reference.contract);
-    if (!existsSync(sourcePath)) {
-      diagnostics.push(error(`UI feature contract does not exist: ${reference.contract}.`, "uiFeature.contract", entry.sourcePath));
-      continue;
-    }
-    let contract = loaded.get(sourcePath)?.contract;
-    if (!contract) {
-      try {
-        contract = parseUiFeatureContract(parseYaml(readFileSync(sourcePath, "utf8"))) ?? void 0;
-      } catch {
-        contract = void 0;
-      }
-      if (!contract) {
-        diagnostics.push(error("UI feature contract is unreadable or has an unsupported schema.", "uiFeature.contract", sourcePath));
-        continue;
-      }
-      loaded.set(sourcePath, { contract, sourcePath });
-    }
-    if (contract.ownerPackage !== entry.manifest.ownerPackage) {
-      diagnostics.push(error(`UI feature owner ${contract.ownerPackage} does not match ${entry.manifest.ownerPackage}.`, "ownerPackage", sourcePath));
-    }
-    const capabilityIds = new Set(contract.capabilities.map((capability) => capability.id));
-    const declared = reference.capabilities;
-    const proved = sceneProves(entry);
-    for (const capability of declared) {
-      if (!capabilityIds.has(capability)) diagnostics.push(error(`Unknown UI feature capability "${capability}".`, "uiFeature.capabilities", entry.sourcePath));
-      if (!proved.includes(capability)) diagnostics.push(error(`Scene journey.proves must cite capability "${capability}".`, "scene.journey.proves", entry.sourcePath));
-    }
-    if (entry.manifest.status === "active" && ["admin-ui", "market-ui"].includes(entry.manifest.surface ?? "")) {
-      if (!entry.manifest.scene?.required || !entry.manifest.scene.manifest) {
-        diagnostics.push(error("Active UI guarantees require a positive browser scene.", "scene", entry.sourcePath));
-      }
-      for (const actor of entry.manifest.actors.forbidden) {
-        const negative = arrayOrEmpty(entry.manifest.negativeCases).find((candidate) => candidate.actor === actor && candidate.sceneManifest);
-        if (!negative) diagnostics.push(error(`Forbidden actor "${actor}" requires a negative browser scene.`, "negativeCases", entry.sourcePath));
-      }
-    }
-  }
-  for (const { contract, sourcePath } of loaded.values()) {
-    const capabilityIds = new Set(contract.capabilities.map((entry) => entry.id));
-    for (const capability of contract.capabilities) {
-      if (capability.routes.length === 0 || capability.actions.length === 0 || capability.states.length === 0) {
-        diagnostics.push(error(`Capability "${capability.id}" must declare routes, actions, and states.`, "capabilities", sourcePath));
-      }
-      for (const id of capability.guaranteeIds) {
-        const guarantee = byId.get(id);
-        if (!guarantee) diagnostics.push(error(`Capability "${capability.id}" references missing guarantee "${id}".`, "capabilities.guaranteeIds", sourcePath));
-        else if (!guarantee.manifest.uiFeature?.capabilities.includes(capability.id)) {
-          diagnostics.push(error(`Guarantee "${id}" does not map back to capability "${capability.id}".`, "capabilities.guaranteeIds", sourcePath));
-        }
-      }
-    }
-    for (const id of contract.requiredGuarantees) {
-      const guarantee = byId.get(id);
-      if (!guarantee) diagnostics.push(error(`Required guarantee "${id}" is missing.`, "requiredGuarantees", sourcePath));
-      else if (guarantee.manifest.status !== "active") diagnostics.push(error(`Required guarantee "${id}" is ${guarantee.manifest.status}; UI feature contracts fail closed.`, "requiredGuarantees", sourcePath));
-    }
-    const mapped = new Set(input.guarantees.flatMap((entry) => entry.manifest.uiFeature?.contract && resolve(dirname(entry.sourcePath), entry.manifest.uiFeature.contract) === sourcePath ? entry.manifest.uiFeature.capabilities : []));
-    for (const id of capabilityIds) if (!mapped.has(id)) diagnostics.push(error(`Capability "${id}" has no guarantee coverage.`, "capabilities", sourcePath));
-    if (Object.values(contract.requirements).some((required) => !required)) {
-      diagnostics.push(error("All production UI quality and cleanup requirements must be enabled.", "requirements", sourcePath));
-    }
-  }
-  return diagnostics;
-}
-export {
-  UI_FEATURE_SCHEMA_VERSION,
-  parseUiFeatureContract,
-  validateUiFeatureContracts
-};

package/dist/guarantees/features/ui-scene-runtime-trust.d.ts

@@ -1,16 +0,0 @@
-import type { GuaranteeDiagnostic } from '../index/guarantee-schema-version.js';
-type ObservedError = {
-    message?: string;
-    method?: string;
-    status?: number;
-    url?: string;
-};
-type RuntimeStep = {
-    id?: string;
-    consoleErrors?: ObservedError[];
-    networkErrors?: ObservedError[];
-};
-export declare function unexpectedUiSceneRuntimeDiagnostics(report: {
-    steps?: RuntimeStep[];
-}, sourcePath?: string): GuaranteeDiagnostic[];
-export {};

package/dist/guarantees/features/ui-scene-runtime-trust.js

@@ -1,33 +0,0 @@
-import { diagnostic } from "../index/guarantee-journey-audit-item.js";
-function unexpectedUiSceneRuntimeDiagnostics(report, sourcePath) {
-  const diagnostics = [];
-  for (const step of report.steps ?? []) {
-    for (const observed of step.consoleErrors ?? []) {
-      const browserStatus = observed.message?.match(/status of (\d{3})/iu)?.[1];
-      const isExpectedClientResponse = browserStatus ? (step.networkErrors ?? []).some((entry) => entry.status === Number(browserStatus) && entry.status >= 400 && entry.status < 500) : false;
-      if (/^Failed to load resource:/iu.test(observed.message ?? "") && isExpectedClientResponse) continue;
-      diagnostics.push(diagnostic(
-        "error",
-        "guarantee.scene_unexpected_console_error",
-        `Browser console error${step.id ? ` during ${step.id}` : ""}: ${observed.message ?? "unknown console error"}.`,
-        "scene.console",
-        sourcePath
-      ));
-    }
-    for (const observed of step.networkErrors ?? []) {
-      if (typeof observed.status === "number" && observed.status < 500) continue;
-      const request = [observed.method, observed.url].filter(Boolean).join(" ");
-      diagnostics.push(diagnostic(
-        "error",
-        "guarantee.scene_unexpected_network_error",
-        `Browser network failure${step.id ? ` during ${step.id}` : ""}${request ? ` (${request})` : ""}: ${observed.message ?? `HTTP ${observed.status ?? "failure"}`}.`,
-        "scene.network",
-        sourcePath
-      ));
-    }
-  }
-  return diagnostics;
-}
-export {
-  unexpectedUiSceneRuntimeDiagnostics
-};

package/dist/guarantees/index/build-guarantee-dependency-graph.d.ts

@@ -1,21 +0,0 @@
-import { GuaranteeFilter, GuaranteeManifest, GuaranteeRegistryReport, GuaranteeVerifierContract, LoadedGuarantee, LoadedGuaranteeVerifierRegistry } from './guarantee-schema-version.js';
-import { GuaranteeDependencyGraph } from './parse-verifier-registry.js';
-export declare function buildGuaranteeDependencyGraph(input: {
-    guarantees: LoadedGuarantee[];
-    filter?: GuaranteeFilter;
-    includeDependencies?: boolean;
-}): GuaranteeDependencyGraph;
-export declare function filterGuarantees(input: {
-    guarantees: LoadedGuarantee[];
-    filter?: GuaranteeFilter;
-    includeDependencies?: boolean;
-}): (LoadedGuarantee & {
-    manifest: GuaranteeManifest;
-})[];
-export declare function validateGuaranteeRegistry(input: {
-    workspaceRoot: string;
-    guarantees: LoadedGuarantee[];
-    verifierRegistries?: LoadedGuaranteeVerifierRegistry[];
-    filter?: GuaranteeFilter;
-}): GuaranteeRegistryReport;
-export declare function refs(contract: GuaranteeVerifierContract | undefined): string[];