@vibe-engineer/adapter-pi 0.1.0 → 0.2.0

package/dist/{chunk-VXZJPOEE.js → chunk-QEXU5LD2.js}

@@ -10,9 +10,21 @@ var GENERATED_FILE_FAMILY_IDS = [
   "context-files",
   "harness-config"
 ];
-var SANDBOX_CAPABILITY_STATES = ["proven", "not_provided", "unknown", "blocked", "pending-live"];
+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 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"
@@ -108,8 +120,15 @@ var checkExactStringSet = (value, expected, path, code, issues, message) => {
   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.");
+  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);
@@ -118,7 +137,11 @@ 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"],
+    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",
@@ -136,7 +159,10 @@ var GENERATED_FILE_FAMILY_CONTRACTS = {
   "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"],
+    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",
@@ -154,7 +180,11 @@ var GENERATED_FILE_FAMILY_CONTRACTS = {
   "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"],
+    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",
@@ -172,7 +202,10 @@ var GENERATED_FILE_FAMILY_CONTRACTS = {
   "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"],
+    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",
@@ -190,7 +223,11 @@ var GENERATED_FILE_FAMILY_CONTRACTS = {
   "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"],
+    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",
@@ -206,9 +243,17 @@ var GENERATED_FILE_FAMILY_CONTRACTS = {
     readinessState: "ready"
   },
   "harness-config": {
-    pathPatterns: ["generated harness config field: agenticHarness=pi", "generated harness config field: adapterCapabilityVersion", "generated harness config field: generatedFileManifestVersion"],
+    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"],
+    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",
@@ -233,7 +278,12 @@ var validateEvidenceRecord = (value, path, issues) => {
   checkString(value.notes, `${path}.notes`, issues);
 };
 var validateCapabilitySurface = (value, path, issues) => {
-  if (!checkExactObject(value, path, ["evidence", "support", "details", "downstreamConsequence"], issues)) {
+  if (!checkExactObject(
+    value,
+    path,
+    ["evidence", "support", "details", "downstreamConsequence"],
+    issues
+  )) {
     return;
   }
   validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
@@ -242,7 +292,18 @@ var validateCapabilitySurface = (value, path, issues) => {
   checkString(value.downstreamConsequence, `${path}.downstreamConsequence`, issues);
 };
 var validateVersionCompatibility = (value, path, issues) => {
-  if (!checkExactObject(value, path, ["harnessName", "harnessVersionRange", "resourceFormatVersion", "runtimeRequirements", "compatibilityEvidence"], issues)) {
+  if (!checkExactObject(
+    value,
+    path,
+    [
+      "harnessName",
+      "harnessVersionRange",
+      "resourceFormatVersion",
+      "runtimeRequirements",
+      "compatibilityEvidence"
+    ],
+    issues
+  )) {
     return;
   }
   checkString(value.harnessName, `${path}.harnessName`, issues);
@@ -252,7 +313,12 @@ var validateVersionCompatibility = (value, path, issues) => {
   validateEvidenceRecord(value.compatibilityEvidence, `${path}.compatibilityEvidence`, issues);
 };
 var validateSkillCapability = (value, path, issues) => {
-  if (!checkExactObject(value, path, ["skillId", "nativeCommand", "resourceFamily", "evidence", "readiness", "protocolSource"], issues)) {
+  if (!checkExactObject(
+    value,
+    path,
+    ["skillId", "nativeCommand", "resourceFamily", "evidence", "readiness", "protocolSource"],
+    issues
+  )) {
     return;
   }
   checkLiteral(value.skillId, SKILL_IDS, `${path}.skillId`, issues);
@@ -263,7 +329,20 @@ var validateSkillCapability = (value, path, issues) => {
   checkString(value.protocolSource, `${path}.protocolSource`, issues);
 };
 var validateSkillsCommandsSurface = (value, path, issues) => {
-  if (!checkExactObject(value, path, ["evidence", "support", "details", "downstreamConsequence", "nativeFormat", "autoloadDiscovery", "skills"], issues)) {
+  if (!checkExactObject(
+    value,
+    path,
+    [
+      "evidence",
+      "support",
+      "details",
+      "downstreamConsequence",
+      "nativeFormat",
+      "autoloadDiscovery",
+      "skills"
+    ],
+    issues
+  )) {
     return;
   }
   validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
@@ -279,18 +358,40 @@ var validateSkillsCommandsSurface = (value, path, issues) => {
   }
 };
 var validateSubagentOrPlanCapability = (value, path, issues) => {
-  if (!checkExactObject(value, path, ["evidence", "support", "details", "downstreamConsequence", "implementationKind", "requiresGeneratedExtension"], 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);
+  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)) {
+  if (!checkExactObject(
+    value,
+    path,
+    ["interactive", "printMode", "jsonMode", "rpcMode", "sdk", "shellCommandPolicy"],
+    issues
+  )) {
     return;
   }
   validateCapabilitySurface(value.interactive, `${path}.interactive`, issues);
@@ -298,23 +399,50 @@ var validateCommandInvocationModel = (value, path, 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);
+  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)) {
+  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);
+      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)) {
+  if (!checkExactObject(
+    value,
+    path,
+    [
+      "evidence",
+      "support",
+      "details",
+      "downstreamConsequence",
+      "distributionKinds",
+      "trustUpdatePolicy"
+    ],
+    issues
+  )) {
     return;
   }
   validateEvidenceRecord(value.evidence, `${path}.evidence`, issues);
@@ -323,48 +451,162 @@ var validatePackageDistributionCapability = (value, path, 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);
+      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)) {
+  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);
+  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)) {
+  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"]) {
+  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);
+  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)) {
+  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);
+  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);
+  validateI14ARuntimeExecutionClaim(
+    value.runtimeExecutionClaim,
+    `${path}.runtimeExecutionClaim`,
+    issues
+  );
 };
 var validateSelection = (value, path, issues) => {
-  if (!checkExactObject(value, path, ["manifestSelectable", "createImportSelectable", "readiness", "reason"], issues)) {
+  if (!checkExactObject(
+    value,
+    path,
+    ["manifestSelectable", "createImportSelectable", "readiness", "reason"],
+    issues
+  )) {
     return;
   }
   checkBoolean(value.manifestSelectable, `${path}.manifestSelectable`, issues);
@@ -373,47 +615,69 @@ var validateSelection = (value, path, 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)) {
+  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);
+  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);
+  validateCommandInvocationModel(
+    value.commandInvocationModel,
+    `${path}.commandInvocationModel`,
+    issues
+  );
   validateGeneratedFilesCapability(value.generatedFiles, `${path}.generatedFiles`, issues);
-  validatePackageDistributionCapability(value.packageDistribution, `${path}.packageDistribution`, 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)) {
+  if (!checkExactObject(
+    value,
+    path,
+    ["ownerKind", "ownerId", "writePathScope", "allowedOperations"],
+    issues
+  )) {
     return;
   }
   checkLiteral(value.ownerKind, ["lane", "package"], `${path}.ownerKind`, issues);
@@ -421,33 +685,99 @@ var validateGeneratedFileOwner = (value, path, 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);
+      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)) {
+  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);
+  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);
+  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)) {
+  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);
+  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)) {
@@ -457,20 +787,45 @@ var validateGeneratedFileReadiness = (value, path, 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)) {
+  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);
+  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);
+      checkLiteral(
+        value.consumedByLanes[index],
+        GENERATED_FILE_CONSUMER_LANE_IDS,
+        `${path}.consumedByLanes[${index}]`,
+        issues
+      );
     }
   }
   validateGeneratedFileTrustSecurity(value.trustSecurity, `${path}.trustSecurity`, issues);
@@ -496,28 +851,50 @@ var getRecordArray = (value) => {
 };
 var validateCapabilityMatrix = (value) => {
   const issues = [];
-  if (!checkExactObject(value, "$", ["schemaVersion", "producedByLane", "adapterPackage", "adapters"], 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.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.");
+      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 : "");
+  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'.");
+    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}]`;
@@ -527,50 +904,125 @@ var validateCapabilityMatrix = (value) => {
     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.");
+      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.");
+        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.");
+        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"]) {
+      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.");
+          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.");
+        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.");
+        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.");
+        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 : "");
+      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}'.`);
+          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}'.`);
+        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.");
+      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.");
+      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.");
+      addIssue(
+        issues,
+        `${adapterPath}.capabilityFlags.hooks`,
+        "flag_without_known_evidence",
+        "Enabled hook capability requires known evidence."
+      );
     }
   }
   if (issues.length > 0) {
@@ -580,30 +1032,62 @@ var validateCapabilityMatrix = (value) => {
 };
 var validateGeneratedFileManifest = (value) => {
   const issues = [];
-  if (!checkExactObject(value, "$", ["schemaVersion", "adapterId", "adapterCapabilityVersion", "producedByLane", "families"], 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);
+  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.");
+      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 : "");
+  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}'.`);
+      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}'.`);
+    addIssue(
+      issues,
+      "$.families",
+      "duplicate_generated_file_family",
+      `Duplicate generated-file family '${duplicate}'.`
+    );
   }
   for (const [index, family] of families.entries()) {
     const familyPath = `$.families[${index}]`;
@@ -613,7 +1097,12 @@ var validateGeneratedFileManifest = (value) => {
     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.");
+      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];
@@ -626,7 +1115,12 @@ var validateGeneratedFileManifest = (value) => {
         `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}'.`);
+        addIssue(
+          issues,
+          `${familyPath}.producedByLane`,
+          "unsupported_value",
+          `Generated-file family '${family.familyId}' must be produced by '${contract.producerLane}'.`
+        );
       }
       checkExactStringSet(
         family.consumedByLanes,
@@ -638,10 +1132,20 @@ var validateGeneratedFileManifest = (value) => {
       );
       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.`);
+          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}'.`);
+          addIssue(
+            issues,
+            `${familyPath}.owner.ownerId`,
+            "unsupported_value",
+            `Generated-file family '${family.familyId}' owner lane must be '${contract.producerLane}'.`
+          );
         }
         checkExactStringSet(
           owner.writePathScope,
@@ -662,47 +1166,112 @@ var validateGeneratedFileManifest = (value) => {
       }
       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}'.`);
+          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.`);
+          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.`);
+          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}'.`);
+          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}'.`);
+          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}'.`);
+          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}'.`);
+          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}'.`);
+          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}'.`);
+          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}'.`);
+          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}'.`);
+        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.");
+      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.");
+      addIssue(
+        issues,
+        `${familyPath}.trustSecurity.executesCode`,
+        "unexpected_executable_family",
+        "Only extension/package manifest families may declare executable behavior in this manifest."
+      );
     }
   }
   if (issues.length > 0) {
@@ -713,11 +1282,15 @@ var validateGeneratedFileManifest = (value) => {
 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(",")}`);
+    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(",")}`);
+    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) {