@tiic-tech/openworkflow 0.1.1 → 0.1.2

package/dist/core/src/validators/validateRepositoryContracts.js

@@ -1,9 +1,11 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { statSync } from "node:fs";
 import { basename, join, relative, resolve } from "node:path";
+import { getWorkflowCommands } from "../commands/registry.js";
 import { SCHEMA_VERSION } from "../contracts/index.js";
 import { parseYaml } from "../contracts/yaml.js";
-import { isNotFound } from "../fs/index.js";
+import { isExternalReference, isNotFound, resolveLocalReference } from "../fs/index.js";
+import { assessBranchIdentity, branchIdentityExceptionFrom } from "../git/branchIdentity.js";
 const REQUIRED_FILES = [
     "AGENT.md",
     "README.md",
@@ -16,7 +18,9 @@ const REQUIRED_FILES = [
     "references/discovery-artifact-contracts.md",
     "references/artifact-authoring-templates.md",
     "references/runtime-command-surface.md",
+    "references/proto2html-artifact-contracts.md",
     "schemas/openworkflow-contract.schema.json",
+    "schemas/current-state.schema.json",
     "schemas/workflow-index.schema.json",
     "schemas/contract-graph.schema.json",
     "schemas/artifact-contracts.schema.json",
@@ -24,6 +28,7 @@ const REQUIRED_FILES = [
     "schemas/vision-session.schema.json",
     "schemas/validation-target.schema.json",
     "schemas/prototype-evidence.schema.json",
+    "schemas/html-prototype.schema.json",
     "schemas/decision-record.schema.json",
     "schemas/product-design.schema.json",
     "schemas/change.schema.json",
@@ -33,22 +38,39 @@ const REQUIRED_FILES = [
     "package.json",
     "tsconfig.json",
     "packages/cli/src/index.ts",
+    "packages/cli/src/report.ts",
+    "packages/cli/src/commands/brief.ts",
+    "packages/cli/src/commands/check.ts",
     "packages/cli/src/commands/clean.ts",
+    "packages/cli/src/commands/context.ts",
+    "packages/cli/src/commands/draft.ts",
     "packages/cli/src/commands/init.ts",
+    "packages/cli/src/commands/inspect.ts",
+    "packages/cli/src/commands/register.ts",
+    "packages/cli/src/commands/summaries.ts",
+    "packages/cli/src/commands/summarize.ts",
     "packages/cli/src/commands/validate.ts",
     "packages/cli/src/commands/sync.ts",
     "packages/cli/src/commands/doctor.ts",
     "packages/cli/src/dev/validateRepositoryContractsCli.ts",
     "packages/cli/src/dev/verifyRuntimeSurface.ts",
     "packages/cli/src/dev/verifyWorkflowE2E.ts",
+    "packages/cli/src/dev/verifyAgentE2E.ts",
     "packages/cli/src/dev/verifyCleanCommand.ts",
+    "packages/adapters/src/registry.ts",
     "packages/core/src/artifacts/registry.ts",
+    "packages/core/src/artifacts/readiness.ts",
     "packages/core/src/contracts/index.ts",
     "packages/core/src/contracts/yaml.ts",
     "packages/core/src/commands/registry.ts",
     "packages/core/src/fs/index.ts",
+    "packages/core/src/onboarding/agentsGuide.ts",
+    "packages/core/src/workflow/doctorOpenWorkflow.ts",
     "packages/core/src/workflow/initOpenWorkflow.ts",
+    "packages/core/src/workflow/readWorkflowConfig.ts",
     "packages/core/src/workflow/cleanOpenWorkflow.ts",
+    "packages/core/src/workflow/summaryHealth.ts",
+    "packages/core/src/workflow/syncOpenWorkflow.ts",
     "packages/core/src/validators/validateOpenWorkflow.ts",
     "packages/core/src/validators/validateRepositoryContracts.ts",
     "packages/core/src/graph/README.md",
@@ -60,6 +82,7 @@ const REQUIRED_FILES = [
     "packages/adapters/codex/src/templates.ts",
     "templates/openworkflow/README.md",
     "templates/codex/README.md",
+    "skills/build-vision/SKILL.md",
     "skills/build-validation/SKILL.md",
     "skills/build-validation/scripts/init_validation.py",
     "skills/build-prototype/SKILL.md",
@@ -113,15 +136,105 @@ const REQUIRED_FILES = [
     "changes/M21-npm-package-release-readiness/WORK_ITEMS.yaml",
     "changes/M22-project-clean-command/CHANGE.yaml",
     "changes/M22-project-clean-command/WORK_ITEMS.yaml",
+    "changes/M23-production-command-lazy-contracts/CHANGE.yaml",
+    "changes/M23-production-command-lazy-contracts/WORK_ITEMS.yaml",
+    "changes/M24-agent-context-state-and-summaries/CHANGE.yaml",
+    "changes/M24-agent-context-state-and-summaries/WORK_ITEMS.yaml",
+    "changes/M25-agent-onboarding-entrypoint/CHANGE.yaml",
+    "changes/M25-agent-onboarding-entrypoint/WORK_ITEMS.yaml",
+    "changes/M26-non-destructive-multi-platform-sync/CHANGE.yaml",
+    "changes/M26-non-destructive-multi-platform-sync/WORK_ITEMS.yaml",
+    "changes/M27-agent-brief-status/CHANGE.yaml",
+    "changes/M27-agent-brief-status/WORK_ITEMS.yaml",
+    "changes/M28-cli-json-report-surface/CHANGE.yaml",
+    "changes/M28-cli-json-report-surface/WORK_ITEMS.yaml",
+    "changes/M29-command-readiness-check/CHANGE.yaml",
+    "changes/M29-command-readiness-check/WORK_ITEMS.yaml",
+    "changes/M30-artifact-summary-health/CHANGE.yaml",
+    "changes/M30-artifact-summary-health/WORK_ITEMS.yaml",
+    "changes/M31-unified-health-semantics/CHANGE.yaml",
+    "changes/M31-unified-health-semantics/WORK_ITEMS.yaml",
+    "changes/M32-agent-inspect-entry/CHANGE.yaml",
+    "changes/M32-agent-inspect-entry/WORK_ITEMS.yaml",
+    "changes/M33-summary-refresh-command/CHANGE.yaml",
+    "changes/M33-summary-refresh-command/WORK_ITEMS.yaml",
+    "changes/M34-agent-context-packet/CHANGE.yaml",
+    "changes/M34-agent-context-packet/WORK_ITEMS.yaml",
+    "changes/M35-artifact-draft-command/CHANGE.yaml",
+    "changes/M35-artifact-draft-command/WORK_ITEMS.yaml",
+    "changes/M36-artifact-register-command/CHANGE.yaml",
+    "changes/M36-artifact-register-command/WORK_ITEMS.yaml",
+    "changes/M37-managed-clean-boundary/CHANGE.yaml",
+    "changes/M37-managed-clean-boundary/WORK_ITEMS.yaml",
+    "changes/M38-json-exit-code-semantics/CHANGE.yaml",
+    "changes/M38-json-exit-code-semantics/WORK_ITEMS.yaml",
+    "changes/M39-stage-readiness-gates/CHANGE.yaml",
+    "changes/M39-stage-readiness-gates/WORK_ITEMS.yaml",
+    "changes/M40-compact-context-default/CHANGE.yaml",
+    "changes/M40-compact-context-default/WORK_ITEMS.yaml",
+    "changes/M41-compact-command-audit-slice/CHANGE.yaml",
+    "changes/M41-compact-command-audit-slice/WORK_ITEMS.yaml",
+    "changes/M42-health-errors-surface/CHANGE.yaml",
+    "changes/M42-health-errors-surface/WORK_ITEMS.yaml",
+    "changes/M43-summary-quality-signals/CHANGE.yaml",
+    "changes/M43-summary-quality-signals/WORK_ITEMS.yaml",
+    "changes/M44-clean-sync-recovery-e2e/CHANGE.yaml",
+    "changes/M44-clean-sync-recovery-e2e/WORK_ITEMS.yaml",
+    "changes/M45-sync-state-reconciliation/CHANGE.yaml",
+    "changes/M45-sync-state-reconciliation/WORK_ITEMS.yaml",
+    "changes/M46-strict-summary-quality/CHANGE.yaml",
+    "changes/M46-strict-summary-quality/WORK_ITEMS.yaml",
+    "changes/M47-doctor-handoff-quality-split/CHANGE.yaml",
+    "changes/M47-doctor-handoff-quality-split/WORK_ITEMS.yaml",
+    "changes/M48-handoff-quality-summary/CHANGE.yaml",
+    "changes/M48-handoff-quality-summary/WORK_ITEMS.yaml",
+    "changes/M49-single-handoff-entry/CHANGE.yaml",
+    "changes/M49-single-handoff-entry/WORK_ITEMS.yaml",
+    "changes/M50-context-handoff-mode/CHANGE.yaml",
+    "changes/M50-context-handoff-mode/WORK_ITEMS.yaml",
+    "changes/M51-agent-first-e2e-suite/CHANGE.yaml",
+    "changes/M51-agent-first-e2e-suite/WORK_ITEMS.yaml",
+    "changes/M52-default-sync-adapter-recovery/CHANGE.yaml",
+    "changes/M52-default-sync-adapter-recovery/WORK_ITEMS.yaml",
 ];
 const IGNORED_DIRS = new Set([".git", "node_modules", "dist", "build", "coverage"]);
 const COMMON_REQUIRED = ["schema_version", "contract_id", "contract_type", "title", "status"];
+const CODEX_SKILL_METADATA_FIELDS = [
+    "generated_by",
+    "adapter",
+    "adapter_version",
+    "template_id",
+    "source_command_id",
+    "semantic_trigger",
+    "skill_name",
+];
+const REQUIRED_CODEX_SKILL_BLOCKS = [
+    "user_behavior",
+    "agent_protocol",
+    "working_protocol",
+    "artifact_checkpoint",
+    "codex_skill",
+];
+const HIGH_RISK_REPORT_SECTIONS = [
+    "Trigger",
+    "Change",
+    "Concrete Risks",
+    "Decision Options",
+    "Recommended Path",
+    "Guardrails",
+    "Go Criteria",
+    "Stop Criteria",
+    "Validation Expectations",
+];
 export async function validateRepositoryContracts(rootInput) {
     const root = resolve(rootInput);
     const errors = [];
     await validateRequiredFiles(root, errors);
     await validateJsonSchemas(root, errors);
     await validateYamlContracts(root, errors);
+    await validateGeneratedCodexSkills(root, errors);
+    await validateGeneratedSurfaceParity(root, errors);
+    await validateHighRiskDecisionReports(root, errors);
     return { ok: errors.length === 0, errors };
 }
 async function validateRequiredFiles(root, errors) {
@@ -171,417 +284,2267 @@ async function validateYamlContracts(root, errors) {
             validatePrototype(root, path, data, errors);
             validateArtifactContracts(root, path, data, errors);
             validateDisclosureLevels(root, path, data, errors);
+            validateConfig(root, path, data, errors);
+            validateCurrentState(root, path, data, errors);
             validateActivePointer(root, path, data, errors);
             validateDiscoveryArtifact(root, path, data, errors);
             validateWorkflowIndex(root, path, data, errors);
             validateContractGraph(root, path, data, errors);
+            await validateCandidateChanges(root, path, data, errors);
+            validateLocalCommitEvidence(root, path, data, errors);
         }
     }
 }
-function validateCommonContract(root, path, data, errors) {
-    if (!isRecord(data)) {
+async function validateGeneratedCodexSkills(root, errors) {
+    const manifestPath = join(root, ".agents", "openworkflow-adapter.yaml");
+    if (!(await exists(manifestPath))) {
         return;
     }
-    if (!("contract_type" in data) && !("schema_version" in data)) {
+    const label = relative(root, manifestPath);
+    let manifest;
+    try {
+        manifest = parseYaml(await readFile(manifestPath, "utf8"));
+    }
+    catch (error) {
+        errors.push(`${label} is not valid YAML for generated skill validation: ${messageFor(error)}`);
         return;
     }
-    const label = relative(root, path);
-    for (const key of COMMON_REQUIRED) {
-        if (!(key in data)) {
-            errors.push(`${label} missing contract key ${key}`);
+    if (!isRecord(manifest)) {
+        errors.push(`${label} must be a mapping`);
+        return;
+    }
+    if (manifest.generated_by !== "openworkflow") {
+        errors.push(`${label} generated_by must be openworkflow for Codex skill validation`);
+    }
+    if (manifest.adapter !== "codex") {
+        errors.push(`${label} adapter must be codex for Codex skill validation`);
+    }
+    const adapterVersion = typeof manifest.adapter_version === "string" ? manifest.adapter_version : null;
+    if (!adapterVersion) {
+        errors.push(`${label} adapter_version must be a non-empty string`);
+    }
+    const namespace = typeof manifest.command_namespace === "string" ? manifest.command_namespace : "ow";
+    validateManifestSkillSurface(label, manifest.skill_surface, errors);
+    const commands = manifest.commands;
+    if (!Array.isArray(commands) || commands.length === 0) {
+        errors.push(`${label} commands must be a non-empty list`);
+        return;
+    }
+    for (const [index, command] of commands.entries()) {
+        if (!isRecord(command)) {
+            errors.push(`${label} command ${index} must be a mapping`);
+            continue;
         }
+        await validateGeneratedCodexSkill(root, label, command, namespace, adapterVersion ?? "", errors);
     }
-    if (data.schema_version !== SCHEMA_VERSION) {
-        errors.push(`${label} must use schema_version ${SCHEMA_VERSION}`);
+}
+function validateManifestSkillSurface(label, value, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} skill_surface must be a mapping`);
+        return;
     }
-    for (const listKey of ["depends_on", "produces"]) {
-        const value = data[listKey];
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                if (typeof item !== "string") {
-                    errors.push(`${label} has non-string ${listKey} value`);
-                }
-            }
+    const frontmatter = value.frontmatter;
+    if (!Array.isArray(frontmatter) || !["name", "description", "metadata"].every((field) => frontmatter.includes(field))) {
+        errors.push(`${label} skill_surface.frontmatter must include name, description, and metadata`);
+    }
+    const metadataFields = value.metadata_fields;
+    if (!Array.isArray(metadataFields)) {
+        errors.push(`${label} skill_surface.metadata_fields must list generated metadata fields`);
+        return;
+    }
+    for (const field of CODEX_SKILL_METADATA_FIELDS) {
+        if (!metadataFields.includes(field)) {
+            errors.push(`${label} skill_surface.metadata_fields missing ${field}`);
         }
     }
 }
-function validateChange(root, path, data, errors) {
-    if (basename(path) !== "CHANGE.yaml") {
+async function validateGeneratedCodexSkill(root, manifestLabel, command, namespace, adapterVersion, errors) {
+    const commandId = stringField(command, "id");
+    const trigger = stringField(command, "trigger");
+    const skillName = stringField(command, "skill_name");
+    const skillPath = stringField(command, "skill_path");
+    const commandLabel = `${manifestLabel} command ${commandId || "<unknown>"}`;
+    if (!commandId || !trigger || !skillName || !skillPath) {
+        errors.push(`${commandLabel} must include id, trigger, skill_name, and skill_path`);
         return;
     }
-    for (const key of ["problem", "goals", "non_goals", "affected_paths", "acceptance", "validation"]) {
-        if (!(key in data)) {
-            errors.push(`${relative(root, path)} missing change key ${key}`);
+    const absoluteSkillPath = join(root, skillPath);
+    if (!existsSyncSafe(absoluteSkillPath)) {
+        errors.push(`${commandLabel} references missing generated skill ${skillPath}; update adapter source and run openworkflow sync --tools codex`);
+        return;
+    }
+    let content;
+    try {
+        if (!statSync(absoluteSkillPath).isFile()) {
+            errors.push(`${skillPath} must be a generated skill file`);
+            return;
         }
+        content = await readFile(absoluteSkillPath, "utf8");
     }
-    if (data.contract_type !== "change") {
-        errors.push(`${relative(root, path)} contract_type must be change`);
+    catch (error) {
+        errors.push(`${skillPath} could not be read for generated skill validation: ${messageFor(error)}`);
+        return;
+    }
+    const frontmatter = parseSkillFrontmatter(skillPath, content, errors);
+    if (!frontmatter) {
+        return;
     }
+    validateSkillFrontmatter(skillPath, frontmatter, {
+        adapterVersion,
+        commandId,
+        namespace,
+        skillName,
+        trigger,
+    }, errors);
+    validateSkillGeneratedMarker(skillPath, content, namespace, commandId, errors);
+    validateSkillProtocolBlocks(skillPath, content, errors);
 }
-function validateWorkItems(root, path, data, errors) {
-    if (basename(path) !== "WORK_ITEMS.yaml") {
+function parseSkillFrontmatter(skillPath, content, errors) {
+    if (!content.startsWith("---\n")) {
+        errors.push(`${skillPath} missing SKILL.md frontmatter; update adapter source and run openworkflow sync --tools codex`);
+        return null;
+    }
+    const frontmatterEnd = content.indexOf("\n---\n", 4);
+    if (frontmatterEnd === -1) {
+        errors.push(`${skillPath} has unterminated SKILL.md frontmatter`);
+        return null;
+    }
+    let frontmatter;
+    try {
+        frontmatter = parseYaml(content.slice(4, frontmatterEnd));
+    }
+    catch (error) {
+        errors.push(`${skillPath} has invalid SKILL.md frontmatter YAML: ${messageFor(error)}`);
+        return null;
+    }
+    if (!isRecord(frontmatter)) {
+        errors.push(`${skillPath} SKILL.md frontmatter must be a mapping`);
+        return null;
+    }
+    return frontmatter;
+}
+function validateSkillFrontmatter(skillPath, frontmatter, expected, errors) {
+    if (frontmatter.name !== expected.skillName) {
+        errors.push(`${skillPath} frontmatter.name must be ${expected.skillName}`);
+    }
+    if (!nonEmptyString(frontmatter.description)) {
+        errors.push(`${skillPath} frontmatter.description must be a non-empty string`);
+    }
+    const metadata = frontmatter.metadata;
+    if (!isRecord(metadata)) {
+        errors.push(`${skillPath} missing generated metadata; update adapter source and run openworkflow sync --tools codex`);
         return;
     }
-    const label = relative(root, path);
-    if (data.contract_type !== "work_items") {
-        errors.push(`${label} contract_type must be work_items`);
+    const expectedMetadata = {
+        generated_by: "openworkflow",
+        adapter: "codex",
+        adapter_version: expected.adapterVersion,
+        template_id: `codex.skill.${expected.namespace}.${expected.commandId}`,
+        source_command_id: expected.commandId,
+        semantic_trigger: expected.trigger,
+        skill_name: expected.skillName,
+    };
+    for (const field of CODEX_SKILL_METADATA_FIELDS) {
+        if (metadata[field] !== expectedMetadata[field]) {
+            errors.push(`${skillPath} metadata.${field} must be ${expectedMetadata[field]}`);
+        }
     }
-    const changeContract = data.change_contract;
-    if (typeof changeContract !== "string") {
-        errors.push(`${label} missing change_contract`);
+}
+function validateSkillGeneratedMarker(skillPath, content, namespace, commandId, errors) {
+    if (!content.includes("generated-by: openworkflow")) {
+        errors.push(`${skillPath} missing generated marker; update adapter source and run openworkflow sync --tools codex`);
     }
-    else if (!(existsSyncSafe(join(contractRootFor(root, path), changeContract)) || existsSyncSafe(join(root, changeContract)))) {
-        errors.push(`${label} references missing change_contract ${changeContract}`);
+    const templateMarker = `template-id: codex.skill.${namespace}.${commandId}`;
+    if (!content.includes(templateMarker)) {
+        errors.push(`${skillPath} missing generated marker ${templateMarker}`);
     }
-    const items = data.items;
-    if (!Array.isArray(items) || items.length === 0) {
-        errors.push(`${label} must contain non-empty items`);
+}
+function validateSkillProtocolBlocks(skillPath, content, errors) {
+    if (/<\/?skill(?:\s|>)/.test(content)) {
+        errors.push(`${skillPath} must not use a top-level <skill> XML wrapper; generated skills are Markdown with YAML frontmatter and XML-like protocol blocks`);
+    }
+    for (const tag of REQUIRED_CODEX_SKILL_BLOCKS) {
+        validateRequiredSkillBlock(skillPath, content, tag, errors);
+    }
+}
+function validateRequiredSkillBlock(skillPath, content, tag, errors) {
+    const openTag = `<${tag}>`;
+    const closeTag = `</${tag}>`;
+    const openCount = countOccurrences(content, openTag);
+    const closeCount = countOccurrences(content, closeTag);
+    if (openCount === 0 || closeCount === 0 || openCount !== closeCount) {
+        errors.push(`${skillPath} must contain a balanced <${tag}> protocol block`);
         return;
     }
-    const seen = new Set();
-    items.forEach((item, index) => {
+    if (tag !== "artifact_checkpoint" && (openCount !== 1 || closeCount !== 1)) {
+        errors.push(`${skillPath} must contain exactly one <${tag}> protocol block`);
+        return;
+    }
+    if (content.indexOf(openTag) > content.indexOf(closeTag)) {
+        errors.push(`${skillPath} <${tag}> protocol block closes before it opens`);
+    }
+}
+function countOccurrences(content, needle) {
+    return content.split(needle).length - 1;
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function recordField(record, key) {
+    const value = record[key];
+    return isRecord(value) ? value : {};
+}
+async function validateGeneratedSurfaceParity(root, errors) {
+    const commands = [...getWorkflowCommands()];
+    const commandAudit = await readYamlRecordForParity(root, ".openworkflow/audit/COMMAND_AUDIT_INDEX.yaml", errors);
+    if (commandAudit) {
+        validateCommandAuditParity(".openworkflow/audit/COMMAND_AUDIT_INDEX.yaml", commandAudit.commands, commands, errors);
+    }
+    const contextPackets = await readYamlRecordForParity(root, ".openworkflow/audit/CONTEXT_PACKETS.yaml", errors);
+    if (contextPackets) {
+        validateContextPacketParity(".openworkflow/audit/CONTEXT_PACKETS.yaml", contextPackets.packets, commands, errors);
+    }
+    const codexManifest = await readYamlRecordForParity(root, ".agents/openworkflow-adapter.yaml", errors);
+    if (codexManifest) {
+        await validateCodexManifestParity(root, ".agents/openworkflow-adapter.yaml", codexManifest, commands, errors);
+    }
+}
+async function readYamlRecordForParity(root, relativePath, errors) {
+    const path = join(root, relativePath);
+    if (!(await exists(path))) {
+        return null;
+    }
+    try {
+        const data = parseYaml(await readFile(path, "utf8"));
+        if (isRecord(data)) {
+            return data;
+        }
+        errors.push(`${relativePath} must be a mapping for generated-surface parity validation`);
+    }
+    catch (error) {
+        errors.push(`${relativePath} is not valid YAML for generated-surface parity validation: ${messageFor(error)}`);
+    }
+    return null;
+}
+function validateCommandAuditParity(label, value, commands, errors) {
+    const records = recordsById(label, "commands", value, "id", errors);
+    if (!records) {
+        return;
+    }
+    assertCommandIds(label, records, commands, errors);
+    for (const command of commands) {
+        const actual = records.get(command.id);
+        if (!actual) {
+            continue;
+        }
+        assertField(label, command.id, actual, "trigger", command.trigger, errors);
+        assertField(label, command.id, actual, "stage", command.stage, errors);
+        assertField(label, command.id, actual, "visibility", command.visibility, errors);
+        assertField(label, command.id, actual, "depth", command.protocol?.depth ?? "shallow", errors);
+        assertField(label, command.id, actual, "context_packet", `context:${command.id}`, errors);
+        assertStringArray(label, command.id, actual, "allowed_outputs", command.protocol?.allowedOutputs ?? command.targetArtifacts, errors);
+        assertStringArray(label, command.id, actual, "conditional_outputs", command.protocol?.conditionalOutputs ?? [], errors);
+        assertStringArray(label, command.id, actual, "forbidden_outputs", command.protocol?.forbiddenOutputs ?? [], errors);
+        assertStringArray(label, command.id, actual, "handoff_commands", command.protocol?.handoffCommands ?? [], errors);
+    }
+}
+function validateContextPacketParity(label, value, commands, errors) {
+    const records = recordsById(label, "packets", value, "packet_id", errors);
+    if (!records) {
+        return;
+    }
+    const expectedIds = new Set(commands.map((command) => `context:${command.id}`));
+    assertIdSet(label, "packets", records, expectedIds, errors);
+    for (const command of commands) {
+        const packetId = `context:${command.id}`;
+        const actual = records.get(packetId);
+        if (!actual) {
+            continue;
+        }
+        assertField(label, packetId, actual, "command", command.trigger, errors);
+        assertField(label, packetId, actual, "visibility", command.visibility, errors);
+        assertStringArray(label, packetId, actual, "required", command.protocol?.requiredContext ?? [".openworkflow/workflow/WORKFLOW_INDEX.yaml"], errors);
+        assertStringArray(label, packetId, actual, "optional", command.protocol?.optionalContext ?? [], errors);
+        assertStringArray(label, packetId, actual, "forbidden", command.protocol?.forbiddenContext ?? [], errors);
+        assertStringArray(label, packetId, actual, "conditional_outputs", command.protocol?.conditionalOutputs ?? [], errors);
+    }
+}
+async function validateCodexManifestParity(root, label, manifest, commands, errors) {
+    const records = recordsById(label, "commands", manifest.commands, "id", errors);
+    if (!records) {
+        return;
+    }
+    assertCommandIds(label, records, commands, errors);
+    const expectedGeneratedFiles = new Set();
+    for (const command of commands) {
+        const actual = records.get(command.id);
+        if (!actual) {
+            continue;
+        }
+        const skillName = `ow-${command.id}`;
+        const skillPath = `.agents/skills/${skillName}/SKILL.md`;
+        const interfacePath = `.agents/skills/${skillName}/agents/openai.yaml`;
+        expectedGeneratedFiles.add(skillPath);
+        expectedGeneratedFiles.add(interfacePath);
+        assertField(label, command.id, actual, "trigger", command.trigger, errors);
+        assertField(label, command.id, actual, "visibility", command.visibility, errors);
+        assertField(label, command.id, actual, "skill_name", skillName, errors);
+        assertField(label, command.id, actual, "explicit_invocation", `$${skillName}`, errors);
+        assertField(label, command.id, actual, "skill_path", skillPath, errors);
+        assertField(label, command.id, actual, "interface_path", interfacePath, errors);
+        assertStringArray(label, command.id, actual, "legacy_triggers", command.legacyTriggers, errors);
+    }
+    await validateManifestGeneratedFiles(root, label, manifest.generated_files, expectedGeneratedFiles, errors);
+}
+async function validateManifestGeneratedFiles(root, label, value, expectedGeneratedFiles, errors) {
+    if (!Array.isArray(value)) {
+        errors.push(`${label} generated_files must be a list; update adapter source and run openworkflow sync --tools codex`);
+        return;
+    }
+    const actual = new Set();
+    for (const item of value) {
+        if (typeof item !== "string") {
+            errors.push(`${label} generated_files contains a non-string path`);
+            continue;
+        }
+        actual.add(item);
+        const path = join(root, item);
+        if (!existsSyncSafe(path)) {
+            errors.push(`${label} generated_files references missing ${item}; update adapter source and run openworkflow sync --tools codex`);
+            continue;
+        }
+        const content = await readFile(path, "utf8");
+        if (!content.includes("generated-by: openworkflow")) {
+            errors.push(`${label} generated_files ${item} is missing generated marker; update adapter source and run openworkflow sync --tools codex`);
+        }
+    }
+    for (const expected of expectedGeneratedFiles) {
+        if (!actual.has(expected)) {
+            errors.push(`${label} generated_files missing ${expected}; update adapter source and run openworkflow sync --tools codex`);
+        }
+    }
+}
+function recordsById(label, collectionName, value, idKey, errors) {
+    if (!Array.isArray(value)) {
+        errors.push(`${label} ${collectionName} must be a list for generated-surface parity validation`);
+        return null;
+    }
+    const records = new Map();
+    value.forEach((item, index) => {
         if (!isRecord(item)) {
-            errors.push(`${label} item ${index} is not a mapping`);
+            errors.push(`${label} ${collectionName}[${index}] must be a mapping`);
             return;
         }
-        const taskId = item.task_id;
-        if (typeof taskId !== "string" || taskId.length === 0) {
-            errors.push(`${label} item ${index} missing task_id`);
+        const id = item[idKey];
+        if (typeof id !== "string" || id.length === 0) {
+            errors.push(`${label} ${collectionName}[${index}] missing ${idKey}`);
             return;
         }
-        if (seen.has(taskId)) {
-            errors.push(`${label} duplicate task_id ${taskId}`);
-        }
-        seen.add(taskId);
-        for (const key of ["title", "status", "owned_paths", "acceptance"]) {
-            if (!(key in item)) {
-                errors.push(`${label} ${taskId} missing ${key}`);
-            }
+        if (records.has(id)) {
+            errors.push(`${label} ${collectionName} duplicate ${idKey} ${id}`);
+            return;
         }
+        records.set(id, item);
     });
+    return records;
 }
-function validateValidation(root, path, data, errors) {
-    if (basename(path) !== "VALIDATION.yaml") {
-        return;
-    }
-    const label = relative(root, path);
-    if (data.contract_type !== "validation") {
-        errors.push(`${label} contract_type must be validation`);
+function assertCommandIds(label, records, commands, errors) {
+    assertIdSet(label, "commands", records, new Set(commands.map((command) => command.id)), errors);
+}
+function assertIdSet(label, collectionName, records, expectedIds, errors) {
+    for (const expected of expectedIds) {
+        if (!records.has(expected)) {
+            errors.push(`${label} ${collectionName} missing ${expected}; update source registry and run openworkflow sync --tools codex`);
+        }
     }
-    validateValidationTarget(label, data, errors);
-    for (const key of [
-        "core_question",
-        "feature_classification",
-        "critical_assumptions",
-        "prototype_scope",
-        "acceptance",
-        "decision_options",
-    ]) {
-        if (!(key in data)) {
-            errors.push(`${label} missing validation key ${key}`);
+    for (const actual of records.keys()) {
+        if (!expectedIds.has(actual)) {
+            errors.push(`${label} ${collectionName} has unexpected ${actual}; update source registry and run openworkflow sync --tools codex`);
         }
     }
-    const decisionOptions = data.decision_options;
-    if (Array.isArray(decisionOptions)) {
-        const allowed = new Set(["continue", "revise", "pivot", "stop", "needs_more_evidence"]);
-        for (const option of decisionOptions) {
-            if (typeof option !== "string" || !allowed.has(option)) {
-                errors.push(`${label} has invalid decision option ${String(option)}`);
+}
+function assertField(label, id, record, field, expected, errors) {
+    if (record[field] !== expected) {
+        errors.push(`${label} ${id} ${field} must be ${expected}; update source registry and run openworkflow sync --tools codex`);
+    }
+}
+function assertStringArray(label, id, record, field, expected, errors) {
+    const actual = record[field];
+    if (!Array.isArray(actual) || !actual.every((item) => typeof item === "string")) {
+        errors.push(`${label} ${id} ${field} must be a string list; update source registry and run openworkflow sync --tools codex`);
+        return;
+    }
+    if (!stringArraysEqual(actual, expected)) {
+        errors.push(`${label} ${id} ${field} drifted from source registry; update source registry and run openworkflow sync --tools codex`);
+    }
+}
+function stringArraysEqual(actual, expected) {
+    return actual.length === expected.length && actual.every((item, index) => item === expected[index]);
+}
+async function validateHighRiskDecisionReports(root, errors) {
+    for (const path of await findFiles(root, (entry) => entry === "HIGH_RISK_DECISION_REPORT.md")) {
+        const label = relative(root, path);
+        const content = await readFile(path, "utf8");
+        for (const section of HIGH_RISK_REPORT_SECTIONS) {
+            if (!hasMarkdownHeading(content, section)) {
+                errors.push(`${label} missing high-risk report section: ${section}`);
             }
         }
+        if (!content.includes("explicit") || !content.includes("approval")) {
+            errors.push(`${label} must state that implementation resumes only after explicit approval`);
+        }
     }
 }
-function validatePrototype(root, path, data, errors) {
-    if (basename(path) !== "TODO.yaml" || data.contract_type !== "prototype") {
+function hasMarkdownHeading(content, heading) {
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`^#{2,4}\\s+.*${escaped}.*$`, "m").test(content);
+}
+function validateConfig(root, path, data, errors) {
+    if (basename(path) !== "config.yaml") {
         return;
     }
     const label = relative(root, path);
-    for (const key of [
-        "validation_contract",
-        "core_question",
-        "prototype_scope",
-        "todo",
-        "acceptance",
-        "artifact",
-        "decision_handoff",
-    ]) {
+    if (!nonEmptyString(data.project_slug) || data.project_slug === "project") {
+        errors.push(`${label} project_slug must be a useful non-empty slug`);
+    }
+    if (!nonEmptyString(data.project_title) || data.project_title === ".") {
+        errors.push(`${label} project_title must be a useful non-empty title`);
+    }
+}
+function validateCurrentState(root, path, data, errors) {
+    if (basename(path) !== "CURRENT_STATE.yaml") {
+        return;
+    }
+    const label = relative(root, path);
+    for (const key of ["active_stage", "next_command", "blocked_by", "read_this_first", "last_decision"]) {
         if (!(key in data)) {
-            errors.push(`${label} missing prototype key ${key}`);
+            errors.push(`${label} missing current state key ${key}`);
         }
     }
-    validatePrototypeScope(label, data.prototype_scope, errors);
-    validatePrototypeTodo(label, data.todo, errors);
-    const artifact = data.artifact;
-    if (isRecord(artifact) && typeof artifact.path === "string" && !existsSyncSafe(join(contractRootFor(root, path), artifact.path))) {
-        errors.push(`${label} references missing artifact path ${artifact.path}`);
+    if (!nonEmptyString(data.active_stage)) {
+        errors.push(`${label} active_stage must be a non-empty string`);
     }
-    const decisionHandoff = data.decision_handoff;
-    if (isRecord(decisionHandoff) && decisionHandoff.requires_user_review !== true) {
-        errors.push(`${label} decision_handoff.requires_user_review must be true`);
+    if (typeof data.next_command !== "string" && data.next_command !== null) {
+        errors.push(`${label} next_command must be a string or null`);
+    }
+    for (const key of ["blocked_by", "read_this_first"]) {
+        if (!Array.isArray(data[key])) {
+            errors.push(`${label} ${key} must be an array`);
+        }
+    }
+    if (!isRecord(data.last_decision)) {
+        errors.push(`${label} last_decision must be a mapping`);
     }
 }
-function validateArtifactContracts(root, path, data, errors) {
-    if (basename(path) !== "ARTIFACT_CONTRACTS.yaml") {
+async function validateCandidateChanges(root, path, data, errors) {
+    if (basename(path) !== "CANDIDATE_CHANGES.yaml") {
         return;
     }
     const label = relative(root, path);
-    const artifacts = data.artifacts;
-    if (!Array.isArray(artifacts) || artifacts.length === 0) {
-        errors.push(`${label} must contain artifacts`);
+    if (data.planning_artifact_type !== "candidate_changes") {
         return;
     }
-    const missing = new Set(["vision_session", "validation_target", "prototype_evidence", "decision_record", "product_design"]);
-    artifacts.forEach((artifact, index) => {
-        if (!isRecord(artifact)) {
-            errors.push(`${label} artifact ${index} is not a mapping`);
-            return;
-        }
-        if (typeof artifact.artifact_type === "string") {
-            missing.delete(artifact.artifact_type);
-        }
-        for (const key of [
-            "artifact_type",
-            "contract_type",
-            "command",
-            "source_of_truth_path",
-            "template_path",
-            "read_policy",
-            "active_pointer",
-            "required_keys",
-        ]) {
-            if (!(key in artifact)) {
-                errors.push(`${label} artifact ${index} missing ${key}`);
-            }
+    const queuePolicy = data.queue_policy;
+    if (isRecord(queuePolicy) && "branch_boundary" in queuePolicy) {
+        validateBranchBoundary(label, queuePolicy.branch_boundary, errors);
+    }
+    if (isRecord(queuePolicy) && "branch_identity_exception" in queuePolicy) {
+        validateBranchIdentityException(label, queuePolicy.branch_identity_exception, errors);
+    }
+    const strictCommitGate = isRecord(queuePolicy) && queuePolicy.selected_change_commit_gate === "strict";
+    const strictLifecycleGate = isRecord(queuePolicy) && queuePolicy.git_lifecycle_gate === "strict";
+    if (strictLifecycleGate) {
+        validateStrictGitLifecycle(root, label, data, queuePolicy, errors);
+    }
+    if (!Array.isArray(data.changes)) {
+        errors.push(`${label} changes must be a list`);
+        return;
+    }
+    for (const candidate of data.changes) {
+        if (!isRecord(candidate)) {
+            errors.push(`${label} changes entries must be mappings`);
+            continue;
         }
-        validateArtifactContractMetadata(label, index, artifact, errors);
-    });
-    for (const artifactType of [...missing].sort()) {
-        errors.push(`${label} missing artifact_type ${artifactType}`);
+        validateCandidateCompletionEvidence(root, label, candidate, errors, { strictCommitGate });
     }
 }
-function validateArtifactContractMetadata(label, index, artifact, errors) {
-    const readPolicy = artifact.read_policy;
-    if (isRecord(readPolicy)) {
-        for (const key of ["load_by_default", "agent_read_order", "max_yaml_lines", "max_note_lines", "raw_evidence"]) {
-            if (!(key in readPolicy)) {
-                errors.push(`${label} artifact ${index} read_policy missing ${key}`);
-            }
+function validateStrictGitLifecycle(root, label, data, queuePolicy, errors) {
+    const planId = stringField(data, "plan_id");
+    const branchBoundary = stringField(queuePolicy, "branch_boundary");
+    if (!branchBoundary) {
+        errors.push(`${label} strict git lifecycle requires queue_policy.branch_boundary`);
+    }
+    else if (planId) {
+        const branchIdentity = assessBranchIdentity(planId, branchBoundary, branchIdentityExceptionFrom(queuePolicy.branch_identity_exception), "validate");
+        errors.push(...branchIdentity.errors.map((error) => `${label} ${error}`));
+    }
+    const status = stringField(data, "status");
+    if (status === "completed" || status === "done") {
+        validateCompletedQueuePrEvidence(root, label, data, errors);
+    }
+}
+function validateCompletedQueuePrEvidence(root, label, data, errors) {
+    const evidencePath = queuePrEvidencePath(data);
+    if (!evidencePath) {
+        errors.push(`${label} strict git lifecycle completed queue must include DRAFT_PR_OPERATION_EVIDENCE.yaml`);
+        return;
+    }
+    if (isExternalRef(evidencePath) || evidencePath.startsWith("commit:")) {
+        errors.push(`${label} DRAFT_PR_OPERATION_EVIDENCE.yaml path must be repo-relative`);
+        return;
+    }
+    const resolved = resolve(root, evidencePath);
+    if (resolved !== root && !resolved.startsWith(`${root}/`)) {
+        errors.push(`${label} DRAFT_PR_OPERATION_EVIDENCE.yaml path escapes repository root`);
+        return;
+    }
+    if (!existsSyncSafe(resolved)) {
+        errors.push(`${label} references missing DRAFT_PR_OPERATION_EVIDENCE.yaml ${evidencePath}`);
+    }
+}
+function queuePrEvidencePath(data) {
+    const completion = recordField(data, "completion");
+    const explicit = stringField(completion, "draft_pr_evidence_path")
+        ?? stringField(completion, "draft_pr_evidence")
+        ?? stringField(completion, "pr_evidence_path")
+        ?? stringField(completion, "pr_evidence");
+    if (explicit && explicit.endsWith("DRAFT_PR_OPERATION_EVIDENCE.yaml")) {
+        return explicit;
+    }
+    const evidence = Array.isArray(completion.evidence) ? completion.evidence : [];
+    for (const item of evidence) {
+        if (typeof item === "string" && item.endsWith("DRAFT_PR_OPERATION_EVIDENCE.yaml")) {
+            return item;
+        }
+    }
+    return null;
+}
+function validateBranchIdentityException(label, value, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} queue_policy.branch_identity_exception must be a mapping when present`);
+        return;
+    }
+    if (value.mode !== "temporary_continuation_branch") {
+        errors.push(`${label} queue_policy.branch_identity_exception.mode must be temporary_continuation_branch`);
+    }
+    if (value.approved !== true) {
+        errors.push(`${label} queue_policy.branch_identity_exception.approved must be true`);
+    }
+    if (!Array.isArray(value.allowed_operations) || !value.allowed_operations.every((item) => typeof item === "string")) {
+        errors.push(`${label} queue_policy.branch_identity_exception.allowed_operations must be a string list`);
+    }
+    if (!nonEmptyString(value.reason)) {
+        errors.push(`${label} queue_policy.branch_identity_exception.reason must explain the temporary continuation branch`);
+    }
+}
+function validateBranchBoundary(label, value, errors) {
+    if (!nonEmptyString(value)) {
+        errors.push(`${label} queue_policy.branch_boundary must be a non-empty string when present`);
+        return;
+    }
+    const branch = String(value).trim();
+    if (branch !== value || branch.includes(" ") || branch.startsWith("/") || branch.endsWith("/")) {
+        errors.push(`${label} queue_policy.branch_boundary must be a branch-like string without spaces or leading/trailing slashes`);
+    }
+}
+function validateCandidateCompletionEvidence(root, label, candidate, errors, options) {
+    if (candidate.status !== "done") {
+        return;
+    }
+    const id = typeof candidate.id === "string" ? candidate.id : "<unknown>";
+    const completion = candidate.completion;
+    if (!isRecord(completion)) {
+        errors.push(`${label} ${id} done candidate must include completion evidence`);
+        return;
+    }
+    const evidence = completion.evidence;
+    if (!Array.isArray(evidence) || evidence.length === 0) {
+        errors.push(`${label} ${id} completion.evidence must be a non-empty list`);
+        return;
+    }
+    for (const item of evidence) {
+        if (typeof item !== "string") {
+            errors.push(`${label} ${id} completion.evidence values must be strings`);
+            continue;
+        }
+        if (item.startsWith("commit:") && !/^commit:\s+[0-9a-f]{7,40}$/i.test(item)) {
+            errors.push(`${label} ${id} completion commit evidence must use 'commit: <7-40 hex chars>'`);
+        }
+    }
+    const selectedChangeId = stringField(recordField(candidate, "selection"), "selected_change_id");
+    const implementationChangedFiles = completion.implementation_changed_files;
+    if (implementationChangedFiles === false) {
+        if (!nonEmptyString(completion.commit_not_required_reason)) {
+            errors.push(`${label} ${id} planning-only completion must include commit_not_required_reason`);
+        }
+        return;
+    }
+    if (implementationChangedFiles === true) {
+        validateRequiredLocalCommitEvidence(root, label, id, completion, evidence, errors);
+        return;
+    }
+    if (options.strictCommitGate && selectedChangeId) {
+        errors.push(`${label} ${id} strict selected-change completion must set implementation_changed_files true or false`);
+    }
+}
+function validateRequiredLocalCommitEvidence(root, label, candidateId, completion, evidence, errors) {
+    const evidencePath = localCommitEvidencePath(completion, evidence);
+    if (!evidencePath) {
+        errors.push(`${label} ${candidateId} implementation completion must include LOCAL_COMMIT_EVIDENCE.yaml`);
+        return;
+    }
+    if (isExternalRef(evidencePath) || evidencePath.startsWith("commit:")) {
+        errors.push(`${label} ${candidateId} LOCAL_COMMIT_EVIDENCE.yaml path must be repo-relative`);
+        return;
+    }
+    const resolved = resolve(root, evidencePath);
+    if (resolved !== root && !resolved.startsWith(`${root}/`)) {
+        errors.push(`${label} ${candidateId} LOCAL_COMMIT_EVIDENCE.yaml path escapes repository root`);
+        return;
+    }
+    if (!existsSyncSafe(resolved)) {
+        errors.push(`${label} ${candidateId} references missing LOCAL_COMMIT_EVIDENCE.yaml ${evidencePath}`);
+    }
+}
+function localCommitEvidencePath(completion, evidence) {
+    const explicit = stringField(completion, "local_commit_evidence_path") ?? stringField(completion, "local_commit_evidence");
+    if (explicit && explicit.endsWith("LOCAL_COMMIT_EVIDENCE.yaml")) {
+        return explicit;
+    }
+    for (const item of evidence) {
+        if (typeof item === "string" && item.endsWith("LOCAL_COMMIT_EVIDENCE.yaml")) {
+            return item;
+        }
+    }
+    return null;
+}
+function validateLocalCommitEvidence(root, path, data, errors) {
+    if (basename(path) !== "LOCAL_COMMIT_EVIDENCE.yaml") {
+        return;
+    }
+    const label = relative(root, path);
+    const planId = stringField(data, "source_plan_id") ?? stringField(data, "plan_id");
+    const candidateId = stringField(data, "source_candidate_id") ?? stringField(data, "candidate_id");
+    const selectedChangeId = stringField(data, "selected_change_id") ?? stringField(data, "change_id");
+    const commit = stringField(data, "primary_commit") ?? stringField(data, "implementation_commit") ?? stringField(data, "commit");
+    if (!planId) {
+        errors.push(`${label} missing source_plan_id or plan_id`);
+    }
+    if (!candidateId) {
+        errors.push(`${label} missing source_candidate_id or candidate_id`);
+    }
+    if (!selectedChangeId) {
+        errors.push(`${label} missing selected_change_id or change_id`);
+    }
+    if (!commit || !/^[0-9a-f]{7,40}$/i.test(commit)) {
+        errors.push(`${label} must include primary_commit or implementation_commit with a 7-40 character git hash`);
+    }
+    if (!hasValidationEvidence(data)) {
+        errors.push(`${label} must include validation_evidence, validations, or validation.commands_run`);
+    }
+    validateOptionalCoderEvidence(label, data.coder_evidence, errors);
+}
+function hasValidationEvidence(data) {
+    if (Array.isArray(data.validation_evidence) && data.validation_evidence.some((item) => typeof item === "string" && item.trim().length > 0)) {
+        return true;
+    }
+    if (Array.isArray(data.validations) && data.validations.some((item) => typeof item === "string" && item.trim().length > 0)) {
+        return true;
+    }
+    const validation = recordField(data, "validation");
+    return Array.isArray(validation.commands_run) && validation.commands_run.some((item) => typeof item === "string" && item.trim().length > 0);
+}
+function validateOptionalCoderEvidence(label, value, errors) {
+    if (value === undefined || value === null) {
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(`${label} coder_evidence must be a mapping when present`);
+        return;
+    }
+    const status = stringField(value, "status");
+    if (!status) {
+        errors.push(`${label} coder_evidence.status must be recorded, skipped, or not_applicable`);
+    }
+    else if (!["recorded", "skipped", "not_applicable"].includes(status)) {
+        errors.push(`${label} coder_evidence.status has invalid value ${status}`);
+    }
+    const enforcement = stringField(value, "enforcement");
+    if (enforcement && enforcement !== "guidance_only") {
+        errors.push(`${label} coder_evidence.enforcement must be guidance_only when present`);
+    }
+    const evidenceKeys = ["preflight", "red_evidence", "green_evidence", "self_check", "validation_ladder", "lessons"];
+    let hasEvidence = false;
+    for (const key of evidenceKeys) {
+        const field = value[key];
+        if (field === undefined || field === null) {
+            continue;
+        }
+        if (!Array.isArray(field)) {
+            errors.push(`${label} coder_evidence.${key} must be a list of non-empty strings when present`);
+            continue;
+        }
+        for (const item of field) {
+            if (!nonEmptyString(item)) {
+                errors.push(`${label} coder_evidence.${key} values must be non-empty strings`);
+            }
+        }
+        if (field.some((item) => nonEmptyString(item))) {
+            hasEvidence = true;
+        }
+    }
+    if (status === "recorded" && !hasEvidence) {
+        errors.push(`${label} coder_evidence.status recorded requires at least one evidence list entry`);
+    }
+    const notes = value.notes;
+    if (notes !== undefined && notes !== null && !nonEmptyString(notes)) {
+        errors.push(`${label} coder_evidence.notes must be a non-empty string when present`);
+    }
+}
+function validateCommonContract(root, path, data, errors) {
+    if (!isRecord(data)) {
+        return;
+    }
+    if (!("contract_type" in data) && !("schema_version" in data)) {
+        return;
+    }
+    const label = relative(root, path);
+    for (const key of COMMON_REQUIRED) {
+        if (!(key in data)) {
+            errors.push(`${label} missing contract key ${key}`);
+        }
+    }
+    if (data.schema_version !== SCHEMA_VERSION) {
+        errors.push(`${label} must use schema_version ${SCHEMA_VERSION}`);
+    }
+    for (const listKey of ["depends_on", "produces"]) {
+        const value = data[listKey];
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (typeof item !== "string") {
+                    errors.push(`${label} has non-string ${listKey} value`);
+                }
+            }
+        }
+    }
+}
+function validateChange(root, path, data, errors) {
+    if (basename(path) !== "CHANGE.yaml") {
+        return;
+    }
+    for (const key of ["problem", "goals", "non_goals", "affected_paths", "acceptance", "validation"]) {
+        if (!(key in data)) {
+            errors.push(`${relative(root, path)} missing change key ${key}`);
+        }
+    }
+    if (data.contract_type !== "change") {
+        errors.push(`${relative(root, path)} contract_type must be change`);
+    }
+}
+function validateWorkItems(root, path, data, errors) {
+    if (basename(path) !== "WORK_ITEMS.yaml") {
+        return;
+    }
+    const label = relative(root, path);
+    if (data.contract_type !== "work_items") {
+        errors.push(`${label} contract_type must be work_items`);
+    }
+    const changeContract = data.change_contract;
+    if (typeof changeContract !== "string") {
+        errors.push(`${label} missing change_contract`);
+    }
+    else if (!(existsSyncSafe(join(contractRootFor(root, path), changeContract)) || existsSyncSafe(join(root, changeContract)))) {
+        errors.push(`${label} references missing change_contract ${changeContract}`);
+    }
+    const items = data.items;
+    if (!Array.isArray(items) || items.length === 0) {
+        errors.push(`${label} must contain non-empty items`);
+        return;
+    }
+    const seen = new Set();
+    items.forEach((item, index) => {
+        if (!isRecord(item)) {
+            errors.push(`${label} item ${index} is not a mapping`);
+            return;
+        }
+        const taskId = item.task_id;
+        if (typeof taskId !== "string" || taskId.length === 0) {
+            errors.push(`${label} item ${index} missing task_id`);
+            return;
+        }
+        if (seen.has(taskId)) {
+            errors.push(`${label} duplicate task_id ${taskId}`);
+        }
+        seen.add(taskId);
+        for (const key of ["title", "status", "owned_paths", "acceptance"]) {
+            if (!(key in item)) {
+                errors.push(`${label} ${taskId} missing ${key}`);
+            }
+        }
+    });
+}
+function validateValidation(root, path, data, errors) {
+    if (basename(path) !== "VALIDATION.yaml") {
+        return;
+    }
+    const label = relative(root, path);
+    if (data.contract_type !== "validation") {
+        errors.push(`${label} contract_type must be validation`);
+    }
+    validateValidationTarget(label, data, errors);
+    for (const key of [
+        "core_question",
+        "feature_classification",
+        "critical_assumptions",
+        "prototype_scope",
+        "acceptance",
+        "decision_options",
+    ]) {
+        if (!(key in data)) {
+            errors.push(`${label} missing validation key ${key}`);
+        }
+    }
+    const decisionOptions = data.decision_options;
+    if (Array.isArray(decisionOptions)) {
+        const allowed = new Set(["continue", "revise", "pivot", "stop", "needs_more_evidence"]);
+        for (const option of decisionOptions) {
+            if (typeof option !== "string" || !allowed.has(option)) {
+                errors.push(`${label} has invalid decision option ${String(option)}`);
+            }
+        }
+    }
+}
+function validatePrototype(root, path, data, errors) {
+    if (basename(path) !== "TODO.yaml" || data.contract_type !== "prototype") {
+        return;
+    }
+    const label = relative(root, path);
+    for (const key of [
+        "validation_contract",
+        "core_question",
+        "prototype_scope",
+        "todo",
+        "acceptance",
+        "artifact",
+        "decision_handoff",
+    ]) {
+        if (!(key in data)) {
+            errors.push(`${label} missing prototype key ${key}`);
+        }
+    }
+    validatePrototypeScope(label, data.prototype_scope, errors);
+    validatePrototypeTodo(label, data.todo, errors);
+    const artifact = data.artifact;
+    if (isRecord(artifact) && typeof artifact.path === "string" && !existsSyncSafe(join(contractRootFor(root, path), artifact.path))) {
+        errors.push(`${label} references missing artifact path ${artifact.path}`);
+    }
+    const decisionHandoff = data.decision_handoff;
+    if (isRecord(decisionHandoff) && decisionHandoff.requires_user_review !== true) {
+        errors.push(`${label} decision_handoff.requires_user_review must be true`);
+    }
+}
+function validateArtifactContracts(root, path, data, errors) {
+    if (basename(path) !== "ARTIFACT_CONTRACTS.yaml") {
+        return;
+    }
+    const label = relative(root, path);
+    const artifacts = data.artifacts;
+    if (!Array.isArray(artifacts) || artifacts.length === 0) {
+        errors.push(`${label} must contain artifacts`);
+        return;
+    }
+    const missing = new Set([
+        "vision_session",
+        "validation_target",
+        "prototype_evidence",
+        "decision_record",
+        "product_design",
+        "production_spec",
+        "production_change",
+        "team_runtime",
+    ]);
+    artifacts.forEach((artifact, index) => {
+        if (!isRecord(artifact)) {
+            errors.push(`${label} artifact ${index} is not a mapping`);
+            return;
+        }
+        if (typeof artifact.artifact_type === "string") {
+            missing.delete(artifact.artifact_type);
+        }
+        for (const key of [
+            "artifact_type",
+            "contract_type",
+            "command",
+            "source_of_truth_path",
+            "template_path",
+            "read_policy",
+            "active_pointer",
+            "required_keys",
+        ]) {
+            if (!(key in artifact)) {
+                errors.push(`${label} artifact ${index} missing ${key}`);
+            }
+        }
+        validateArtifactContractMetadata(label, index, artifact, errors);
+    });
+    for (const artifactType of [...missing].sort()) {
+        errors.push(`${label} missing artifact_type ${artifactType}`);
+    }
+}
+function validateArtifactContractMetadata(label, index, artifact, errors) {
+    const readPolicy = artifact.read_policy;
+    if (isRecord(readPolicy)) {
+        for (const key of ["load_by_default", "agent_read_order", "max_yaml_lines", "max_note_lines", "raw_evidence"]) {
+            if (!(key in readPolicy)) {
+                errors.push(`${label} artifact ${index} read_policy missing ${key}`);
+            }
+        }
+    }
+    else {
+        errors.push(`${label} artifact ${index} read_policy must be a mapping`);
+    }
+    const activePointer = artifact.active_pointer;
+    if (isRecord(activePointer)) {
+        for (const key of ["index_path", "pointer_key", "collection_key", "id_key", "path_key"]) {
+            if (!(key in activePointer)) {
+                errors.push(`${label} artifact ${index} active_pointer missing ${key}`);
+            }
+        }
+    }
+    else {
+        errors.push(`${label} artifact ${index} active_pointer must be a mapping`);
+    }
+    const summaryPolicy = artifact.summary_policy;
+    if (summaryPolicy !== null && summaryPolicy !== undefined) {
+        if (!isRecord(summaryPolicy)) {
+            errors.push(`${label} artifact ${index} summary_policy must be null or a mapping`);
+        }
+        else {
+            for (const key of ["strategy", "path", "load_before_full", "refresh_when"]) {
+                if (!(key in summaryPolicy)) {
+                    errors.push(`${label} artifact ${index} summary_policy missing ${key}`);
+                }
+            }
+        }
+    }
+}
+function validateDisclosureLevels(root, path, data, errors) {
+    if (basename(path) !== "DISCLOSURE_LEVELS.yaml") {
+        return;
+    }
+    const label = relative(root, path);
+    const levels = data.levels;
+    if (!Array.isArray(levels) || levels.length < 5) {
+        errors.push(`${label} must contain disclosure levels 0 through 4`);
+        return;
+    }
+    const seen = new Set();
+    levels.forEach((level, index) => {
+        if (!isRecord(level)) {
+            errors.push(`${label} level ${index} is not a mapping`);
+            return;
+        }
+        if (typeof level.level === "number") {
+            seen.add(level.level);
+        }
+        for (const key of ["name", "default_for_agents", "purpose", "examples"]) {
+            if (!(key in level)) {
+                errors.push(`${label} level ${index} missing ${key}`);
+            }
+        }
+    });
+    for (let level = 0; level <= 4; level += 1) {
+        if (!seen.has(level)) {
+            errors.push(`${label} missing disclosure level ${level}`);
+        }
+    }
+}
+function validateDiscoveryArtifact(root, path, data, errors) {
+    if (data.contract_type === "planning") {
+        return;
+    }
+    if (typeof data.artifact_type !== "string") {
+        return;
+    }
+    const label = relative(root, path);
+    const required = artifactRequiredKeys(data.artifact_type);
+    if (!required) {
+        errors.push(`${label} has unknown artifact_type ${data.artifact_type}`);
+        return;
+    }
+    for (const key of required) {
+        if (!(key in data)) {
+            errors.push(`${label} missing artifact key ${key}`);
+        }
+    }
+    if (data.artifact_type === "validation_target") {
+        validateValidationTarget(label, data, errors);
+    }
+    else if (data.artifact_type === "prototype_evidence") {
+        validatePrototypeEvidence(root, label, data, errors);
+    }
+    else if (data.artifact_type === "decision_record") {
+        validateDecisionRecord(label, data, errors);
+    }
+    else if (data.artifact_type === "product_design") {
+        validateProductDesign(label, data, errors);
+    }
+    else if (data.artifact_type === "production_spec") {
+        validateProductionSpec(label, data, errors);
+    }
+    else if (data.artifact_type === "production_change") {
+        validateProductionChange(label, data, errors);
+    }
+    else if (data.artifact_type === "team_runtime") {
+        validateTeamRuntime(label, data, errors);
+    }
+}
+function artifactRequiredKeys(artifactType) {
+    const requiredByType = {
+        vision_session: ["current_question", "stable_answers", "unresolved_questions", "vision_delta", "handoff"],
+        validation_target: [
+            "trigger",
+            "core_question",
+            "central_uncertainty",
+            "hypothesis",
+            "target_behavior",
+            "feature_classification",
+            "critical_assumptions",
+            "prototype_scope",
+            "prototype_experiment",
+            "observable_signals",
+            "acceptance",
+            "decision_rules",
+            "decision_options",
+            "vision_gaps",
+            "agent_readiness_gate",
+        ],
+        prototype_evidence: [
+            "validation_target",
+            "core_question",
+            "prototype_mode",
+            "prompt_pack_type",
+            "validation_input",
+            "source",
+            "negative_constraints",
+            "review_plan",
+            "result",
+            "handoff",
+        ],
+        decision_record: [
+            "reviewed_evidence",
+            "outcome",
+            "rationale",
+            "accepted_scope",
+            "rejected_scope",
+            "revision_scope",
+            "next_command",
+            "follow_up_questions",
+        ],
+        product_design: [
+            "accepted_prototype_evidence",
+            "personas",
+            "journey_map",
+            "user_stories",
+            "feature_matrix",
+            "kano_classification",
+            "behavior_model",
+            "ux_states",
+            "scope",
+            "open_questions",
+            "conditional_packets",
+            "spec_readiness",
+        ],
+        production_spec: [
+            "source_design",
+            "goal",
+            "scope",
+            "requirements",
+            "interfaces",
+            "acceptance",
+            "verification",
+            "risks",
+            "change_readiness",
+        ],
+        production_change: [
+            "source_spec",
+            "problem",
+            "goals",
+            "non_goals",
+            "affected_paths",
+            "acceptance",
+            "validation",
+            "work_items",
+            "risks",
+            "runtime_readiness",
+        ],
+        team_runtime: [
+            "source_change",
+            "active_work_item",
+            "execution_mode",
+            "work_queue",
+            "agents",
+            "verification",
+            "issues",
+            "checkpoints",
+            "handoff",
+        ],
+    };
+    return requiredByType[artifactType] ?? null;
+}
+function validateValidationTarget(label, data, errors) {
+    validateValidationTrigger(label, data.trigger, errors);
+    const featureClassification = data.feature_classification;
+    if (isRecord(featureClassification)) {
+        for (const key of ["existential", "supporting", "later", "out_of_scope"]) {
+            if (!(key in featureClassification)) {
+                errors.push(`${label} feature_classification missing ${key}`);
+            }
+        }
+    }
+    validatePrototypeScope(label, data.prototype_scope, errors);
+    validatePrototypeExperiment(label, data.prototype_experiment, errors);
+    validateSignalSet(label, "observable_signals", data.observable_signals, ["pass", "fail", "ambiguous"], errors);
+    validateSignalSet(label, "decision_rules", data.decision_rules, ["continue", "revise", "pivot", "stop", "needs_more_evidence"], errors);
+    validateAgentReadinessGate(label, data.agent_readiness_gate, errors);
+}
+function validateValidationTrigger(label, value, errors) {
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const key of ["mode", "requested_command", "reason"]) {
+        if (!(key in value)) {
+            errors.push(`${label} trigger missing ${key}`);
+        }
+    }
+    const mode = String(value.mode ?? "");
+    if (mode && !["user_explicit", "agent_auto"].includes(mode)) {
+        errors.push(`${label} trigger.mode has invalid value ${mode}`);
+    }
+}
+function validatePrototypeExperiment(label, value, errors) {
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const key of ["scenario", "must_show", "must_not_show"]) {
+        if (!(key in value)) {
+            errors.push(`${label} prototype_experiment missing ${key}`);
+        }
+    }
+}
+function validateSignalSet(label, field, value, keys, errors) {
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const key of keys) {
+        if (!(key in value)) {
+            errors.push(`${label} ${field} missing ${key}`);
+        }
+    }
+}
+function validateAgentReadinessGate(label, value, errors) {
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const key of ["status", "blockers", "warnings", "write_authority"]) {
+        if (!(key in value)) {
+            errors.push(`${label} agent_readiness_gate missing ${key}`);
+        }
+    }
+    const status = String(value.status ?? "");
+    if (status && !["missing_validation", "thin_validation", "stale_validation", "ready_for_proto", "return_to_vision"].includes(status)) {
+        errors.push(`${label} agent_readiness_gate.status has invalid value ${status}`);
+    }
+}
+function validatePrototypeScope(label, value, errors) {
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const key of ["include", "exclude"]) {
+        if (!(key in value)) {
+            errors.push(`${label} prototype_scope missing ${key}`);
+        }
+    }
+}
+function validatePrototypeTodo(label, value, errors) {
+    if (!Array.isArray(value) || value.length === 0) {
+        errors.push(`${label} must contain non-empty todo list`);
+        return;
+    }
+    const seen = new Set();
+    value.forEach((item, index) => {
+        if (!isRecord(item)) {
+            errors.push(`${label} todo item ${index} is not a mapping`);
+            return;
+        }
+        const taskId = item.task_id;
+        if (typeof taskId !== "string" || taskId.length === 0) {
+            errors.push(`${label} todo item ${index} missing task_id`);
+            return;
+        }
+        if (seen.has(taskId)) {
+            errors.push(`${label} duplicate prototype task_id ${taskId}`);
+        }
+        seen.add(taskId);
+        for (const key of ["title", "status", "acceptance"]) {
+            if (!(key in item)) {
+                errors.push(`${label} ${taskId} missing ${key}`);
+            }
+        }
+    });
+}
+function validatePrototypeEvidence(root, label, data, errors) {
+    if (!["image_prompt_pack", "visual", "interaction", "technical_feasibility", "3d_material", "workflow", "data_logic"].includes(String(data.prototype_mode))) {
+        errors.push(`${label} has invalid prototype_mode ${String(data.prototype_mode)}`);
+    }
+    for (const key of ["reference_analysis", "concept_evidence", "implementation_evidence", "known_limits"]) {
+        if (key in data && !Array.isArray(data[key])) {
+            errors.push(`${label} ${key} must be an array`);
+        }
+    }
+    if ("visual_direction" in data && !isRecord(data.visual_direction)) {
+        errors.push(`${label} visual_direction must be a mapping`);
+    }
+    if ("visual_concept_policy" in data) {
+        validateVisualConceptPolicy(label, data, errors);
+    }
+    if ("verification" in data && !isRecord(data.verification)) {
+        errors.push(`${label} verification must be a mapping`);
+    }
+    if ("self_critique" in data && !isRecord(data.self_critique)) {
+        errors.push(`${label} self_critique must be a mapping`);
+    }
+    else {
+        validateSelfCritique(label, data.self_critique, errors);
+    }
+    const prototypeArtifact = data.prototype_artifact;
+    if (isRecord(prototypeArtifact)) {
+        for (const key of ["path", "type"]) {
+            if (!(key in prototypeArtifact)) {
+                errors.push(`${label} prototype_artifact missing ${key}`);
+            }
+        }
+        validateLocalRef(root, label, "prototype_artifact.path", prototypeArtifact.path, errors);
+    }
+    validateEvidenceRefs(root, label, data, errors);
+    if ("validation_input" in data && !isRecord(data.validation_input)) {
+        errors.push(`${label} validation_input must be a mapping`);
+    }
+    else {
+        validatePrototypeValidationInput(label, data.validation_input, errors);
+    }
+    if ("source" in data && !isRecord(data.source)) {
+        errors.push(`${label} source must be a mapping`);
+    }
+    if ("negative_constraints" in data && !Array.isArray(data.negative_constraints)) {
+        errors.push(`${label} negative_constraints must be an array`);
+    }
+    if ("review_plan" in data && !isRecord(data.review_plan)) {
+        errors.push(`${label} review_plan must be a mapping`);
+    }
+    if ("directions" in data && !Array.isArray(data.directions)) {
+        errors.push(`${label} directions must be an array`);
+    }
+    if ("screen_manifest" in data && !Array.isArray(data.screen_manifest)) {
+        errors.push(`${label} screen_manifest must be an array`);
+    }
+    if ("screen_prompts" in data && !Array.isArray(data.screen_prompts)) {
+        errors.push(`${label} screen_prompts must be an array`);
+    }
+    if ("prompt_pack_type" in data && !["strategic_proto_prompt_pack", "refined_proto_prompt_pack", "proto_review_evidence"].includes(String(data.prompt_pack_type))) {
+        errors.push(`${label} has invalid prompt_pack_type ${String(data.prompt_pack_type)}`);
+    }
+    if (data.prompt_pack_type === "strategic_proto_prompt_pack") {
+        validateStrategicPrototypePromptPack(label, data, errors);
+    }
+    if (data.prompt_pack_type === "refined_proto_prompt_pack") {
+        validateRefinedPrototypePromptPack(label, data, errors);
+    }
+    if (!["pass", "fail", "unclear", "not_reviewed"].includes(String(data.result))) {
+        errors.push(`${label} has invalid result ${String(data.result)}`);
+    }
+}
+function validateRefinedPrototypePromptPack(label, data, errors) {
+    validateRequiredObjectFields(label, "tune_input", data.tune_input, ["baseline_source_type", "baseline_refs", "tune_request", "regeneration_scope"], errors);
+    validateRefinedBaselineResolution(label, data.baseline_resolution, errors);
+    validateRefinedCarryForward(label, data.carry_forward, errors);
+    validateRefinedBaselineAudit(label, data.baseline_audit, errors);
+    validateRequiredObjectFields(label, "product_system", data.product_system, REFINED_PRODUCT_SYSTEM_FIELDS, errors);
+    validateRefinedDeltaRules(label, data.delta_rules, data.tune_input, errors);
+    validateRefinedScreenDeltaMatrix(label, data.screen_delta_matrix, errors);
+    const manifestIds = validateRefinedScreenManifest(label, data.screen_manifest, errors);
+    validateRefinedScreenPrompts(label, data.screen_prompts, manifestIds, errors);
+    if (!Array.isArray(data.generation_order) || data.generation_order.length === 0) {
+        errors.push(`${label} generation_order must list target screen ids`);
+    }
+    if (!Array.isArray(data.acceptance_checklist) || data.acceptance_checklist.length === 0) {
+        errors.push(`${label} acceptance_checklist must be non-empty`);
+    }
+}
+const REFINED_BASELINE_AUDIT_FIELDS = [
+    "source_screen_id",
+    "screen_name",
+    "journey_stage",
+    "user_goal",
+    "system_state",
+    "components",
+    "must_preserve",
+];
+const REFINED_BASELINE_RESOLUTION_FIELDS = [
+    "latest_approved_baseline_group_id",
+    "latest_approved_baseline_ref",
+    "baseline_lineage",
+    "resolution_rule",
+    "stale_source_guard",
+];
+const REFINED_CARRY_FORWARD_FIELDS = [
+    "locked_screens",
+    "locked_elements",
+    "preserved_improvements",
+    "explicit_unlocks",
+    "cumulative_drift_guard",
+];
+const REFINED_PRODUCT_SYSTEM_FIELDS = [
+    "product_thesis",
+    "primary_loop",
+    "component_vocabulary",
+    "copywriting_style",
+    "trust_and_boundary_system",
+    "stable_constants",
+    "adaptable_variables",
+];
+const REFINED_DELTA_RULE_KEYS = ["must_inherit", "must_add", "must_remove", "flexible_change"];
+const REFINED_SCREEN_DELTA_FIELDS = [
+    "target_screen_id",
+    "source_screen_ids",
+    "preserve",
+    "add",
+    "remove",
+    "transform",
+    "flexible",
+    "acceptance_criteria",
+];
+const REFINED_SCREEN_MANIFEST_FIELDS = ["target_screen_id", "source_screen_ids", "screen_name", "generation_scope"];
+const REFINED_SCREEN_PROMPT_FIELDS = ["prompt_id", "target_screen_id", "source_screen_ids", "screen_name", "prompt", "negative_prompt", "acceptance_criteria"];
+function validateRefinedBaselineAudit(label, value, errors) {
+    if (!Array.isArray(value) || value.length === 0) {
+        errors.push(`${label} baseline_audit must contain source screen audits`);
+        return;
+    }
+    value.forEach((item, index) => {
+        validateRequiredObjectFields(label, `baseline_audit[${index}]`, item, REFINED_BASELINE_AUDIT_FIELDS, errors);
+    });
+}
+function validateRefinedBaselineResolution(label, value, errors) {
+    validateRequiredObjectFields(label, "baseline_resolution", value, REFINED_BASELINE_RESOLUTION_FIELDS, errors);
+    if (!isRecord(value)) {
+        return;
+    }
+    if (!Array.isArray(value.baseline_lineage)) {
+        errors.push(`${label} baseline_resolution.baseline_lineage must be an array`);
+    }
+    if (String(value.stale_source_guard ?? "").trim().length === 0) {
+        errors.push(`${label} baseline_resolution.stale_source_guard must forbid stale source-screen fallback`);
+    }
+}
+function validateRefinedCarryForward(label, value, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} carry_forward must be a mapping`);
+        return;
+    }
+    for (const key of REFINED_CARRY_FORWARD_FIELDS) {
+        if (!Object.hasOwn(value, key)) {
+            errors.push(`${label} carry_forward.${key} must be present`);
+        }
+    }
+    for (const key of ["locked_screens", "locked_elements", "preserved_improvements", "explicit_unlocks"]) {
+        if (!Array.isArray(value[key])) {
+            errors.push(`${label} carry_forward.${key} must be an array`);
+        }
+    }
+    if (String(value.cumulative_drift_guard ?? "").trim().length === 0) {
+        errors.push(`${label} carry_forward.cumulative_drift_guard must forbid cumulative tune drift`);
+    }
+}
+function validateRefinedDeltaRules(label, value, tuneInput, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} delta_rules must be a mapping`);
+        return;
+    }
+    for (const key of REFINED_DELTA_RULE_KEYS) {
+        if (!Array.isArray(value[key])) {
+            errors.push(`${label} delta_rules.${key} must be an array`);
+        }
+    }
+    if (Array.isArray(value.must_inherit) && value.must_inherit.length === 0) {
+        errors.push(`${label} delta_rules.must_inherit must preserve baseline product-system constants`);
+    }
+    const tuneRequest = isRecord(tuneInput) ? String(tuneInput.tune_request ?? "").toLowerCase() : "";
+    if (/\b(remove|delete|drop|eliminate|hide)\b/.test(tuneRequest) && Array.isArray(value.must_remove) && value.must_remove.length === 0) {
+        errors.push(`${label} delta_rules.must_remove must name requested removals from tune_input.tune_request`);
+    }
+}
+function validateRefinedScreenDeltaMatrix(label, value, errors) {
+    if (!Array.isArray(value) || value.length === 0) {
+        errors.push(`${label} screen_delta_matrix must contain target screen delta rows`);
+        return;
+    }
+    value.forEach((item, index) => {
+        validateRequiredObjectFields(label, `screen_delta_matrix[${index}]`, item, REFINED_SCREEN_DELTA_FIELDS, errors);
+    });
+}
+function validateRefinedScreenManifest(label, value, errors) {
+    const ids = new Set();
+    if (!Array.isArray(value) || value.length === 0) {
+        errors.push(`${label} screen_manifest must contain target screens`);
+        return ids;
+    }
+    value.forEach((item, index) => {
+        validateRequiredObjectFields(label, `screen_manifest[${index}]`, item, REFINED_SCREEN_MANIFEST_FIELDS, errors);
+        if (isRecord(item) && nonEmptyString(item.target_screen_id)) {
+            ids.add(String(item.target_screen_id));
+        }
+    });
+    return ids;
+}
+function validateRefinedScreenPrompts(label, value, manifestIds, errors) {
+    if (!Array.isArray(value) || value.length === 0) {
+        errors.push(`${label} screen_prompts must contain screen-bound refined prompts`);
+        return;
+    }
+    value.forEach((item, index) => {
+        validateRequiredObjectFields(label, `screen_prompts[${index}]`, item, REFINED_SCREEN_PROMPT_FIELDS, errors);
+        if (isRecord(item) && nonEmptyString(item.target_screen_id) && manifestIds.size > 0 && !manifestIds.has(String(item.target_screen_id))) {
+            errors.push(`${label} screen_prompts[${index}].target_screen_id must exist in screen_manifest`);
+        }
+    });
+}
+const STRATEGIC_NORMALIZED_FIELDS = [
+    "product_domain",
+    "primary_user",
+    "usage_context",
+    "current_alternative",
+    "core_pain",
+    "desired_behavior_change",
+    "strongest_success_signal",
+    "core_differentiator",
+    "emotional_value",
+    "functional_value",
+    "trust_requirements",
+    "privacy_requirements",
+    "non_goals",
+    "future_opportunities",
+    "validation_target",
+];
+const STRATEGIC_CORE_FIELDS = [
+    "target_user",
+    "behavior_change",
+    "mechanism",
+    "differentiator",
+    "boundary_conditions",
+    "central_uncertainty",
+];
+const PRODUCT_EXPERIENCE_MODEL_FIELDS = [
+    "product_archetype",
+    "primary_canvas",
+    "information_architecture",
+    "domain_object_model",
+    "primary_task_loop",
+    "interaction_state_model",
+    "data_realism_requirements",
+    "visual_language",
+    "anti_generic_constraints",
+];
+const PROTOTYPE_SYSTEM_CONTRACT_FIELDS = [
+    "stable_app_shell",
+    "navigation_taxonomy",
+    "data_vocabulary",
+    "domain_object_anatomy",
+    "object_detail_anatomy",
+    "action_bar_contract",
+    "audit_trust_pattern",
+    "copy_tone",
+    "allowed_screen_deltas",
+];
+const PROTOTYPE_REALITY_GATE_DIMENSIONS = [
+    "product_category_fit",
+    "primary_canvas_fit",
+    "domain_object_realism",
+    "task_loop_completeness",
+    "interaction_state_coverage",
+    "data_realism",
+    "anti_generic_constraints",
+];
+const PROMPT_PACK_INTEGRITY_GATE_DIMENSIONS = [
+    "direction_count_matches",
+    "prompt_text_refs_resolve",
+    "generated_image_refs_resolve",
+];
+const STRATEGIC_PROTOTYPE_BRIEF_FIELDS = [
+    "product_name",
+    "positioning",
+    "target_user",
+    "current_alternative",
+    "core_idea",
+    "primary_loop",
+    "trust_boundaries",
+    "non_goals",
+    "desired_feeling",
+];
+const STRATEGIC_SCREEN_MANIFEST_FIELDS = [
+    "target_screen_id",
+    "screen_name",
+    "journey_stage",
+    "user_goal",
+    "system_state",
+    "required_components",
+    "required_data_fields",
+    "primary_actions",
+    "trust_controls",
+    "example_copy",
+    "acceptance_criteria",
+];
+const STRATEGIC_GLOBAL_DESIGN_SYSTEM_PROMPT_FIELDS = [
+    "visual_language",
+    "layout_system",
+    "component_vocabulary",
+    "information_density",
+    "copy_tone",
+    "responsive_canvas_rules",
+    "negative_visual_patterns",
+];
+const STRATEGIC_SCREEN_PROMPT_FIELDS = [
+    "prompt_id",
+    "target_screen_id",
+    "screen_name",
+    "image_role",
+    "negative_prompt",
+    "example_copy",
+    "acceptance_criteria",
+];
+const STRATEGIC_QUALITY_RUBRIC_FIELDS = [
+    "prompt_executability",
+    "strategic_distinctness",
+    "product_specificity",
+    "state_coverage",
+    "trust_boundary_coverage",
+];
+const STRATEGIC_DIRECTION_FIELDS = [
+    "direction_id",
+    "name",
+    "strategic_hypothesis",
+    "validates",
+    "main_risk",
+    "distinctness_rationale",
+    "prototype_prompt",
+    "screen_prompts",
+    "pm_judgment",
+];
+const STRATEGIC_DISTINCTNESS_SIGNALS = [
+    "product form",
+    "trigger",
+    "interaction model",
+    "emotional driver",
+    "retention mechanism",
+    "metric",
+    "main risk",
+    "risk",
+    "user behavior",
+    "workflow",
+    "trust",
+    "privacy",
+];
+const STRATEGIC_FINGERPRINT_DIMENSIONS = [
+    "product_form",
+    "trigger",
+    "interaction_model",
+    "emotional_driver",
+    "retention_mechanism",
+    "metric",
+    "main_risk",
+    "trust_model",
+    "privacy_model",
+];
+function validatePrototypeValidationInput(label, value, errors) {
+    if (!isRecord(value)) {
+        return;
+    }
+    const mode = String(value.mode ?? "");
+    if (mode && !["validation_present", "agent_auto_generated"].includes(mode)) {
+        errors.push(`${label} validation_input.mode has invalid value ${mode}`);
+    }
+    if (mode === "vision_only" || mode === "internally_derived") {
+        errors.push(`${label} validation_input.mode must reference durable validation, not ${mode}`);
+    }
+    if (!Array.isArray(value.refs)) {
+        errors.push(`${label} validation_input.refs must be an array`);
+    }
+    else if (mode && value.refs.length === 0) {
+        errors.push(`${label} validation_input.refs must include durable validation artifact refs`);
+    }
+}
+function validateStrategicPrototypePromptPack(label, data, errors) {
+    validatePreflightQualityGate(label, data.preflight_quality_gate, errors);
+    validateInternalPipeline(label, data.internal_pipeline, errors);
+    validateDirectionCountPolicy(label, data.direction_count_policy, errors);
+    validateRequiredObjectFields(label, "normalized_input", data.normalized_input, STRATEGIC_NORMALIZED_FIELDS, errors);
+    validateRequiredObjectFields(label, "strategic_core", data.strategic_core, STRATEGIC_CORE_FIELDS, errors);
+    validateProductExperienceModel(label, data.product_experience_model, data, errors);
+    validatePrototypeSystemContract(label, data.prototype_system_contract, data, errors);
+    validatePrototypeRealityGate(label, data.prototype_reality_gate, data, errors);
+    validatePromptPackIntegrityGate(label, data.prompt_pack_integrity_gate, data, errors);
+    validateScreenBoundExecutability(label, data, errors);
+    validateStrategicDirections(label, data.directions, data.direction_count_policy, errors);
+    validateBuildRecommendation(label, data.build_recommendation, errors);
+    validatePromptTextManifest(label, data.prompt_text_manifest, errors);
+    validatePostValidate(label, data.post_validate, data.direction_count_policy, data.prompt_text_manifest, data.image_generation, data.directions, errors);
+    validateImageGeneration(label, data.image_generation, errors);
+}
+function validatePreflightQualityGate(label, value, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} preflight_quality_gate must be a mapping`);
+        return;
+    }
+    for (const key of ["vision_status", "validation_status", "can_proceed", "blockers", "next_command_when_blocked"]) {
+        if (!(key in value)) {
+            errors.push(`${label} preflight_quality_gate missing ${key}`);
+        }
+    }
+    for (const key of ["vision_status", "validation_status"]) {
+        const status = String(value[key] ?? "");
+        if (status && !["missing", "thin", "ready"].includes(status)) {
+            errors.push(`${label} preflight_quality_gate.${key} has invalid value ${status}`);
+        }
+    }
+    if (value.can_proceed !== true && value.next_command_when_blocked !== "/ow:vision") {
+        errors.push(`${label} preflight_quality_gate must route blocked prototype work back to /ow:vision`);
+    }
+}
+function validateInternalPipeline(label, value, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} internal_pipeline must be a mapping`);
+        return;
+    }
+    if (value.orchestrator_command !== "/ow:proto" || value.user_visible_command !== "/ow:proto") {
+        errors.push(`${label} internal_pipeline must keep /ow:proto as the user-visible orchestrator`);
+    }
+    const stages = value.stages;
+    if (!Array.isArray(stages)) {
+        errors.push(`${label} internal_pipeline.stages must be an array`);
+        return;
+    }
+    const stageIds = new Set();
+    for (const item of stages) {
+        if (!isRecord(item)) {
+            errors.push(`${label} internal_pipeline.stages entries must be mappings`);
+            continue;
+        }
+        const stageId = String(item.stage_id ?? "");
+        stageIds.add(stageId);
+        for (const key of ["stage_id", "command", "visibility", "status", "outputs"]) {
+            if (!(key in item)) {
+                errors.push(`${label} internal_pipeline stage missing ${key}`);
+            }
+        }
+        if ((stageId === "vision2prompt" || stageId === "prompt2proto") && item.visibility !== "internal") {
+            errors.push(`${label} internal pipeline stage ${stageId} must be internal`);
+        }
+    }
+    for (const required of ["proto-preflight", "vision2prompt", "prompt2proto"]) {
+        if (!stageIds.has(required)) {
+            errors.push(`${label} internal_pipeline missing stage ${required}`);
+        }
+    }
+}
+function validateDirectionCountPolicy(label, value, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} direction_count_policy must be a mapping`);
+        return;
+    }
+    const source = String(value.source ?? "");
+    if (source && !["user_input", "agent_default_after_user_delegation"].includes(source)) {
+        errors.push(`${label} direction_count_policy.source has invalid value ${source}`);
+    }
+    if (typeof value.resolved_count !== "number" || value.resolved_count < 1) {
+        errors.push(`${label} direction_count_policy.resolved_count must be a positive number`);
+    }
+    if (source === "agent_default_after_user_delegation" && value.resolved_count !== 3) {
+        errors.push(`${label} direction_count_policy delegated default must resolve to 3`);
+    }
+    if (value.ask_user_question_required === true && !nonEmptyString(value.ask_user_question)) {
+        errors.push(`${label} direction_count_policy.ask_user_question must be set when askUserQuestion is required`);
+    }
+}
+function validateRequiredObjectFields(label, field, value, keys, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} ${field} must be a mapping`);
+        return;
+    }
+    for (const key of keys) {
+        if (!hasUsefulValue(value[key])) {
+            errors.push(`${label} ${field}.${key} must be non-empty`);
+        }
+    }
+}
+function validateProductExperienceModel(label, value, data, errors) {
+    if (!strategicPromptPackRequiresProductExperienceModel(data)) {
+        if ("product_experience_model" in data && !isRecord(value)) {
+            errors.push(`${label} product_experience_model must be a mapping when present`);
+        }
+        return;
+    }
+    validateRequiredObjectFields(label, "product_experience_model", value, PRODUCT_EXPERIENCE_MODEL_FIELDS, errors);
+}
+function strategicPromptPackRequiresProductExperienceModel(data) {
+    const promptTextManifest = isRecord(data.prompt_text_manifest) ? data.prompt_text_manifest : {};
+    const imageGeneration = isRecord(data.image_generation) ? data.image_generation : {};
+    return (data.status !== "draft" ||
+        promptTextManifest.status === "ready_for_image_generation" ||
+        promptTextManifest.status === "generated" ||
+        (typeof imageGeneration.status === "string" && imageGeneration.status !== "not_started"));
+}
+function validatePrototypeSystemContract(label, value, data, errors) {
+    const required = strategicPromptPackRequiresProductExperienceModel(data);
+    if (!required) {
+        if ("prototype_system_contract" in data && !isRecord(value)) {
+            errors.push(`${label} prototype_system_contract must be a mapping when present`);
+        }
+        return;
+    }
+    validateRequiredObjectFields(label, "prototype_system_contract", value, PROTOTYPE_SYSTEM_CONTRACT_FIELDS, errors);
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const key of PROTOTYPE_SYSTEM_CONTRACT_FIELDS) {
+        if (key === "copy_tone") {
+            if (!nonEmptyString(value[key])) {
+                errors.push(`${label} prototype_system_contract.copy_tone must be a non-empty string`);
+            }
+            continue;
+        }
+        if (!Array.isArray(value[key]) || value[key].length === 0) {
+            errors.push(`${label} prototype_system_contract.${key} must be a non-empty array`);
+        }
+    }
+}
+function validatePrototypeRealityGate(label, value, data, errors) {
+    const required = strategicPromptPackRequiresProductExperienceModel(data);
+    if (!required) {
+        if ("prototype_reality_gate" in data && !isRecord(value)) {
+            errors.push(`${label} prototype_reality_gate must be a mapping when present`);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(`${label} prototype_reality_gate must be a mapping`);
+        return;
+    }
+    for (const key of ["status", "trigger", "required_when_prompt_text_ready", "dimensions", "failures", "outcome_notes", "repair_route"]) {
+        if (!(key in value)) {
+            errors.push(`${label} prototype_reality_gate missing ${key}`);
+        }
+    }
+    const status = String(value.status ?? "");
+    if (status && !["pending", "pass", "fail"].includes(status)) {
+        errors.push(`${label} prototype_reality_gate.status has invalid value ${status}`);
+    }
+    if (value.trigger !== "before_image_generation") {
+        errors.push(`${label} prototype_reality_gate.trigger must be before_image_generation`);
+    }
+    if (value.required_when_prompt_text_ready !== true) {
+        errors.push(`${label} prototype_reality_gate.required_when_prompt_text_ready must be true`);
+    }
+    if (value.repair_route !== "/ow:vision2prompt") {
+        errors.push(`${label} prototype_reality_gate.repair_route must be /ow:vision2prompt`);
+    }
+    if (!Array.isArray(value.dimensions)) {
+        errors.push(`${label} prototype_reality_gate.dimensions must be an array`);
+    }
+    else {
+        for (const dimension of PROTOTYPE_REALITY_GATE_DIMENSIONS) {
+            if (!value.dimensions.includes(dimension)) {
+                errors.push(`${label} prototype_reality_gate.dimensions missing ${dimension}`);
+            }
+        }
+    }
+    for (const key of ["failures", "outcome_notes"]) {
+        if (!Array.isArray(value[key])) {
+            errors.push(`${label} prototype_reality_gate.${key} must be an array`);
+        }
+    }
+    const promptTextManifest = isRecord(data.prompt_text_manifest) ? data.prompt_text_manifest : {};
+    const imageGeneration = isRecord(data.image_generation) ? data.image_generation : {};
+    const promptTextReady = promptTextManifest.status === "ready_for_image_generation" || promptTextManifest.status === "generated";
+    if (promptTextReady && status !== "pass") {
+        errors.push(`${label} prototype_reality_gate.status must be pass before image generation`);
+    }
+    if (status === "pass" && Array.isArray(value.failures) && value.failures.length > 0) {
+        errors.push(`${label} prototype_reality_gate.failures must be empty when status is pass`);
+    }
+    if (status === "fail" && typeof imageGeneration.status === "string" && imageGeneration.status !== "not_started") {
+        errors.push(`${label} prototype_reality_gate failed gates must not start image_generation`);
+    }
+}
+function validatePromptPackIntegrityGate(label, value, data, errors) {
+    const required = strategicPromptPackRequiresProductExperienceModel(data);
+    if (!required) {
+        if ("prompt_pack_integrity_gate" in data && !isRecord(value)) {
+            errors.push(`${label} prompt_pack_integrity_gate must be a mapping when present`);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        errors.push(`${label} prompt_pack_integrity_gate must be a mapping`);
+        return;
+    }
+    for (const key of ["status", "trigger", "required_when_prompt_text_ready", "dimensions", "failures", "outcome_notes", "repair_route"]) {
+        if (!(key in value)) {
+            errors.push(`${label} prompt_pack_integrity_gate missing ${key}`);
+        }
+    }
+    const status = String(value.status ?? "");
+    if (status && !["pending", "pass", "fail"].includes(status)) {
+        errors.push(`${label} prompt_pack_integrity_gate.status has invalid value ${status}`);
+    }
+    if (value.trigger !== "before_image_generation") {
+        errors.push(`${label} prompt_pack_integrity_gate.trigger must be before_image_generation`);
+    }
+    if (value.required_when_prompt_text_ready !== true) {
+        errors.push(`${label} prompt_pack_integrity_gate.required_when_prompt_text_ready must be true`);
+    }
+    if (value.repair_route !== "/ow:vision2prompt") {
+        errors.push(`${label} prompt_pack_integrity_gate.repair_route must be /ow:vision2prompt`);
+    }
+    if (!Array.isArray(value.dimensions)) {
+        errors.push(`${label} prompt_pack_integrity_gate.dimensions must be an array`);
+    }
+    else {
+        for (const dimension of PROMPT_PACK_INTEGRITY_GATE_DIMENSIONS) {
+            if (!value.dimensions.includes(dimension)) {
+                errors.push(`${label} prompt_pack_integrity_gate.dimensions missing ${dimension}`);
+            }
+        }
+    }
+    for (const key of ["failures", "outcome_notes"]) {
+        if (!Array.isArray(value[key])) {
+            errors.push(`${label} prompt_pack_integrity_gate.${key} must be an array`);
+        }
+    }
+    validatePromptPackIntegrity(label, data, errors);
+    const promptTextManifest = isRecord(data.prompt_text_manifest) ? data.prompt_text_manifest : {};
+    const imageGeneration = isRecord(data.image_generation) ? data.image_generation : {};
+    const promptTextReady = promptTextManifest.status === "ready_for_image_generation" || promptTextManifest.status === "generated";
+    if (promptTextReady && status !== "pass") {
+        errors.push(`${label} prompt_pack_integrity_gate.status must be pass before image generation`);
+    }
+    if (status === "pass" && Array.isArray(value.failures) && value.failures.length > 0) {
+        errors.push(`${label} prompt_pack_integrity_gate.failures must be empty when status is pass`);
+    }
+    if (status === "fail" && typeof imageGeneration.status === "string" && imageGeneration.status !== "not_started") {
+        errors.push(`${label} prompt_pack_integrity_gate failed gates must not start image_generation`);
+    }
+}
+function validatePromptPackIntegrity(label, data, errors) {
+    const directions = Array.isArray(data.directions) ? data.directions.filter(isRecord) : [];
+    const directionIds = new Set();
+    const promptIds = new Set();
+    for (const direction of directions) {
+        if (nonEmptyString(direction.direction_id)) {
+            directionIds.add(String(direction.direction_id));
+        }
+        if (Array.isArray(direction.screen_prompts)) {
+            for (const prompt of direction.screen_prompts) {
+                if (isRecord(prompt) && nonEmptyString(prompt.prompt_id)) {
+                    promptIds.add(String(prompt.prompt_id));
+                }
+            }
+        }
+    }
+    const countPolicy = isRecord(data.direction_count_policy) ? data.direction_count_policy : {};
+    const promptTextManifest = isRecord(data.prompt_text_manifest) ? data.prompt_text_manifest : {};
+    const promptTextReady = promptTextManifest.status === "ready_for_image_generation" || promptTextManifest.status === "generated";
+    const resolvedCount = typeof countPolicy.resolved_count === "number" ? countPolicy.resolved_count : null;
+    if (promptTextReady && resolvedCount !== null && directions.length !== resolvedCount) {
+        errors.push(`${label} directions length must equal direction_count_policy.resolved_count before image generation`);
+    }
+    if (promptTextReady && typeof promptTextManifest.direction_count !== "number") {
+        errors.push(`${label} prompt_text_manifest.direction_count must be a number before image generation`);
+    }
+    if (typeof promptTextManifest.direction_count === "number" && directions.length > 0 && promptTextManifest.direction_count !== directions.length) {
+        errors.push(`${label} prompt_text_manifest.direction_count must equal directions length`);
+    }
+    if (promptTextReady) {
+        const refs = Array.isArray(promptTextManifest.prompt_text_refs) ? promptTextManifest.prompt_text_refs : [];
+        if (refs.length === 0) {
+            errors.push(`${label} prompt_text_manifest.prompt_text_refs must include prompt refs before image generation`);
+        }
+        refs.forEach((ref, index) => {
+            if (!stringReferencesKnownPrompt(String(ref), directionIds, promptIds)) {
+                errors.push(`${label} prompt_text_manifest.prompt_text_refs[${index}] must reference an existing direction_id or prompt_id`);
+            }
+        });
+    }
+    const imageGeneration = isRecord(data.image_generation) ? data.image_generation : {};
+    const generatedImages = Array.isArray(imageGeneration.generated_images) ? imageGeneration.generated_images : [];
+    generatedImages.forEach((image, index) => {
+        if (!isRecord(image)) {
+            return;
+        }
+        const directionId = String(image.direction_id ?? "");
+        const promptId = String(image.prompt_id ?? "");
+        if (directionId && !directionIds.has(directionId)) {
+            errors.push(`${label} image_generation.generated_images[${index}].direction_id must exist in directions`);
+        }
+        if (promptId && !promptIds.has(promptId)) {
+            errors.push(`${label} image_generation.generated_images[${index}].prompt_id must exist in directions[].screen_prompts`);
+        }
+        const metadata = isRecord(image.metadata) ? image.metadata : {};
+        const sourcePromptRef = String(metadata.source_prompt_ref ?? "");
+        if (sourcePromptRef && !stringReferencesKnownPrompt(sourcePromptRef, directionIds, promptIds)) {
+            errors.push(`${label} image_generation.generated_images[${index}].metadata.source_prompt_ref must reference an existing direction_id or prompt_id`);
+        }
+    });
+}
+function validateScreenBoundExecutability(label, data, errors) {
+    if (!strategicPromptPackRequiresScreenExecutability(data)) {
+        return;
+    }
+    validateRequiredObjectFields(label, "prototype_brief", data.prototype_brief, STRATEGIC_PROTOTYPE_BRIEF_FIELDS, errors);
+    validateRequiredObjectFields(label, "global_design_system_prompt", data.global_design_system_prompt, STRATEGIC_GLOBAL_DESIGN_SYSTEM_PROMPT_FIELDS, errors);
+    validateRequiredObjectFields(label, "quality_rubric", data.quality_rubric, STRATEGIC_QUALITY_RUBRIC_FIELDS, errors);
+    const manifestIds = validateStrategicScreenManifest(label, data.screen_manifest, errors);
+    validateStrategicDirectionScreenPrompts(label, data.directions, manifestIds, errors);
+}
+function strategicPromptPackRequiresScreenExecutability(data) {
+    const promptTextManifest = isRecord(data.prompt_text_manifest) ? data.prompt_text_manifest : {};
+    const imageGeneration = isRecord(data.image_generation) ? data.image_generation : {};
+    return (promptTextManifest.status === "ready_for_image_generation" ||
+        promptTextManifest.status === "generated" ||
+        (typeof imageGeneration.status === "string" && imageGeneration.status !== "not_started"));
+}
+function validateStrategicScreenManifest(label, value, errors) {
+    const ids = new Set();
+    if (!Array.isArray(value) || value.length === 0) {
+        errors.push(`${label} screen_manifest must contain screen-bound product states before image generation`);
+        return ids;
+    }
+    value.forEach((item, index) => {
+        validateRequiredObjectFields(label, `screen_manifest[${index}]`, item, STRATEGIC_SCREEN_MANIFEST_FIELDS, errors);
+        if (!isRecord(item)) {
+            return;
         }
+        if (nonEmptyString(item.target_screen_id)) {
+            ids.add(String(item.target_screen_id));
+        }
+        if (!hasUsefulValue(item.ai_behavior) && !hasUsefulValue(item.non_ai_rationale)) {
+            errors.push(`${label} screen_manifest[${index}] must include ai_behavior or non_ai_rationale`);
+        }
+    });
+    return ids;
+}
+function validateStrategicDirectionScreenPrompts(label, directions, manifestIds, errors) {
+    if (!Array.isArray(directions)) {
+        return;
     }
-    else {
-        errors.push(`${label} artifact ${index} read_policy must be a mapping`);
-    }
-    const activePointer = artifact.active_pointer;
-    if (isRecord(activePointer)) {
-        for (const key of ["index_path", "pointer_key", "collection_key", "id_key", "path_key"]) {
-            if (!(key in activePointer)) {
-                errors.push(`${label} artifact ${index} active_pointer missing ${key}`);
+    directions.forEach((direction, directionIndex) => {
+        if (!isRecord(direction)) {
+            return;
+        }
+        const screenPrompts = direction.screen_prompts;
+        if (!Array.isArray(screenPrompts) || screenPrompts.length === 0) {
+            errors.push(`${label} directions[${directionIndex}].screen_prompts must contain screen-bound prompt text before image generation`);
+            return;
+        }
+        screenPrompts.forEach((prompt, promptIndex) => {
+            const fieldLabel = `directions[${directionIndex}].screen_prompts[${promptIndex}]`;
+            validateRequiredObjectFields(label, fieldLabel, prompt, STRATEGIC_SCREEN_PROMPT_FIELDS, errors);
+            if (!isRecord(prompt)) {
+                return;
+            }
+            if (!hasUsefulValue(prompt.prompt) && !hasUsefulValue(prompt.standalone_prompt)) {
+                errors.push(`${label} ${fieldLabel} must include prompt or standalone_prompt`);
             }
+            if (nonEmptyString(prompt.target_screen_id) && manifestIds.size > 0 && !manifestIds.has(String(prompt.target_screen_id))) {
+                errors.push(`${label} ${fieldLabel}.target_screen_id must exist in screen_manifest`);
+            }
+        });
+    });
+}
+function stringReferencesKnownPrompt(value, directionIds, promptIds) {
+    const normalized = normalizePromptRef(value);
+    if (normalized.length === 0) {
+        return false;
+    }
+    for (const id of [...directionIds, ...promptIds]) {
+        const token = normalizePromptRef(id);
+        if (token.length > 0 && normalized.includes(token)) {
+            return true;
         }
     }
-    else {
-        errors.push(`${label} artifact ${index} active_pointer must be a mapping`);
-    }
+    return false;
 }
-function validateDisclosureLevels(root, path, data, errors) {
-    if (basename(path) !== "DISCLOSURE_LEVELS.yaml") {
+function normalizePromptRef(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function validateStrategicDirections(label, value, countPolicy, errors) {
+    if (!Array.isArray(value) || value.length === 0) {
+        errors.push(`${label} directions must contain strategic prompt directions`);
         return;
     }
-    const label = relative(root, path);
-    const levels = data.levels;
-    if (!Array.isArray(levels) || levels.length < 5) {
-        errors.push(`${label} must contain disclosure levels 0 through 4`);
-        return;
+    const resolvedCount = isRecord(countPolicy) && typeof countPolicy.resolved_count === "number" ? countPolicy.resolved_count : null;
+    if (resolvedCount !== null && value.length < resolvedCount) {
+        errors.push(`${label} directions must include at least direction_count_policy.resolved_count items`);
     }
-    const seen = new Set();
-    levels.forEach((level, index) => {
-        if (!isRecord(level)) {
-            errors.push(`${label} level ${index} is not a mapping`);
+    value.forEach((item, index) => {
+        if (!isRecord(item)) {
+            errors.push(`${label} directions[${index}] must be a mapping`);
             return;
         }
-        if (typeof level.level === "number") {
-            seen.add(level.level);
-        }
-        for (const key of ["name", "default_for_agents", "purpose", "examples"]) {
-            if (!(key in level)) {
-                errors.push(`${label} level ${index} missing ${key}`);
+        for (const key of STRATEGIC_DIRECTION_FIELDS) {
+            if (!hasUsefulValue(item[key])) {
+                errors.push(`${label} directions[${index}].${key} must be non-empty`);
             }
         }
-    });
-    for (let level = 0; level <= 4; level += 1) {
-        if (!seen.has(level)) {
-            errors.push(`${label} missing disclosure level ${level}`);
+        const screenPrompts = item.screen_prompts;
+        if (Array.isArray(screenPrompts) && screenPrompts.length < 2) {
+            errors.push(`${label} directions[${index}].screen_prompts must include multi-image prompt text`);
         }
-    }
+        const distinctness = String(item.distinctness_rationale ?? "").toLowerCase();
+        if (!STRATEGIC_DISTINCTNESS_SIGNALS.some((signal) => distinctness.includes(signal))) {
+            errors.push(`${label} directions[${index}].distinctness_rationale must name a strategic difference, not only visual style`);
+        }
+    });
 }
-function validateDiscoveryArtifact(root, path, data, errors) {
-    if (typeof data.artifact_type !== "string") {
+function validateBuildRecommendation(label, value, errors) {
+    validateRequiredObjectFields(label, "build_recommendation", value, ["first_direction_id", "why_first", "success_signals", "failure_signals", "next_test_if_it_works"], errors);
+}
+function validatePromptTextManifest(label, value, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} prompt_text_manifest must be a mapping`);
         return;
     }
-    const label = relative(root, path);
-    const required = artifactRequiredKeys(data.artifact_type);
-    if (!required) {
-        errors.push(`${label} has unknown artifact_type ${data.artifact_type}`);
+    const status = String(value.status ?? "");
+    if (status && !["draft", "ready_for_image_generation", "generated"].includes(status)) {
+        errors.push(`${label} prompt_text_manifest.status has invalid value ${status}`);
+    }
+    if (status !== "draft" && value.directions_ready !== true) {
+        errors.push(`${label} prompt_text_manifest.directions_ready must be true before image generation`);
+    }
+    if (!Array.isArray(value.prompt_text_refs)) {
+        errors.push(`${label} prompt_text_manifest.prompt_text_refs must be an array`);
+    }
+}
+function validatePostValidate(label, value, countPolicy, promptTextManifest, imageGeneration, directions, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} post_validate must be a mapping`);
         return;
     }
-    for (const key of required) {
-        if (!(key in data)) {
-            errors.push(`${label} missing artifact key ${key}`);
+    for (const key of ["status", "trigger", "required_when_direction_count_gte", "skip_when_resolved_count", "threshold_policy", "fingerprint_dimensions", "comparisons", "failures", "outcome_notes", "repair_route"]) {
+        if (!(key in value)) {
+            errors.push(`${label} post_validate missing ${key}`);
         }
     }
-    if (data.artifact_type === "validation_target") {
-        validateValidationTarget(label, data, errors);
+    const status = String(value.status ?? "");
+    if (status && !["pending", "pass", "fail", "skipped"].includes(status)) {
+        errors.push(`${label} post_validate.status has invalid value ${status}`);
     }
-    else if (data.artifact_type === "prototype_evidence") {
-        validatePrototypeEvidence(root, label, data, errors);
+    if (value.trigger !== "after_prompt_assets_ready") {
+        errors.push(`${label} post_validate.trigger must be after_prompt_assets_ready`);
     }
-    else if (data.artifact_type === "decision_record") {
-        validateDecisionRecord(label, data, errors);
+    if (value.required_when_direction_count_gte !== 2) {
+        errors.push(`${label} post_validate.required_when_direction_count_gte must be 2`);
     }
-    else if (data.artifact_type === "product_design") {
-        validateProductDesign(label, data, errors);
+    if (value.skip_when_resolved_count !== 1) {
+        errors.push(`${label} post_validate.skip_when_resolved_count must be 1`);
     }
-}
-function artifactRequiredKeys(artifactType) {
-    const requiredByType = {
-        vision_session: ["current_question", "stable_answers", "unresolved_questions", "vision_delta", "handoff"],
-        validation_target: [
-            "core_question",
-            "feature_classification",
-            "critical_assumptions",
-            "prototype_scope",
-            "acceptance",
-            "decision_options",
-        ],
-        prototype_evidence: [
-            "validation_target",
-            "core_question",
-            "prototype_mode",
-            "reference_analysis",
-            "visual_direction",
-            "visual_concept_policy",
-            "concept_evidence",
-            "prototype_artifact",
-            "run",
-            "implementation_evidence",
-            "observations",
-            "evidence",
-            "verification",
-            "self_critique",
-            "known_limits",
-            "result",
-            "handoff",
-        ],
-        decision_record: [
-            "reviewed_evidence",
-            "outcome",
-            "rationale",
-            "accepted_scope",
-            "rejected_scope",
-            "revision_scope",
-            "next_command",
-            "follow_up_questions",
-        ],
-        product_design: [
-            "accepted_prototype_evidence",
-            "personas",
-            "journey_map",
-            "user_stories",
-            "feature_matrix",
-            "kano_classification",
-            "behavior_model",
-            "ux_states",
-            "scope",
-            "open_questions",
-            "conditional_packets",
-            "spec_readiness",
-        ],
-    };
-    return requiredByType[artifactType] ?? null;
-}
-function validateValidationTarget(label, data, errors) {
-    const featureClassification = data.feature_classification;
-    if (isRecord(featureClassification)) {
-        for (const key of ["existential", "supporting", "later", "out_of_scope"]) {
-            if (!(key in featureClassification)) {
-                errors.push(`${label} feature_classification missing ${key}`);
+    if (value.repair_route !== "/ow:vision2prompt") {
+        errors.push(`${label} post_validate.repair_route must be /ow:vision2prompt`);
+    }
+    const thresholdPolicy = value.threshold_policy;
+    if (!isRecord(thresholdPolicy)) {
+        errors.push(`${label} post_validate.threshold_policy must be a mapping`);
+    }
+    else {
+        if (thresholdPolicy.method !== "strategic_fingerprint_similarity") {
+            errors.push(`${label} post_validate.threshold_policy.method must be strategic_fingerprint_similarity`);
+        }
+        if (thresholdPolicy.comparison !== "pairwise") {
+            errors.push(`${label} post_validate.threshold_policy.comparison must be pairwise`);
+        }
+        if (typeof thresholdPolicy.max_pairwise_similarity !== "number" || thresholdPolicy.max_pairwise_similarity <= 0 || thresholdPolicy.max_pairwise_similarity >= 1) {
+            errors.push(`${label} post_validate.threshold_policy.max_pairwise_similarity must be between 0 and 1`);
+        }
+    }
+    if (!Array.isArray(value.fingerprint_dimensions)) {
+        errors.push(`${label} post_validate.fingerprint_dimensions must be an array`);
+    }
+    else {
+        for (const dimension of STRATEGIC_FINGERPRINT_DIMENSIONS) {
+            if (!value.fingerprint_dimensions.includes(dimension)) {
+                errors.push(`${label} post_validate.fingerprint_dimensions missing ${dimension}`);
             }
         }
     }
-    validatePrototypeScope(label, data.prototype_scope, errors);
-}
-function validatePrototypeScope(label, value, errors) {
-    if (!isRecord(value)) {
-        return;
+    for (const key of ["comparisons", "failures", "outcome_notes"]) {
+        if (!Array.isArray(value[key])) {
+            errors.push(`${label} post_validate.${key} must be an array`);
+        }
     }
-    for (const key of ["include", "exclude"]) {
-        if (!(key in value)) {
-            errors.push(`${label} prototype_scope missing ${key}`);
+    const resolvedCount = isRecord(countPolicy) && typeof countPolicy.resolved_count === "number" ? countPolicy.resolved_count : null;
+    const promptStatus = isRecord(promptTextManifest) ? String(promptTextManifest.status ?? "") : "";
+    const promptReady = promptStatus === "ready_for_image_generation" || promptStatus === "generated";
+    if (resolvedCount === 1 && status !== "skipped") {
+        errors.push(`${label} post_validate.status must be skipped when direction_count_policy.resolved_count is 1`);
+    }
+    if (promptReady && resolvedCount !== null && resolvedCount >= 2 && !["pass", "fail"].includes(status)) {
+        errors.push(`${label} post_validate.status must be pass or fail before /ow:prompt2proto when resolved_count is 2 or more`);
+    }
+    if (status === "skipped" && resolvedCount !== 1) {
+        errors.push(`${label} post_validate.status can be skipped only when resolved_count is 1`);
+    }
+    if (status === "fail") {
+        const imageStatus = isRecord(imageGeneration) ? String(imageGeneration.status ?? "") : "";
+        if (["queued", "in_progress", "complete"].includes(imageStatus)) {
+            errors.push(`${label} post_validate failed gates must not start image_generation`);
         }
     }
+    if (status === "pass" && promptReady && resolvedCount !== null && resolvedCount >= 2) {
+        validateStrategicFingerprintSimilarity(label, directions, value.fingerprint_dimensions, thresholdPolicy, errors);
+    }
 }
-function validatePrototypeTodo(label, value, errors) {
-    if (!Array.isArray(value) || value.length === 0) {
-        errors.push(`${label} must contain non-empty todo list`);
+function validateStrategicFingerprintSimilarity(label, directions, dimensions, thresholdPolicy, errors) {
+    if (!Array.isArray(directions) || !Array.isArray(dimensions) || !isRecord(thresholdPolicy)) {
         return;
     }
-    const seen = new Set();
-    value.forEach((item, index) => {
-        if (!isRecord(item)) {
-            errors.push(`${label} todo item ${index} is not a mapping`);
-            return;
-        }
-        const taskId = item.task_id;
-        if (typeof taskId !== "string" || taskId.length === 0) {
-            errors.push(`${label} todo item ${index} missing task_id`);
-            return;
-        }
-        if (seen.has(taskId)) {
-            errors.push(`${label} duplicate prototype task_id ${taskId}`);
+    const threshold = typeof thresholdPolicy.max_pairwise_similarity === "number" ? thresholdPolicy.max_pairwise_similarity : null;
+    if (threshold === null) {
+        return;
+    }
+    const records = directions
+        .filter(isRecord)
+        .map((direction, index) => {
+        const directionId = nonEmptyString(direction.direction_id) ? String(direction.direction_id) : `index-${index}`;
+        const fingerprint = isRecord(direction.strategic_fingerprint) ? direction.strategic_fingerprint : null;
+        if (fingerprint === null) {
+            errors.push(`${label} directions[${index}].strategic_fingerprint must be set when post_validate.status is pass`);
         }
-        seen.add(taskId);
-        for (const key of ["title", "status", "acceptance"]) {
-            if (!(key in item)) {
-                errors.push(`${label} ${taskId} missing ${key}`);
+        return { directionId, index, fingerprint };
+    });
+    for (let left = 0; left < records.length; left += 1) {
+        for (let right = left + 1; right < records.length; right += 1) {
+            const leftRecord = records[left];
+            const rightRecord = records[right];
+            if (!leftRecord?.fingerprint || !rightRecord?.fingerprint) {
+                continue;
+            }
+            const result = compareStrategicFingerprints(leftRecord.fingerprint, rightRecord.fingerprint, dimensions);
+            if (result.comparedCount === 0) {
+                errors.push(`${label} post_validate cannot compare ${leftRecord.directionId} and ${rightRecord.directionId}: no populated strategic_fingerprint dimensions`);
+                continue;
+            }
+            if (result.score > threshold) {
+                errors.push(`${label} post_validate pair ${leftRecord.directionId}/${rightRecord.directionId} exceeds strategic fingerprint similarity threshold ${threshold}: score ${formatSimilarity(result.score)} shared dimensions ${result.sharedDimensions.join(", ")}`);
             }
         }
-    });
+    }
 }
-function validatePrototypeEvidence(root, label, data, errors) {
-    if (!["visual", "interaction", "technical_feasibility", "3d_material", "workflow", "data_logic"].includes(String(data.prototype_mode))) {
-        errors.push(`${label} has invalid prototype_mode ${String(data.prototype_mode)}`);
+function compareStrategicFingerprints(left, right, dimensions) {
+    let total = 0;
+    let comparedCount = 0;
+    const sharedDimensions = [];
+    for (const rawDimension of dimensions) {
+        const dimension = String(rawDimension);
+        const leftTokens = fingerprintTokens(left[dimension]);
+        const rightTokens = fingerprintTokens(right[dimension]);
+        if (leftTokens.size === 0 || rightTokens.size === 0) {
+            continue;
+        }
+        const similarity = jaccardSimilarity(leftTokens, rightTokens);
+        total += similarity;
+        comparedCount += 1;
+        if (similarity >= 0.8) {
+            sharedDimensions.push(dimension);
+        }
     }
-    for (const key of ["reference_analysis", "concept_evidence", "implementation_evidence", "known_limits"]) {
-        if (key in data && !Array.isArray(data[key])) {
-            errors.push(`${label} ${key} must be an array`);
+    return {
+        score: comparedCount === 0 ? 0 : total / comparedCount,
+        comparedCount,
+        sharedDimensions,
+    };
+}
+function fingerprintTokens(value) {
+    const raw = Array.isArray(value)
+        ? value.join(" ")
+        : isRecord(value)
+            ? Object.values(value).join(" ")
+            : String(value ?? "");
+    return new Set(raw.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 1));
+}
+function jaccardSimilarity(left, right) {
+    let intersection = 0;
+    for (const token of left) {
+        if (right.has(token)) {
+            intersection += 1;
         }
     }
-    if ("visual_direction" in data && !isRecord(data.visual_direction)) {
-        errors.push(`${label} visual_direction must be a mapping`);
+    const union = left.size + right.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+}
+function formatSimilarity(value) {
+    return value.toFixed(2);
+}
+function validateImageGeneration(label, value, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} image_generation must be a mapping`);
+        return;
     }
-    validateVisualConceptPolicy(label, data, errors);
-    if ("verification" in data && !isRecord(data.verification)) {
-        errors.push(`${label} verification must be a mapping`);
+    const status = String(value.status ?? "");
+    if (status && !["not_started", "queued", "in_progress", "complete", "blocked"].includes(status)) {
+        errors.push(`${label} image_generation.status has invalid value ${status}`);
     }
-    if ("self_critique" in data && !isRecord(data.self_critique)) {
-        errors.push(`${label} self_critique must be a mapping`);
+    if (!nonEmptyString(value.batch_strategy)) {
+        errors.push(`${label} image_generation.batch_strategy must be non-empty`);
+    }
+    if (!Array.isArray(value.generated_images)) {
+        errors.push(`${label} image_generation.generated_images must be an array`);
     }
     else {
-        validateSelfCritique(label, data.self_critique, errors);
+        value.generated_images.forEach((item, index) => validateGeneratedImageMetadata(label, item, index, errors));
     }
-    const prototypeArtifact = data.prototype_artifact;
-    if (isRecord(prototypeArtifact)) {
-        for (const key of ["path", "type"]) {
-            if (!(key in prototypeArtifact)) {
-                errors.push(`${label} prototype_artifact missing ${key}`);
-            }
+    if (!Array.isArray(value.collection_notes)) {
+        errors.push(`${label} image_generation.collection_notes must be an array`);
+    }
+}
+function validateGeneratedImageMetadata(label, value, index, errors) {
+    if (!isRecord(value)) {
+        errors.push(`${label} image_generation.generated_images[${index}] must be a mapping`);
+        return;
+    }
+    for (const key of ["image_id", "direction_id", "prompt_id", "screen_name", "path", "metadata"]) {
+        if (!hasUsefulValue(value[key])) {
+            errors.push(`${label} image_generation.generated_images[${index}].${key} must be non-empty`);
         }
-        validateLocalRef(root, label, "prototype_artifact.path", prototypeArtifact.path, errors);
     }
-    validateEvidenceRefs(root, label, data, errors);
-    if (!["pass", "fail", "unclear", "not_reviewed"].includes(String(data.result))) {
-        errors.push(`${label} has invalid result ${String(data.result)}`);
+    const metadata = value.metadata;
+    if (!isRecord(metadata)) {
+        errors.push(`${label} image_generation.generated_images[${index}].metadata must be a mapping`);
+        return;
+    }
+    for (const key of ["source_prompt_ref", "generated_at", "generator", "generation_status", "review_status"]) {
+        if (!hasUsefulValue(metadata[key])) {
+            errors.push(`${label} image_generation.generated_images[${index}].metadata.${key} must be non-empty`);
+        }
+    }
+}
+function hasUsefulValue(value) {
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    if (isRecord(value)) {
+        return Object.keys(value).length > 0;
     }
+    return nonEmptyString(value);
 }
 function validateVisualConceptPolicy(label, data, errors) {
     const policy = data.visual_concept_policy;
@@ -644,20 +2607,23 @@ function validateEvidenceRefs(root, label, data, errors) {
     }
 }
 function validateLocalRef(root, label, field, value, errors) {
-    if (typeof value !== "string" || value.length === 0 || isExternalRef(value)) {
+    if (typeof value !== "string") {
         return;
     }
-    const resolved = resolve(root, value);
-    if (resolved !== root && !resolved.startsWith(`${root}/`)) {
+    const ref = resolveLocalReference(root, value, { exists: existsSyncSafe });
+    if (ref.kind === "empty" || ref.kind === "external") {
+        return;
+    }
+    if (ref.kind === "outside-root") {
         errors.push(`${label} ${field} references path outside root: ${value}`);
         return;
     }
-    if (!existsSyncSafe(resolved)) {
+    if (!ref.exists) {
         errors.push(`${label} ${field} references missing path ${value}`);
     }
 }
 function isExternalRef(value) {
-    return /^[a-z][a-z0-9+.-]*:/i.test(value);
+    return isExternalReference(value);
 }
 function nonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
@@ -677,6 +2643,52 @@ function validateProductDesign(label, data, errors) {
         }
     }
 }
+function validateProductionSpec(label, data, errors) {
+    for (const key of ["scope", "requirements", "interfaces", "verification", "change_readiness"]) {
+        if (key in data && !isRecord(data[key])) {
+            errors.push(`${label} ${key} must be a mapping`);
+        }
+    }
+    const changeReadiness = data.change_readiness;
+    if (isRecord(changeReadiness)) {
+        for (const key of ["ready", "next_command"]) {
+            if (!(key in changeReadiness)) {
+                errors.push(`${label} change_readiness missing ${key}`);
+            }
+        }
+    }
+}
+function validateProductionChange(label, data, errors) {
+    for (const key of ["goals", "non_goals", "affected_paths", "acceptance", "validation", "risks"]) {
+        if (key in data && !Array.isArray(data[key])) {
+            errors.push(`${label} ${key} must be an array`);
+        }
+    }
+    const runtimeReadiness = data.runtime_readiness;
+    if (isRecord(runtimeReadiness)) {
+        for (const key of ["ready", "next_command"]) {
+            if (!(key in runtimeReadiness)) {
+                errors.push(`${label} runtime_readiness missing ${key}`);
+            }
+        }
+    }
+}
+function validateTeamRuntime(label, data, errors) {
+    if (typeof data.execution_mode === "string" && !["single_agent", "agent_team", "reconcile", "qa_fix"].includes(data.execution_mode)) {
+        errors.push(`${label} has invalid execution_mode ${data.execution_mode}`);
+    }
+    for (const key of ["work_queue", "agents", "issues", "checkpoints"]) {
+        if (key in data && !Array.isArray(data[key])) {
+            errors.push(`${label} ${key} must be an array`);
+        }
+    }
+    if ("verification" in data && !isRecord(data.verification)) {
+        errors.push(`${label} verification must be a mapping`);
+    }
+    if ("handoff" in data && !isRecord(data.handoff)) {
+        errors.push(`${label} handoff must be a mapping`);
+    }
+}
 function validateActivePointer(root, path, data, errors) {
     const rule = [
         pointerRule("VISION_CONTRACT.yaml", "current_session", "sessions", "session_id", "path"),
@@ -684,6 +2696,9 @@ function validateActivePointer(root, path, data, errors) {
         pointerRule("PROTOTYPE_INDEX.yaml", "current_prototype", "prototypes", "prototype_id", "path"),
         pointerRule("DECISION_INDEX.yaml", "current_decision", "decisions", "decision_id", "path"),
         pointerRule("DESIGN_INDEX.yaml", "current_design", "designs", "design_id", "path"),
+        pointerRule("SPEC_INDEX.yaml", "current_spec", "specs", "spec_id", "path"),
+        pointerRule("CHANGE_INDEX.yaml", "current_change", "changes", "change_id", "path"),
+        pointerRule("RUNTIME_INDEX.yaml", "current_run", "runs", "run_id", "path"),
     ].find((item) => basename(path) === item.fileName);
     if (!rule) {
         return;