@vibe-engineer/adapter-pi 0.1.0

package/dist/chunk-VXZJPOEE.js

@@ -0,0 +1,751 @@
+// src/schema/index.ts
+var EVIDENCE_STATES = ["known", "unknown", "deferred", "blocked"];
+var READINESS_STATES = ["ready", "unknown", "deferred", "blocked"];
+var SKILL_IDS = ["brainstorm", "grill-me", "task", "plan", "build", "ship"];
+var GENERATED_FILE_FAMILY_IDS = [
+  "pi-skill-files",
+  "pi-prompt-templates",
+  "pi-extensions",
+  "pi-package-manifest",
+  "context-files",
+  "harness-config"
+];
+var SANDBOX_CAPABILITY_STATES = ["proven", "not_provided", "unknown", "blocked", "pending-live"];
+var I14A_RUNTIME_EXECUTION_CLAIMS = ["not-claimed", "pending-live", "blocked"];
+var I14A_OUT_OF_SCOPE_RUNTIME_EXECUTION_CLAIMS = ["proven", "live-proven", "runtime-proven", "loaded", "executed"];
+var GENERATED_FILE_PRODUCER_LANE_IDS = [
+  "I-14B-pi-adapter-runtime-skill-consumption",
+  "I-15A-create-import-cli-ux-selected-harness"
+];
+var GENERATED_FILE_CONSUMER_LANE_IDS = [
+  "I-08-context-graph-index-drift",
+  "I-14B-pi-adapter-runtime-skill-consumption",
+  "I-15A-create-import-cli-ux-selected-harness",
+  "I-15B-starter-template-harness-consumption",
+  "I-18-security-safety-hooks-policy",
+  "I-21-build-skill-orchestration"
+];
+var hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var addIssue = (issues, path, code, message) => {
+  issues.push({ path, code, message });
+};
+var checkExactObject = (value, path, requiredKeys, issues) => {
+  if (!isRecord(value)) {
+    addIssue(issues, path, "expected_object", "Expected a JSON object.");
+    return false;
+  }
+  for (const key of requiredKeys) {
+    if (!hasOwn(value, key)) {
+      addIssue(issues, `${path}.${key}`, "missing_required", "Required field is missing.");
+    }
+  }
+  for (const key of Object.keys(value)) {
+    if (!requiredKeys.includes(key)) {
+      addIssue(issues, `${path}.${key}`, "unknown_field", "Unknown fields fail closed.");
+    }
+  }
+  return true;
+};
+var checkString = (value, path, issues) => {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    addIssue(issues, path, "expected_non_empty_string", "Expected a non-empty string.");
+    return false;
+  }
+  return true;
+};
+var checkBoolean = (value, path, issues) => {
+  if (typeof value !== "boolean") {
+    addIssue(issues, path, "expected_boolean", "Expected a boolean.");
+    return false;
+  }
+  return true;
+};
+var checkArray = (value, path, issues) => {
+  if (!Array.isArray(value)) {
+    addIssue(issues, path, "expected_array", "Expected an array.");
+    return false;
+  }
+  return true;
+};
+var checkStringArray = (value, path, issues, nonEmpty) => {
+  if (!checkArray(value, path, issues)) {
+    return false;
+  }
+  if (nonEmpty && value.length === 0) {
+    addIssue(issues, path, "empty_array", "Array must not be empty.");
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    checkString(value[index], `${path}[${index}]`, issues);
+  }
+  return true;
+};
+var checkLiteral = (value, allowed, path, issues) => {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    addIssue(issues, path, "unsupported_value", `Expected one of: ${allowed.join(", ")}.`);
+    return false;
+  }
+  return true;
+};
+var sameStringSet = (actual, expected) => {
+  if (actual.length !== expected.length) {
+    return false;
+  }
+  const actualSet = new Set(actual);
+  if (actualSet.size !== actual.length) {
+    return false;
+  }
+  return expected.every((expectedValue) => actualSet.has(expectedValue));
+};
+var checkExactStringSet = (value, expected, path, code, issues, message) => {
+  if (!checkStringArray(value, path, issues, true)) {
+    return false;
+  }
+  if (!sameStringSet(value, expected)) {
+    addIssue(issues, path, code, message);
+    return false;
+  }
+  return true;
+};
+var validateI14ARuntimeExecutionClaim = (value, path, issues) => {
+  if (typeof value === "string" && I14A_OUT_OF_SCOPE_RUNTIME_EXECUTION_CLAIMS.includes(value)) {
+    addIssue(issues, path, "i14a_runtime_claim_out_of_scope", "I-14A cannot claim live pi runtime execution; live-runtime proof belongs to I-14B.");
+    return false;
+  }
+  return checkLiteral(value, I14A_RUNTIME_EXECUTION_CLAIMS, path, issues);
+};
+var GENERATED_FILE_FAMILY_CONTRACTS = {
+  "pi-skill-files": {
+    pathPatterns: [".pi/skills/<skill>/SKILL.md", ".agents/skills/<skill>/SKILL.md"],
+    producerLane: "I-14B-pi-adapter-runtime-skill-consumption",
+    consumedByLanes: ["I-14B-pi-adapter-runtime-skill-consumption", "I-15A-create-import-cli-ux-selected-harness", "I-21-build-skill-orchestration"],
+    ownerKind: "lane",
+    allowedOperations: ["generate-in-later-lane", "validate"],
+    trustClassification: "project-instruction",
+    projectTrustRequired: true,
+    executesCode: false,
+    commandPolicy: "not-applicable",
+    sandboxCapability: "not_provided",
+    credentialPolicy: "no-credentials-required",
+    externalIntegration: "disabled-by-default",
+    destructiveOperationPolicy: "forbidden",
+    formatName: "Agent Skills SKILL.md",
+    formatVersion: "v1",
+    readinessState: "ready"
+  },
+  "pi-prompt-templates": {
+    pathPatterns: [".pi/prompts/<name>.md"],
+    producerLane: "I-14B-pi-adapter-runtime-skill-consumption",
+    consumedByLanes: ["I-14B-pi-adapter-runtime-skill-consumption", "I-15A-create-import-cli-ux-selected-harness"],
+    ownerKind: "lane",
+    allowedOperations: ["generate-in-later-lane", "validate"],
+    trustClassification: "project-instruction",
+    projectTrustRequired: true,
+    executesCode: false,
+    commandPolicy: "not-applicable",
+    sandboxCapability: "not_provided",
+    credentialPolicy: "no-credentials-required",
+    externalIntegration: "disabled-by-default",
+    destructiveOperationPolicy: "forbidden",
+    formatName: "Pi prompt template markdown",
+    formatVersion: "v1",
+    readinessState: "ready"
+  },
+  "pi-extensions": {
+    pathPatterns: [".pi/extensions/<name>.ts", ".pi/extensions/<name>/index.ts"],
+    producerLane: "I-14B-pi-adapter-runtime-skill-consumption",
+    consumedByLanes: ["I-14B-pi-adapter-runtime-skill-consumption", "I-18-security-safety-hooks-policy", "I-21-build-skill-orchestration"],
+    ownerKind: "lane",
+    allowedOperations: ["generate-in-later-lane", "validate"],
+    trustClassification: "executable-extension",
+    projectTrustRequired: true,
+    executesCode: true,
+    commandPolicy: "default-deny",
+    sandboxCapability: "not_provided",
+    credentialPolicy: "operator-supplied-only",
+    externalIntegration: "disabled-by-default",
+    destructiveOperationPolicy: "approval-required",
+    formatName: "Pi TypeScript extension",
+    formatVersion: "v1",
+    readinessState: "blocked"
+  },
+  "pi-package-manifest": {
+    pathPatterns: ["package.json#pi"],
+    producerLane: "I-14B-pi-adapter-runtime-skill-consumption",
+    consumedByLanes: ["I-14B-pi-adapter-runtime-skill-consumption", "I-15B-starter-template-harness-consumption"],
+    ownerKind: "lane",
+    allowedOperations: ["generate-in-later-lane", "validate"],
+    trustClassification: "package-manifest",
+    projectTrustRequired: true,
+    executesCode: true,
+    commandPolicy: "default-deny",
+    sandboxCapability: "not_provided",
+    credentialPolicy: "operator-supplied-only",
+    externalIntegration: "disabled-by-default",
+    destructiveOperationPolicy: "approval-required",
+    formatName: "Pi package manifest key",
+    formatVersion: "v1",
+    readinessState: "deferred"
+  },
+  "context-files": {
+    pathPatterns: ["AGENTS.md", "CLAUDE.md"],
+    producerLane: "I-15A-create-import-cli-ux-selected-harness",
+    consumedByLanes: ["I-15A-create-import-cli-ux-selected-harness", "I-08-context-graph-index-drift", "I-21-build-skill-orchestration"],
+    ownerKind: "lane",
+    allowedOperations: ["generate-in-later-lane", "validate"],
+    trustClassification: "project-instruction",
+    projectTrustRequired: true,
+    executesCode: false,
+    commandPolicy: "not-applicable",
+    sandboxCapability: "not_provided",
+    credentialPolicy: "no-credentials-required",
+    externalIntegration: "disabled-by-default",
+    destructiveOperationPolicy: "forbidden",
+    formatName: "Pi context file",
+    formatVersion: "v1",
+    readinessState: "ready"
+  },
+  "harness-config": {
+    pathPatterns: ["generated harness config field: agenticHarness=pi", "generated harness config field: adapterCapabilityVersion", "generated harness config field: generatedFileManifestVersion"],
+    producerLane: "I-15A-create-import-cli-ux-selected-harness",
+    consumedByLanes: ["I-15A-create-import-cli-ux-selected-harness", "I-15B-starter-template-harness-consumption", "I-21-build-skill-orchestration"],
+    ownerKind: "lane",
+    allowedOperations: ["generate-in-later-lane", "validate"],
+    trustClassification: "configuration",
+    projectTrustRequired: false,
+    executesCode: false,
+    commandPolicy: "not-applicable",
+    sandboxCapability: "not_provided",
+    credentialPolicy: "no-credentials-required",
+    externalIntegration: "disabled-by-default",
+    destructiveOperationPolicy: "forbidden",
+    formatName: "vibe-engineer harness adapter config",
+    formatVersion: "v1",
+    readinessState: "ready"
+  }
+};
+var validateEvidenceRecord = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["state", "source", "notes"], issues)) {
+    return;
+  }
+  checkLiteral(value.state, EVIDENCE_STATES, `${path}.state`, issues);
+  checkString(value.source, `${path}.source`, issues);
+  checkString(value.notes, `${path}.notes`, issues);
+};
+var validateCapabilitySurface = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["evidence", "support", "details", "downstreamConsequence"], issues)) {
+    return;
+  }
+  validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
+  checkLiteral(value.support, READINESS_STATES, `${path}.support`, issues);
+  checkString(value.details, `${path}.details`, issues);
+  checkString(value.downstreamConsequence, `${path}.downstreamConsequence`, issues);
+};
+var validateVersionCompatibility = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["harnessName", "harnessVersionRange", "resourceFormatVersion", "runtimeRequirements", "compatibilityEvidence"], issues)) {
+    return;
+  }
+  checkString(value.harnessName, `${path}.harnessName`, issues);
+  checkString(value.harnessVersionRange, `${path}.harnessVersionRange`, issues);
+  checkString(value.resourceFormatVersion, `${path}.resourceFormatVersion`, issues);
+  checkStringArray(value.runtimeRequirements, `${path}.runtimeRequirements`, issues, true);
+  validateEvidenceRecord(value.compatibilityEvidence, `${path}.compatibilityEvidence`, issues);
+};
+var validateSkillCapability = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["skillId", "nativeCommand", "resourceFamily", "evidence", "readiness", "protocolSource"], issues)) {
+    return;
+  }
+  checkLiteral(value.skillId, SKILL_IDS, `${path}.skillId`, issues);
+  checkString(value.nativeCommand, `${path}.nativeCommand`, issues);
+  checkLiteral(value.resourceFamily, GENERATED_FILE_FAMILY_IDS, `${path}.resourceFamily`, issues);
+  validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
+  checkLiteral(value.readiness, READINESS_STATES, `${path}.readiness`, issues);
+  checkString(value.protocolSource, `${path}.protocolSource`, issues);
+};
+var validateSkillsCommandsSurface = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["evidence", "support", "details", "downstreamConsequence", "nativeFormat", "autoloadDiscovery", "skills"], issues)) {
+    return;
+  }
+  validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
+  checkLiteral(value.support, READINESS_STATES, `${path}.support`, issues);
+  checkString(value.details, `${path}.details`, issues);
+  checkString(value.downstreamConsequence, `${path}.downstreamConsequence`, issues);
+  checkString(value.nativeFormat, `${path}.nativeFormat`, issues);
+  checkStringArray(value.autoloadDiscovery, `${path}.autoloadDiscovery`, issues, true);
+  if (checkArray(value.skills, `${path}.skills`, issues)) {
+    for (let index = 0; index < value.skills.length; index += 1) {
+      validateSkillCapability(value.skills[index], `${path}.skills[${index}]`, issues);
+    }
+  }
+};
+var validateSubagentOrPlanCapability = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["evidence", "support", "details", "downstreamConsequence", "implementationKind", "requiresGeneratedExtension"], issues)) {
+    return;
+  }
+  validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
+  checkLiteral(value.support, READINESS_STATES, `${path}.support`, issues);
+  checkString(value.details, `${path}.details`, issues);
+  checkString(value.downstreamConsequence, `${path}.downstreamConsequence`, issues);
+  checkLiteral(value.implementationKind, ["built-in", "extension-built", "external", "unsupported"], `${path}.implementationKind`, issues);
+  checkBoolean(value.requiresGeneratedExtension, `${path}.requiresGeneratedExtension`, issues);
+};
+var validateCommandInvocationModel = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["interactive", "printMode", "jsonMode", "rpcMode", "sdk", "shellCommandPolicy"], issues)) {
+    return;
+  }
+  validateCapabilitySurface(value.interactive, `${path}.interactive`, issues);
+  validateCapabilitySurface(value.printMode, `${path}.printMode`, issues);
+  validateCapabilitySurface(value.jsonMode, `${path}.jsonMode`, issues);
+  validateCapabilitySurface(value.rpcMode, `${path}.rpcMode`, issues);
+  validateCapabilitySurface(value.sdk, `${path}.sdk`, issues);
+  checkLiteral(value.shellCommandPolicy, ["not-required", "default-deny", "blocked"], `${path}.shellCommandPolicy`, issues);
+};
+var validateGeneratedFilesCapability = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["evidence", "manifestSchemaVersion", "families", "downstreamConsequence"], issues)) {
+    return;
+  }
+  validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
+  checkString(value.manifestSchemaVersion, `${path}.manifestSchemaVersion`, issues);
+  if (checkArray(value.families, `${path}.families`, issues)) {
+    for (let index = 0; index < value.families.length; index += 1) {
+      checkLiteral(value.families[index], GENERATED_FILE_FAMILY_IDS, `${path}.families[${index}]`, issues);
+    }
+  }
+  checkString(value.downstreamConsequence, `${path}.downstreamConsequence`, issues);
+};
+var validatePackageDistributionCapability = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["evidence", "support", "details", "downstreamConsequence", "distributionKinds", "trustUpdatePolicy"], issues)) {
+    return;
+  }
+  validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
+  checkLiteral(value.support, READINESS_STATES, `${path}.support`, issues);
+  checkString(value.details, `${path}.details`, issues);
+  checkString(value.downstreamConsequence, `${path}.downstreamConsequence`, issues);
+  if (checkArray(value.distributionKinds, `${path}.distributionKinds`, issues)) {
+    for (let index = 0; index < value.distributionKinds.length; index += 1) {
+      checkLiteral(value.distributionKinds[index], ["project-local-files", "pi-package", "npm-package", "global-install"], `${path}.distributionKinds[${index}]`, issues);
+    }
+  }
+  checkString(value.trustUpdatePolicy, `${path}.trustUpdatePolicy`, issues);
+};
+var validateSecurityTrustCapability = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["evidence", "projectTrustRequired", "extensionExecution", "commandPolicy", "sandboxCapability", "credentialPolicy", "destructiveOperations", "externalIntegration", "trustBoundary"], issues)) {
+    return;
+  }
+  validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
+  checkBoolean(value.projectTrustRequired, `${path}.projectTrustRequired`, issues);
+  checkLiteral(value.extensionExecution, ["none", "typescript-extension", "package-extension"], `${path}.extensionExecution`, issues);
+  checkLiteral(value.commandPolicy, ["default-deny", "not-applicable"], `${path}.commandPolicy`, issues);
+  checkLiteral(value.sandboxCapability, SANDBOX_CAPABILITY_STATES, `${path}.sandboxCapability`, issues);
+  checkLiteral(value.credentialPolicy, ["no-credentials-required", "operator-supplied-only", "unknown-blocked"], `${path}.credentialPolicy`, issues);
+  checkLiteral(value.destructiveOperations, ["forbidden", "approval-required", "not-applicable"], `${path}.destructiveOperations`, issues);
+  checkLiteral(value.externalIntegration, ["disabled-by-default", "read-only", "unknown-blocked"], `${path}.externalIntegration`, issues);
+  checkString(value.trustBoundary, `${path}.trustBoundary`, issues);
+};
+var validateCapabilityFlags = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["skills", "prompts", "hooks", "extensions", "subagents", "planMode", "contextFiles", "rpc", "sdk", "jsonMode", "packages", "ui", "unsupportedFeaturePolicy"], issues)) {
+    return;
+  }
+  for (const key of ["skills", "prompts", "hooks", "extensions", "subagents", "planMode", "contextFiles", "rpc", "sdk", "jsonMode", "packages", "ui"]) {
+    checkBoolean(value[key], `${path}.${key}`, issues);
+  }
+  checkLiteral(value.unsupportedFeaturePolicy, ["block", "defer", "unknown-block"], `${path}.unsupportedFeaturePolicy`, issues);
+};
+var validateRealBoundaryWitness = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["evidence", "boundaryStatus", "producer", "carrier", "consumer", "evidencePath", "runtimeExecutionClaim"], issues)) {
+    return;
+  }
+  validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
+  checkLiteral(value.boundaryStatus, ["implemented", "pending-live", "blocked", "deferred", "unknown"], `${path}.boundaryStatus`, issues);
+  checkString(value.producer, `${path}.producer`, issues);
+  checkString(value.carrier, `${path}.carrier`, issues);
+  checkString(value.consumer, `${path}.consumer`, issues);
+  checkString(value.evidencePath, `${path}.evidencePath`, issues);
+  validateI14ARuntimeExecutionClaim(value.runtimeExecutionClaim, `${path}.runtimeExecutionClaim`, issues);
+};
+var validateSelection = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["manifestSelectable", "createImportSelectable", "readiness", "reason"], issues)) {
+    return;
+  }
+  checkBoolean(value.manifestSelectable, `${path}.manifestSelectable`, issues);
+  checkBoolean(value.createImportSelectable, `${path}.createImportSelectable`, issues);
+  checkLiteral(value.readiness, READINESS_STATES, `${path}.readiness`, issues);
+  checkString(value.reason, `${path}.reason`, issues);
+};
+var validateAdapterCapability = (value, path, issues) => {
+  if (!checkExactObject(value, path, [
+    "adapterId",
+    "displayName",
+    "evidenceStatus",
+    "versionCompatibility",
+    "skillsCommandsSurface",
+    "promptTemplateSurface",
+    "hookEventSupport",
+    "subagentCapability",
+    "planModeCapability",
+    "contextFileConventions",
+    "commandInvocationModel",
+    "generatedFiles",
+    "packageDistribution",
+    "securityTrust",
+    "capabilityFlags",
+    "realBoundaryWitness",
+    "selection"
+  ], issues)) {
+    return;
+  }
+  checkString(value.adapterId, `${path}.adapterId`, issues);
+  checkString(value.displayName, `${path}.displayName`, issues);
+  validateEvidenceRecord(value.evidenceStatus, `${path}.evidenceStatus`, issues);
+  validateVersionCompatibility(value.versionCompatibility, `${path}.versionCompatibility`, issues);
+  validateSkillsCommandsSurface(value.skillsCommandsSurface, `${path}.skillsCommandsSurface`, issues);
+  validateCapabilitySurface(value.promptTemplateSurface, `${path}.promptTemplateSurface`, issues);
+  validateCapabilitySurface(value.hookEventSupport, `${path}.hookEventSupport`, issues);
+  validateSubagentOrPlanCapability(value.subagentCapability, `${path}.subagentCapability`, issues);
+  validateSubagentOrPlanCapability(value.planModeCapability, `${path}.planModeCapability`, issues);
+  validateCapabilitySurface(value.contextFileConventions, `${path}.contextFileConventions`, issues);
+  validateCommandInvocationModel(value.commandInvocationModel, `${path}.commandInvocationModel`, issues);
+  validateGeneratedFilesCapability(value.generatedFiles, `${path}.generatedFiles`, issues);
+  validatePackageDistributionCapability(value.packageDistribution, `${path}.packageDistribution`, issues);
+  validateSecurityTrustCapability(value.securityTrust, `${path}.securityTrust`, issues);
+  validateCapabilityFlags(value.capabilityFlags, `${path}.capabilityFlags`, issues);
+  validateRealBoundaryWitness(value.realBoundaryWitness, `${path}.realBoundaryWitness`, issues);
+  validateSelection(value.selection, `${path}.selection`, issues);
+};
+var validateGeneratedFileOwner = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["ownerKind", "ownerId", "writePathScope", "allowedOperations"], issues)) {
+    return;
+  }
+  checkLiteral(value.ownerKind, ["lane", "package"], `${path}.ownerKind`, issues);
+  checkLiteral(value.ownerId, GENERATED_FILE_PRODUCER_LANE_IDS, `${path}.ownerId`, issues);
+  checkStringArray(value.writePathScope, `${path}.writePathScope`, issues, true);
+  if (checkArray(value.allowedOperations, `${path}.allowedOperations`, issues)) {
+    for (let index = 0; index < value.allowedOperations.length; index += 1) {
+      checkLiteral(value.allowedOperations[index], ["declare", "validate", "generate-in-later-lane"], `${path}.allowedOperations[${index}]`, issues);
+    }
+  }
+};
+var validateGeneratedFileTrustSecurity = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["classification", "trustBoundary", "projectTrustRequired", "executesCode", "commandPolicy", "sandboxCapability", "credentialPolicy", "externalIntegration", "destructiveOperationPolicy", "evidence"], issues)) {
+    return;
+  }
+  checkLiteral(value.classification, ["project-instruction", "executable-extension", "package-manifest", "configuration"], `${path}.classification`, issues);
+  checkString(value.trustBoundary, `${path}.trustBoundary`, issues);
+  checkBoolean(value.projectTrustRequired, `${path}.projectTrustRequired`, issues);
+  checkBoolean(value.executesCode, `${path}.executesCode`, issues);
+  checkLiteral(value.commandPolicy, ["default-deny", "not-applicable"], `${path}.commandPolicy`, issues);
+  checkLiteral(value.sandboxCapability, SANDBOX_CAPABILITY_STATES, `${path}.sandboxCapability`, issues);
+  checkLiteral(value.credentialPolicy, ["no-credentials-required", "operator-supplied-only", "unknown-blocked"], `${path}.credentialPolicy`, issues);
+  checkLiteral(value.externalIntegration, ["disabled-by-default", "read-only", "unknown-blocked"], `${path}.externalIntegration`, issues);
+  checkLiteral(value.destructiveOperationPolicy, ["forbidden", "approval-required", "not-applicable"], `${path}.destructiveOperationPolicy`, issues);
+  validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
+};
+var validateGeneratedFileVersion = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["formatName", "formatVersion", "schemaVersion", "adapterCapabilityVersion"], issues)) {
+    return;
+  }
+  checkString(value.formatName, `${path}.formatName`, issues);
+  checkString(value.formatVersion, `${path}.formatVersion`, issues);
+  checkLiteral(value.schemaVersion, ["pi-generated-file-manifest/v1"], `${path}.schemaVersion`, issues);
+  checkLiteral(value.adapterCapabilityVersion, ["pi-adapter-capability-matrix/v1"], `${path}.adapterCapabilityVersion`, issues);
+};
+var validateGeneratedFileReadiness = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["state", "reason"], issues)) {
+    return;
+  }
+  checkLiteral(value.state, READINESS_STATES, `${path}.state`, issues);
+  checkString(value.reason, `${path}.reason`, issues);
+};
+var validateGeneratedFileFamily = (value, path, issues) => {
+  if (!checkExactObject(value, path, ["familyId", "description", "pathPatterns", "owner", "producedByLane", "consumedByLanes", "trustSecurity", "version", "readiness"], issues)) {
+    return;
+  }
+  checkLiteral(value.familyId, GENERATED_FILE_FAMILY_IDS, `${path}.familyId`, issues);
+  checkString(value.description, `${path}.description`, issues);
+  checkStringArray(value.pathPatterns, `${path}.pathPatterns`, issues, true);
+  validateGeneratedFileOwner(value.owner, `${path}.owner`, issues);
+  checkLiteral(value.producedByLane, GENERATED_FILE_PRODUCER_LANE_IDS, `${path}.producedByLane`, issues);
+  if (checkArray(value.consumedByLanes, `${path}.consumedByLanes`, issues)) {
+    if (value.consumedByLanes.length === 0) {
+      addIssue(issues, `${path}.consumedByLanes`, "empty_array", "Array must not be empty.");
+    }
+    for (let index = 0; index < value.consumedByLanes.length; index += 1) {
+      checkLiteral(value.consumedByLanes[index], GENERATED_FILE_CONSUMER_LANE_IDS, `${path}.consumedByLanes[${index}]`, issues);
+    }
+  }
+  validateGeneratedFileTrustSecurity(value.trustSecurity, `${path}.trustSecurity`, issues);
+  validateGeneratedFileVersion(value.version, `${path}.version`, issues);
+  validateGeneratedFileReadiness(value.readiness, `${path}.readiness`, issues);
+};
+var collectDuplicateStrings = (values) => {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (seen.has(value)) {
+      duplicates.add(value);
+    }
+    seen.add(value);
+  }
+  return [...duplicates].sort();
+};
+var getRecordArray = (value) => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter(isRecord);
+};
+var validateCapabilityMatrix = (value) => {
+  const issues = [];
+  if (!checkExactObject(value, "$", ["schemaVersion", "producedByLane", "adapterPackage", "adapters"], issues)) {
+    return { valid: false, issues };
+  }
+  checkLiteral(value.schemaVersion, ["pi-adapter-capability-matrix/v1"], "$.schemaVersion", issues);
+  checkLiteral(value.producedByLane, ["I-14A-pi-adapter-capability-generated-file-manifest"], "$.producedByLane", issues);
+  checkLiteral(value.adapterPackage, ["@vibe-engineer/adapter-pi"], "$.adapterPackage", issues);
+  if (checkArray(value.adapters, "$.adapters", issues)) {
+    if (value.adapters.length === 0) {
+      addIssue(issues, "$.adapters", "empty_adapters", "Capability matrix must contain adapter rows.");
+    }
+    for (let index = 0; index < value.adapters.length; index += 1) {
+      validateAdapterCapability(value.adapters[index], `$.adapters[${index}]`, issues);
+    }
+  }
+  const adapters = getRecordArray(value.adapters);
+  const ids = adapters.map((adapter) => typeof adapter.adapterId === "string" ? adapter.adapterId : "");
+  for (const duplicate of collectDuplicateStrings(ids.filter((id) => id.length > 0))) {
+    addIssue(issues, "$.adapters", "duplicate_adapter_id", `Duplicate adapter id '${duplicate}'.`);
+  }
+  const piAdapter = adapters.find((adapter) => adapter.adapterId === "pi");
+  if (piAdapter === void 0) {
+    addIssue(issues, "$.adapters", "missing_pi_adapter", "Capability matrix must include stable adapter id 'pi'.");
+  }
+  for (const [index, adapter] of adapters.entries()) {
+    const adapterPath = `$.adapters[${index}]`;
+    const selection = isRecord(adapter.selection) ? adapter.selection : void 0;
+    const flags = isRecord(adapter.capabilityFlags) ? adapter.capabilityFlags : void 0;
+    const evidenceStatus = isRecord(adapter.evidenceStatus) ? adapter.evidenceStatus : void 0;
+    const skillsSurface = isRecord(adapter.skillsCommandsSurface) ? adapter.skillsCommandsSurface : void 0;
+    const adapterId = typeof adapter.adapterId === "string" ? adapter.adapterId : "";
+    if (flags?.unsupportedFeaturePolicy !== "block") {
+      addIssue(issues, `${adapterPath}.capabilityFlags.unsupportedFeaturePolicy`, "unsupported_feature_policy_not_blocking", "Unsupported features must block instead of silently no-oping.");
+    }
+    if (adapterId !== "pi") {
+      if (selection?.manifestSelectable === true || selection?.createImportSelectable === true || selection?.readiness === "ready") {
+        addIssue(issues, `${adapterPath}.selection`, "non_pi_selectable", "Non-pi adapter rows must never be selectable or ready.");
+      }
+      if (evidenceStatus?.state === "known") {
+        addIssue(issues, `${adapterPath}.evidenceStatus.state`, "non_pi_known_claim", "Non-pi adapter rows must remain explicit unknown/deferred/blocked until future evidence-backed decisions.");
+      }
+      for (const flagKey of ["skills", "prompts", "hooks", "extensions", "subagents", "planMode", "contextFiles", "rpc", "sdk", "jsonMode", "packages", "ui"]) {
+        if (flags?.[flagKey] === true) {
+          addIssue(issues, `${adapterPath}.capabilityFlags.${flagKey}`, "non_pi_enabled_flag", "Non-pi capability flags cannot be enabled in v1.");
+        }
+      }
+    }
+    if (adapterId === "pi") {
+      if (selection?.manifestSelectable !== true) {
+        addIssue(issues, `${adapterPath}.selection.manifestSelectable`, "pi_manifest_not_selectable", "The pi manifest contract must be selectable for downstream manifest consumers.");
+      }
+      if (selection?.createImportSelectable !== false) {
+        addIssue(issues, `${adapterPath}.selection.createImportSelectable`, "create_import_claim_out_of_scope", "I-14A must not claim create/import selectable behavior.");
+      }
+      if (evidenceStatus?.state !== "known") {
+        addIssue(issues, `${adapterPath}.evidenceStatus.state`, "pi_evidence_not_known", "The pi adapter row must carry known design evidence for this contract.");
+      }
+      const skills = Array.isArray(skillsSurface?.skills) ? skillsSurface.skills : [];
+      const skillIds = skills.map((skill) => isRecord(skill) && typeof skill.skillId === "string" ? skill.skillId : "");
+      for (const expectedSkill of SKILL_IDS) {
+        if (!skillIds.includes(expectedSkill)) {
+          addIssue(issues, `${adapterPath}.skillsCommandsSurface.skills`, "missing_skill_mapping", `Missing required six-skill mapping '${expectedSkill}'.`);
+        }
+      }
+      for (const duplicate of collectDuplicateStrings(skillIds.filter((id) => id.length > 0))) {
+        addIssue(issues, `${adapterPath}.skillsCommandsSurface.skills`, "duplicate_skill_mapping", `Duplicate skill mapping '${duplicate}'.`);
+      }
+    }
+    if (flags?.skills === true && skillsSurface?.evidence !== void 0 && isRecord(skillsSurface.evidence) && skillsSurface.evidence.state !== "known") {
+      addIssue(issues, `${adapterPath}.capabilityFlags.skills`, "flag_without_known_evidence", "Enabled skill capability requires known evidence.");
+    }
+    if (flags?.prompts === true && isRecord(adapter.promptTemplateSurface) && isRecord(adapter.promptTemplateSurface.evidence) && adapter.promptTemplateSurface.evidence.state !== "known") {
+      addIssue(issues, `${adapterPath}.capabilityFlags.prompts`, "flag_without_known_evidence", "Enabled prompt capability requires known evidence.");
+    }
+    if (flags?.hooks === true && isRecord(adapter.hookEventSupport) && isRecord(adapter.hookEventSupport.evidence) && adapter.hookEventSupport.evidence.state !== "known") {
+      addIssue(issues, `${adapterPath}.capabilityFlags.hooks`, "flag_without_known_evidence", "Enabled hook capability requires known evidence.");
+    }
+  }
+  if (issues.length > 0) {
+    return { valid: false, issues };
+  }
+  return { valid: true, value, issues: [] };
+};
+var validateGeneratedFileManifest = (value) => {
+  const issues = [];
+  if (!checkExactObject(value, "$", ["schemaVersion", "adapterId", "adapterCapabilityVersion", "producedByLane", "families"], issues)) {
+    return { valid: false, issues };
+  }
+  checkLiteral(value.schemaVersion, ["pi-generated-file-manifest/v1"], "$.schemaVersion", issues);
+  checkLiteral(value.adapterId, ["pi"], "$.adapterId", issues);
+  checkLiteral(value.adapterCapabilityVersion, ["pi-adapter-capability-matrix/v1"], "$.adapterCapabilityVersion", issues);
+  checkLiteral(value.producedByLane, ["I-14A-pi-adapter-capability-generated-file-manifest"], "$.producedByLane", issues);
+  if (checkArray(value.families, "$.families", issues)) {
+    if (value.families.length === 0) {
+      addIssue(issues, "$.families", "empty_families", "Generated-file manifest must enumerate file families.");
+    }
+    for (let index = 0; index < value.families.length; index += 1) {
+      validateGeneratedFileFamily(value.families[index], `$.families[${index}]`, issues);
+    }
+  }
+  const families = getRecordArray(value.families);
+  const familyIds = families.map((family) => typeof family.familyId === "string" ? family.familyId : "");
+  for (const expectedFamily of GENERATED_FILE_FAMILY_IDS) {
+    if (!familyIds.includes(expectedFamily)) {
+      addIssue(issues, "$.families", "missing_generated_file_family", `Missing generated-file family '${expectedFamily}'.`);
+    }
+  }
+  for (const duplicate of collectDuplicateStrings(familyIds.filter((id) => id.length > 0))) {
+    addIssue(issues, "$.families", "duplicate_generated_file_family", `Duplicate generated-file family '${duplicate}'.`);
+  }
+  for (const [index, family] of families.entries()) {
+    const familyPath = `$.families[${index}]`;
+    const owner = isRecord(family.owner) ? family.owner : void 0;
+    const trustSecurity = isRecord(family.trustSecurity) ? family.trustSecurity : void 0;
+    const version = isRecord(family.version) ? family.version : void 0;
+    const readiness = isRecord(family.readiness) ? family.readiness : void 0;
+    const consumedByLanes = Array.isArray(family.consumedByLanes) ? family.consumedByLanes : [];
+    if (!owner || !trustSecurity || !version || !readiness || consumedByLanes.length === 0) {
+      addIssue(issues, familyPath, "missing_fail_closed_metadata", "Owner, security/trust, version, readiness, and consumer data are mandatory.");
+    }
+    if (typeof family.familyId === "string" && GENERATED_FILE_FAMILY_IDS.includes(family.familyId)) {
+      const contract = GENERATED_FILE_FAMILY_CONTRACTS[family.familyId];
+      checkExactStringSet(
+        family.pathPatterns,
+        contract.pathPatterns,
+        `${familyPath}.pathPatterns`,
+        "missing_required_path_pattern",
+        issues,
+        `Generated-file family '${family.familyId}' must declare exactly the required path patterns: ${contract.pathPatterns.join(", ")}.`
+      );
+      if (family.producedByLane !== contract.producerLane) {
+        addIssue(issues, `${familyPath}.producedByLane`, "unsupported_value", `Generated-file family '${family.familyId}' must be produced by '${contract.producerLane}'.`);
+      }
+      checkExactStringSet(
+        family.consumedByLanes,
+        contract.consumedByLanes,
+        `${familyPath}.consumedByLanes`,
+        "unsupported_value",
+        issues,
+        `Generated-file family '${family.familyId}' must declare exactly the typed consumer lanes: ${contract.consumedByLanes.join(", ")}.`
+      );
+      if (owner !== void 0) {
+        if (owner.ownerKind !== contract.ownerKind) {
+          addIssue(issues, `${familyPath}.owner.ownerKind`, "unsupported_value", `Generated-file family '${family.familyId}' must be owned by a lane.`);
+        }
+        if (owner.ownerId !== contract.producerLane) {
+          addIssue(issues, `${familyPath}.owner.ownerId`, "unsupported_value", `Generated-file family '${family.familyId}' owner lane must be '${contract.producerLane}'.`);
+        }
+        checkExactStringSet(
+          owner.writePathScope,
+          contract.pathPatterns,
+          `${familyPath}.owner.writePathScope`,
+          "missing_required_path_pattern",
+          issues,
+          `Generated-file family '${family.familyId}' owner write scope must exactly match required path patterns.`
+        );
+        checkExactStringSet(
+          owner.allowedOperations,
+          contract.allowedOperations,
+          `${familyPath}.owner.allowedOperations`,
+          "unsupported_value",
+          issues,
+          `Generated-file family '${family.familyId}' owner operations must be typed and exact.`
+        );
+      }
+      if (trustSecurity !== void 0) {
+        if (trustSecurity.classification !== contract.trustClassification) {
+          addIssue(issues, `${familyPath}.trustSecurity.classification`, "unsupported_value", `Generated-file family '${family.familyId}' must use trust classification '${contract.trustClassification}'.`);
+        }
+        if (trustSecurity.projectTrustRequired !== contract.projectTrustRequired) {
+          addIssue(issues, `${familyPath}.trustSecurity.projectTrustRequired`, "unsupported_value", `Generated-file family '${family.familyId}' project-trust metadata must be exact.`);
+        }
+        if (trustSecurity.executesCode !== contract.executesCode) {
+          addIssue(issues, `${familyPath}.trustSecurity.executesCode`, "unsupported_value", `Generated-file family '${family.familyId}' executable-code metadata must be exact.`);
+        }
+        if (trustSecurity.commandPolicy !== contract.commandPolicy) {
+          addIssue(issues, `${familyPath}.trustSecurity.commandPolicy`, "unsupported_value", `Generated-file family '${family.familyId}' command policy must be '${contract.commandPolicy}'.`);
+        }
+        if (trustSecurity.sandboxCapability !== contract.sandboxCapability) {
+          addIssue(issues, `${familyPath}.trustSecurity.sandboxCapability`, "unsupported_value", `Generated-file family '${family.familyId}' sandbox metadata must be '${contract.sandboxCapability}'.`);
+        }
+        if (trustSecurity.credentialPolicy !== contract.credentialPolicy) {
+          addIssue(issues, `${familyPath}.trustSecurity.credentialPolicy`, "unsupported_value", `Generated-file family '${family.familyId}' credential policy must be '${contract.credentialPolicy}'.`);
+        }
+        if (trustSecurity.externalIntegration !== contract.externalIntegration) {
+          addIssue(issues, `${familyPath}.trustSecurity.externalIntegration`, "unsupported_value", `Generated-file family '${family.familyId}' external-integration policy must be '${contract.externalIntegration}'.`);
+        }
+        if (trustSecurity.destructiveOperationPolicy !== contract.destructiveOperationPolicy) {
+          addIssue(issues, `${familyPath}.trustSecurity.destructiveOperationPolicy`, "unsupported_value", `Generated-file family '${family.familyId}' destructive-operation policy must be '${contract.destructiveOperationPolicy}'.`);
+        }
+      }
+      if (version !== void 0) {
+        if (version.formatName !== contract.formatName) {
+          addIssue(issues, `${familyPath}.version.formatName`, "unsupported_value", `Generated-file family '${family.familyId}' format name must be '${contract.formatName}'.`);
+        }
+        if (version.formatVersion !== contract.formatVersion) {
+          addIssue(issues, `${familyPath}.version.formatVersion`, "unsupported_value", `Generated-file family '${family.familyId}' format version must be '${contract.formatVersion}'.`);
+        }
+      }
+      if (readiness !== void 0 && readiness.state !== contract.readinessState) {
+        addIssue(issues, `${familyPath}.readiness.state`, "unsupported_value", `Generated-file family '${family.familyId}' readiness state must be '${contract.readinessState}'.`);
+      }
+    }
+    if (family.familyId === "pi-extensions" && trustSecurity?.executesCode !== true) {
+      addIssue(issues, `${familyPath}.trustSecurity.executesCode`, "extension_execution_not_declared", "Pi extensions execute TypeScript and must declare executable trust/security implications.");
+    }
+    if (family.familyId !== "pi-extensions" && trustSecurity?.executesCode === true && trustSecurity.classification !== "package-manifest") {
+      addIssue(issues, `${familyPath}.trustSecurity.executesCode`, "unexpected_executable_family", "Only extension/package manifest families may declare executable behavior in this manifest.");
+    }
+  }
+  if (issues.length > 0) {
+    return { valid: false, issues };
+  }
+  return { valid: true, value, issues: [] };
+};
+var createDownstreamManifestSummary = (capabilityMatrix, generatedFileManifest) => {
+  const capabilityValidation = validateCapabilityMatrix(capabilityMatrix);
+  if (!capabilityValidation.valid) {
+    throw new Error(`Capability matrix failed validation: ${capabilityValidation.issues.map((issue) => issue.code).join(",")}`);
+  }
+  const manifestValidation = validateGeneratedFileManifest(generatedFileManifest);
+  if (!manifestValidation.valid) {
+    throw new Error(`Generated-file manifest failed validation: ${manifestValidation.issues.map((issue) => issue.code).join(",")}`);
+  }
+  const piAdapter = capabilityMatrix.adapters.find((adapter) => adapter.adapterId === "pi");
+  if (piAdapter === void 0) {
+    throw new Error("Validated matrix unexpectedly lacks pi adapter.");
+  }
+  return {
+    schemaVersion: "pi-adapter-downstream-summary/v1",
+    adapterId: "pi",
+    sixSkills: [...SKILL_IDS],
+    generatedFamilies: generatedFileManifest.families.map((family) => family.familyId),
+    manifestReady: piAdapter.selection.manifestSelectable,
+    createImportReady: false,
+    runtimeExecutionClaim: piAdapter.realBoundaryWitness.runtimeExecutionClaim,
+    blockedNonPiAdapters: capabilityMatrix.adapters.filter((adapter) => adapter.adapterId !== "pi").map((adapter) => adapter.adapterId)
+  };
+};
+
+export {
+  EVIDENCE_STATES,
+  READINESS_STATES,
+  SKILL_IDS,
+  GENERATED_FILE_FAMILY_IDS,
+  SANDBOX_CAPABILITY_STATES,
+  I14A_RUNTIME_EXECUTION_CLAIMS,
+  I14A_OUT_OF_SCOPE_RUNTIME_EXECUTION_CLAIMS,
+  GENERATED_FILE_PRODUCER_LANE_IDS,
+  GENERATED_FILE_CONSUMER_LANE_IDS,
+  validateCapabilityMatrix,
+  validateGeneratedFileManifest,
+  createDownstreamManifestSummary
+};