@vibe-engineer/adapter-pi 0.1.0 → 0.2.0

package/dist/chunk-BUGDS7N5.js

@@ -0,0 +1,1591 @@
+import {
+  GENERATED_FILE_FAMILY_IDS,
+  SKILL_IDS,
+  validateCapabilityMatrix
+} from "./chunk-QEXU5LD2.js";
+
+// src/capabilities/harness-adapter.ts
+var HARNESS_ADAPTER_CONTRACT_SCHEMA_VERSION = "vibe-harness-adapter-contract/v1";
+var HARNESS_GENERATED_FILE_MANIFEST_SCHEMA_VERSION = "vibe-harness-generated-file-manifest/v1";
+var HARNESS_ADAPTER_REGISTRY_SCHEMA_VERSION = "vibe-harness-adapter-registry/v1";
+var SUPPORTED_HARNESS_ADAPTER_IDS = ["pi", "claude-code", "codex"];
+var known = (source, notes) => ({
+  state: "known",
+  source,
+  notes
+});
+var blocked = (source, notes) => ({
+  state: "blocked",
+  source,
+  notes
+});
+var capability = (support, evidence, summary, downstreamConsequence, evidenceRefs = evidenceRefsForEvidence(evidence)) => ({
+  support,
+  evidence,
+  evidenceRefs,
+  summary,
+  downstreamConsequence
+});
+var family = (familyId, pathPatterns, support, producedByLane, writer, reason, evidence, evidenceRefs = evidenceRefsForEvidence(evidence)) => ({
+  familyId,
+  pathPatterns,
+  support,
+  producedByLane,
+  writer,
+  reason,
+  evidence,
+  evidenceRefs,
+  noFallbackToPi: true
+});
+var handoffStep = (stepId, inputArtifact, outputArtifact, nativeCommand, promptInstruction, persistenceRule, handoffRule, unsupportedNativeAssetNote) => ({
+  stepId,
+  inputArtifact,
+  outputArtifact,
+  nativeCommand,
+  promptInstruction,
+  persistenceRule,
+  handoffRule,
+  unsupportedNativeAssetNote
+});
+var handoffInstructionsFor = (adapterId) => {
+  const native = (stepId) => {
+    if (adapterId === "pi") return `/skill:${stepId}`;
+    if (adapterId === "claude-code") return `/vibe-${stepId}`;
+    if (adapterId === "codex") return `$vibe-${stepId}`;
+    return null;
+  };
+  const unsupportedNote = adapterId === "codex" ? "Codex has no evidenced project-local slash-command surface; invoke the generated project-local skill in the prompt (for example, `Use $vibe-task ...`) and persist artifacts instead of inventing .pi/.claude/.codex command or prompt-template files." : null;
+  return [
+    handoffStep(
+      "task",
+      "raw-intent",
+      "work-brief",
+      native("task"),
+      "Normalize exactly one operator request into a Work Brief before planning.",
+      "Persist .vibe/work/<work-id>/raw-intent.md when needed and .vibe/work/<work-id>/work-brief.json as the durable output.",
+      "Hand exactly one Work Brief to plan; do not produce implementation-plan, build-result, or ship-packet in task.",
+      unsupportedNote
+    ),
+    handoffStep(
+      "plan",
+      "work-brief",
+      "implementation-plan-with-verification-delta",
+      native("plan"),
+      "Consume one Work Brief and produce one Implementation Plan with embedded Verification Delta.",
+      "Persist .vibe/work/<work-id>/implementation-plan.json; keep status draft until explicit operator approval.",
+      "Hand an approved persisted plan to build; do not execute build or ship work from plan.",
+      unsupportedNote
+    ),
+    handoffStep(
+      "build",
+      "approved-implementation-plan",
+      "build-result",
+      native("build"),
+      "Implement only the approved plan scope and record deterministic evidence references.",
+      "Persist .vibe/work/<work-id>/build-result.json with changed files, evidence refs, and any blockers.",
+      "Hand the Build Result plus evidence to ship; do not claim release readiness without the persisted packet.",
+      unsupportedNote
+    ),
+    handoffStep(
+      "ship",
+      "build-result",
+      "ship-packet",
+      native("ship"),
+      "Review Build Result evidence and prepare a release/merge handoff packet without inventing missing proofs.",
+      "Persist .vibe/work/<work-id>/ship-packet.json with release notes, risks, and final evidence links.",
+      "Stop if required evidence is missing; do not push, deploy, or open external PRs unless explicitly authorized outside create/import.",
+      unsupportedNote
+    )
+  ];
+};
+var runtimePrerequisiteDiagnostic = (binary, displayName, message) => ({
+  diagnosticCode: "HARNESS_RUNTIME_UNAVAILABLE",
+  classification: "missing_prerequisite",
+  binary,
+  versionCommand: [binary, "--version"],
+  authPrerequisite: "Operator-managed local CLI authentication/subscription is required before any live model/runtime invocation; create/import do not perform auth probes.",
+  liveProbePolicy: "not-run-by-create-import",
+  unavailableRuntimeBehavior: "blocked-missing-prerequisite",
+  message,
+  missingBinaryMessage: `${displayName} binary '${binary}' is required for live harness runs; install it or select a supported installed harness explicitly. No Pi fallback is allowed.`,
+  missingAuthMessage: `${displayName} authentication/subscription is required for live harness runs; authenticate the '${binary}' CLI before invoking a live runner. No Pi fallback is allowed.`,
+  noFallbackToPi: true
+});
+var operatorPacketEvidenceRef = {
+  path: ".pi/autopilot/vibe-engineer-improvements/evidence/upstream/extract-harness-cli-evidence/harness-adapter-operator-packet.md",
+  description: "Accepted local CLI evidence packet for Pi, Claude Code, and Codex harness surfaces."
+};
+var dirtyTreeFixStatusEvidenceRef = {
+  path: ".pi/autopilot/vibe-engineer-improvements-final/statuses/fix-architecture-runner-dirty-tree-delta.fix.attempt-1.json",
+  description: "Implementation status for committed/staged/unstaged/untracked architecture-runner delta evidence."
+};
+var dirtyTreeValidationStatusEvidenceRef = {
+  path: ".pi/autopilot/vibe-engineer-improvements-final/statuses/validate-architecture-runner-dirty-tree-delta.validate.attempt-1.json",
+  description: "Accepted validation status for dirty-tree architecture-runner facts and no-fallback diagnostics."
+};
+var piAdapterContractEvidenceRef = {
+  path: "packages/adapters/pi/src/capabilities/index.ts",
+  description: "Existing Pi adapter capability matrix and trust/security manifest contract."
+};
+var piGeneratedManifestEvidenceRef = {
+  path: "packages/adapters/pi/src/generated-file-manifest/index.ts",
+  description: "Existing Pi generated-file family manifest for context, skills, prompts, extensions, and config."
+};
+var piEvidenceRefs = [
+  operatorPacketEvidenceRef,
+  piAdapterContractEvidenceRef,
+  piGeneratedManifestEvidenceRef
+];
+var claudeNativeEvidenceRef = {
+  path: ".pi/autopilot/vibe-engineer-improvements-final/context/implement-native-claude-code-support/claude-code-adapter-evidence.json",
+  description: "Authoritative Claude Code 2.1.197 native capability evidence for CLAUDE.md, .claude/commands, permissions, and JSON-schema print mode."
+};
+var claudeEvidenceRefs = [claudeNativeEvidenceRef];
+var codexNativeEvidenceRef = {
+  path: ".pi/autopilot/vibe-engineer-improvements-final/context/implement-native-codex-support/codex-native-adapter-evidence.json",
+  description: "Authoritative Codex CLI 0.142.4 native capability evidence for AGENTS.md, project-local .codex/skills, config, exec JSON/schema output, sandbox/approval policy, and unsupported surfaces."
+};
+var codexOperatorPacketEvidenceRef = {
+  path: ".pi/autopilot/vibe-engineer-improvements-final/context/implement-native-codex-support/codex-native-operator-packet.md",
+  description: "Native Codex implementation packet requiring .codex/skills/vibe-* assets, conservative config, codex exec runner flags, and no Pi fallback."
+};
+var codexEvidenceRefs = [codexNativeEvidenceRef, codexOperatorPacketEvidenceRef];
+var dirtyTreeRunnerEvidenceRefs = [
+  operatorPacketEvidenceRef,
+  dirtyTreeFixStatusEvidenceRef,
+  dirtyTreeValidationStatusEvidenceRef
+];
+function evidenceRefsForEvidence(evidence) {
+  if (evidence.source.includes("Codex") || evidence.source.includes("codex")) {
+    return codexEvidenceRefs;
+  }
+  if (evidence.source.includes("Claude") || evidence.source.includes("claude")) {
+    return claudeEvidenceRefs;
+  }
+  return piEvidenceRefs;
+}
+var piEvidence = known(
+  "extract-harness-cli-evidence + existing @vibe-engineer/adapter-pi manifests",
+  "Pi 0.80.2 local help and the existing Pi adapter prove AGENTS.md/CLAUDE.md, .pi skills, .pi prompt templates, JSON event mode, RPC, and project-trust semantics; built-in agents and plan mode remain blocked."
+);
+var claudeEvidence = known(
+  "claude-code-adapter-evidence.json: claude --version/help/print/agents/plugin/mcp plus local binary surface extraction",
+  "Claude Code 2.1.197 evidence proves CLAUDE.md auto-discovery, project .claude/commands/*.md custom commands, project/user skills, agents, hooks/plugins/MCP surfaces, print mode JSON/stream-json, --json-schema, --permission-mode plan, explicit tool allow/deny flags, and trust/safe/bare-mode semantics."
+);
+var codexEvidence = known(
+  "codex-native-adapter-evidence.json: codex --version/help/exec help/debug prompt-input/package skill evidence",
+  "Codex CLI 0.142.4 evidence proves AGENTS.md auto-loading, project-local .codex/skills/<name>/SKILL.md discovery, trusted-project .codex/config.toml defaults, codex exec JSONL events, --output-schema, --output-last-message, sandbox/approval flags, plugin and MCP surfaces, and explicit unsupported slash-command/prompt-template/agent/plan-mode surfaces."
+);
+var piBlockedEvidence = blocked(
+  "existing Pi adapter capability matrix",
+  "Pi extension/package, built-in agent/subagent, and built-in plan-mode generation require separate live runtime and security proof."
+);
+var claudeBlockedEvidence = known(
+  "claude-code-adapter-evidence.json safe default policy",
+  "Claude Code project commands are proven and generated for the core workflow. Skills, agents, hooks, plugins, and MCP are documented ready surfaces but are not generated by default because they are optional or trust-sensitive; standalone prompt templates distinct from commands/skills are unsupported."
+);
+var codexBlockedEvidence = blocked(
+  "codex-native-adapter-evidence.json blocked Codex hook surface",
+  "Hooks/trust flags and plugin hook directories exist, but exact safe generated hook config schema and trust prompts remain blocked pending a focused hook-schema/trust witness."
+);
+var codexUnsupportedEvidence = known(
+  "codex-native-adapter-evidence.json unsupported Codex command/template/agent/plan surfaces",
+  "Current Codex CLI help and prompt-input probes do not expose project-local custom slash commands, standalone prompt templates, user-facing custom agents/subagents, or a separate plan mode; workflow entrypoints must use project-local skills invoked by prompt syntax such as $vibe-task."
+);
+var piCapabilities = {
+  schemaVersion: HARNESS_ADAPTER_CONTRACT_SCHEMA_VERSION,
+  adapterId: "pi",
+  displayName: "Pi Coding Agent",
+  capabilities: {
+    contextFiles: capability(
+      "ready",
+      piEvidence,
+      "Pi project context uses AGENTS.md and optional CLAUDE.md.",
+      "Create/import may emit the existing Pi context files."
+    ),
+    nativeSkills: capability(
+      "ready",
+      piEvidence,
+      "Agent Skills-compatible .pi/skills/<skill>/SKILL.md resources expose the six skills.",
+      "Create/import may copy validated Pi skill templates through writePiHarnessAssets."
+    ),
+    nativeCommands: capability(
+      "ready",
+      piEvidence,
+      "Pi exposes generated skills as /skill:<skill> slash commands from .pi/skills resources.",
+      "Pi command affordances may be documented only for the generated Pi skill assets."
+    ),
+    promptTemplates: capability(
+      "ready",
+      piEvidence,
+      ".pi/prompts/*.md prompt templates are evidenced.",
+      "Create/import may copy validated Pi prompt templates through writePiHarnessAssets."
+    ),
+    hooks: capability(
+      "blocked",
+      piBlockedEvidence,
+      ".pi/extensions hooks are executable and intentionally not generated by create/import.",
+      "Hook/extension generation must block until a later security/runtime lane proves it."
+    ),
+    plugins: capability(
+      "blocked",
+      piBlockedEvidence,
+      "Pi package/extension distribution is executable and not generated by create/import.",
+      "Plugin/package generation must block until trust, install/update, and runtime loading are proven."
+    ),
+    mcp: capability(
+      "unsupported",
+      piBlockedEvidence,
+      "No Pi MCP generated-resource surface is evidenced for this contract.",
+      "MCP-dependent generation must block instead of inventing a Pi fallback."
+    ),
+    agents: capability(
+      "blocked",
+      piBlockedEvidence,
+      "Pi has no built-in agent/subagent surface in current evidence.",
+      "Agent-dependent generation must block instead of falling back to prompt-only behavior silently."
+    ),
+    planMode: capability(
+      "blocked",
+      piBlockedEvidence,
+      "Pi has no built-in plan mode in current evidence.",
+      "Plan-mode behavior must be prompt/extension-built only after separate proof."
+    ),
+    invocation: capability(
+      "ready",
+      piEvidence,
+      "Use pi --approve --no-session --mode json -p for future non-interactive witnesses.",
+      "Automation must parse JSON events and fail closed on missing final evidence."
+    ),
+    structuredOutput: capability(
+      "ready",
+      piEvidence,
+      "Pi has JSON event/RPC carriers but no CLI JSON Schema final-response flag.",
+      "Structured output requires adapter-side event parsing and schema validation."
+    ),
+    verificationRunner: capability(
+      "pending-live",
+      piEvidence,
+      "Recommended future runner is pi --approve --no-session --mode json -p <prompt>.",
+      "Missing binary/auth/unparseable output must produce a blocked missing-prerequisite result with dirty-tree delta evidence included.",
+      dirtyTreeRunnerEvidenceRefs
+    ),
+    securityTrustPolicy: capability(
+      "ready",
+      piEvidence,
+      "Project trust and default-deny command policy are modeled; no OS sandbox is claimed.",
+      "Generated metadata must expose trust boundaries and keep executable extension/plugin families blocked."
+    )
+  }
+};
+var claudeCapabilities = {
+  schemaVersion: HARNESS_ADAPTER_CONTRACT_SCHEMA_VERSION,
+  adapterId: "claude-code",
+  displayName: "Claude Code",
+  capabilities: {
+    contextFiles: capability(
+      "ready",
+      claudeEvidence,
+      "Claude Code natively auto-discovers project CLAUDE.md unless --bare/--safe-mode disables project customizations.",
+      "Create/import emits CLAUDE.md for Claude Code without Pi fallback."
+    ),
+    nativeSkills: capability(
+      "ready",
+      claudeEvidence,
+      "Claude Code supports project/user .claude/skills/<name>/SKILL.md skills, but the core workflow uses commands to avoid duplicate slash surfaces.",
+      "Create/import documents skills as optional and does not mirror the six workflow entrypoints as skills by default."
+    ),
+    nativeCommands: capability(
+      "ready",
+      claudeEvidence,
+      "Claude Code supports project .claude/commands/*.md Markdown/YAML-frontmatter custom slash commands.",
+      "Create/import emits .claude/commands/vibe-{brainstorm,grill-me,task,plan,build,ship}.md and exposes /vibe-* entrypoints."
+    ),
+    promptTemplates: capability(
+      "unsupported",
+      claudeBlockedEvidence,
+      "No separate project-local prompt-template loader distinct from commands/skills is evidenced.",
+      "Prompt-template generation must use .claude/commands/*.md or block; no .claude/prompts tree is invented."
+    ),
+    hooks: capability(
+      "ready",
+      claudeEvidence,
+      "Claude Code exposes hook settings/events, but hooks are executable and trust-sensitive.",
+      "Create/import does not generate executing hooks by default; future hooks must be explicit opt-in with trust/security docs."
+    ),
+    plugins: capability(
+      "ready",
+      claudeEvidence,
+      "Claude Code plugin surfaces are evidenced, including plugin init/validate and plugin-contained commands/agents/skills/hooks/MCP.",
+      "Core generated workflow avoids plugins by default and uses simple project commands for deterministic native UX."
+    ),
+    mcp: capability(
+      "ready",
+      claudeEvidence,
+      "Claude Code MCP management and project .mcp.json approval semantics are evidenced.",
+      "Create/import does not generate .mcp.json by default; future MCP config requires explicit user-approved integrations."
+    ),
+    agents: capability(
+      "ready",
+      claudeEvidence,
+      "Claude Code exposes .claude/agents plus --agent/--agents JSON for custom/current-session agents.",
+      "Verification runners may use explicit --agents JSON later; create/import does not emit unconsumed agents by default."
+    ),
+    planMode: capability(
+      "ready",
+      claudeEvidence,
+      "Claude Code permission mode includes plan.",
+      "Architecture verification runners use --permission-mode plan with read-only tools."
+    ),
+    invocation: capability(
+      "ready",
+      claudeEvidence,
+      "Use claude -p --output-format json --json-schema with explicit permissions for non-interactive runners.",
+      "Automation uses explicit flags and fails closed for missing binary/auth/trust/permission/invalid JSON issues."
+    ),
+    structuredOutput: capability(
+      "ready",
+      claudeEvidence,
+      "Claude Code print mode supports --output-format json and --json-schema for structured final output.",
+      "Runners rely on native schema validation and adapter-side validation of required fields."
+    ),
+    verificationRunner: capability(
+      "pending-live",
+      claudeEvidence,
+      "Recommended runner is claude -p --output-format json --json-schema <schema-json> --permission-mode plan with restricted read-only tools.",
+      "Missing binary/auth/trust/nonzero exit/permission denial/invalid JSON/schema mismatch blocks with no Pi fallback and dirty-tree delta evidence preserved.",
+      dirtyTreeRunnerEvidenceRefs
+    ),
+    securityTrustPolicy: capability(
+      "ready",
+      claudeEvidence,
+      "Claude Code project trust, --bare/--safe-mode behavior, permission modes, tool allow/deny flags, and operator auth requirements are modeled.",
+      "Generated docs require trusted workspace confirmation, prohibit dangerous skip-permissions by default, and state that --bare/--safe-mode disable generated native assets."
+    )
+  }
+};
+var codexCapabilities = {
+  schemaVersion: HARNESS_ADAPTER_CONTRACT_SCHEMA_VERSION,
+  adapterId: "codex",
+  displayName: "Codex CLI",
+  capabilities: {
+    contextFiles: capability(
+      "ready",
+      codexEvidence,
+      "codex debug prompt-input showed cwd AGENTS.md injected as model-visible instructions.",
+      "Create/import may emit AGENTS.md for Codex without Pi fallback."
+    ),
+    nativeSkills: capability(
+      "ready",
+      codexEvidence,
+      "Codex auto-discovers project-local .codex/skills/<skill-name>/SKILL.md resources with YAML name/description frontmatter.",
+      "Create/import emits .codex/skills/vibe-{brainstorm,grill-me,task,plan,build,ship}/SKILL.md and uses prompt syntax such as `Use $vibe-task ...` instead of Pi fallback."
+    ),
+    nativeCommands: capability(
+      "unsupported",
+      codexUnsupportedEvidence,
+      "No Codex custom slash-command or native command file format is evidenced; .codex/commands sentinels were not discovered.",
+      "Command asset generation must block instead of guessing or falling back to Pi prompts."
+    ),
+    promptTemplates: capability(
+      "unsupported",
+      codexUnsupportedEvidence,
+      "No standalone Codex project-local prompt-template path is evidenced; .codex/prompts sentinels were not discovered.",
+      "Prompt-template generation must block instead of guessing; generated workflow entrypoints live in SKILL.md files and docs."
+    ),
+    hooks: capability(
+      "blocked",
+      codexBlockedEvidence,
+      "Hook trust flags and plugin hook directories exist, but safe generated hook config schema/trust behavior is not fully witnessed.",
+      "Hook generation must block pending a focused hook-schema/trust witness."
+    ),
+    plugins: capability(
+      "ready",
+      codexEvidence,
+      "Codex plugin CLI and marketplace surfaces are evidenced, but plugins require explicit install/trust and are optional for the core workflow.",
+      "Create/import does not generate plugins by default; future plugin use must be explicit opt-in and fail closed if absent."
+    ),
+    mcp: capability(
+      "ready",
+      codexEvidence,
+      "Codex MCP commands/config and plugin MCP surfaces are evidenced, but MCP servers are optional integrations.",
+      "Create/import does not generate MCP by default; future MCP-dependent runners must fail closed when servers are absent."
+    ),
+    agents: capability(
+      "unsupported",
+      codexUnsupportedEvidence,
+      "No explicit Codex custom-agent/subagent CLI or project-local agent config is evidenced.",
+      "Agent-dependent behavior must block."
+    ),
+    planMode: capability(
+      "unsupported",
+      codexUnsupportedEvidence,
+      "Planning is prompt/skill protocol-level; no separate Codex plan mode flag or command is evidenced.",
+      "Plan-mode-dependent behavior must block or use the generated $vibe-plan skill protocol."
+    ),
+    invocation: capability(
+      "ready",
+      codexEvidence,
+      "Use codex exec --json --output-schema --output-last-message with sandbox/approval flags.",
+      "Automation must fail closed for missing auth/runtime/git prerequisites or unparseable output."
+    ),
+    structuredOutput: capability(
+      "ready",
+      codexEvidence,
+      "codex exec supports --output-schema and --output-last-message.",
+      "Future runners should use native output schema plus adapter-side validation."
+    ),
+    verificationRunner: capability(
+      "pending-live",
+      codexEvidence,
+      'Recommended future runner is codex exec -c approval_policy="never" --sandbox read-only --json --output-schema <file>.',
+      "Missing binary/auth/git/unparseable output must block with no Pi fallback and dirty-tree delta evidence preserved.",
+      dirtyTreeRunnerEvidenceRefs
+    ),
+    securityTrustPolicy: capability(
+      "ready",
+      codexEvidence,
+      "Sandbox, approval policy, hook trust, and operator auth requirements are modeled.",
+      "Generated metadata must expose trust boundaries while keeping skills/plugins/hooks/MCP assets blocked."
+    )
+  }
+};
+var commonConfigFamily = (adapterId) => family(
+  "harness-config",
+  [`generated harness config field: agenticHarness=${adapterId}`],
+  "ready",
+  "I-15A-create-import-cli-ux-selected-harness",
+  "writeGeneratedArtifacts",
+  "Create/import records the selected adapter id in vibe-engineer.config.json.",
+  adapterId === "pi" ? piEvidence : adapterId === "claude-code" ? claudeEvidence : codexEvidence
+);
+var commonSelectedHarnessFamilies = (adapterId) => {
+  const evidence = adapterId === "pi" ? piEvidence : adapterId === "claude-code" ? claudeEvidence : codexEvidence;
+  return [
+    family(
+      "selected-harness-metadata",
+      [".vibe/harness/selected-harness.json"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "Create/import emits machine-readable selected harness metadata, native/blocked asset assertions, and runtime prerequisite diagnostics.",
+      evidence
+    ),
+    family(
+      "selected-harness-guidance",
+      [".vibe/harness/README.md", ".vibe/harness/handoff.md"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "Create/import emits human-readable security, trust, unsupported-surface, and task/plan/build/ship handoff guidance for the selected harness.",
+      evidence
+    ),
+    family(
+      "runner-catalog-harness-metadata",
+      [".vibe/registry/runner-catalog.json#vibeEngineerHarness"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "Generated starter runner catalog entries carry selected-harness contract states, live invocation placeholders, dirty-tree runner expectations, and no-Pi-fallback assertions.",
+      evidence
+    ),
+    family(
+      "starter-preset-harness-metadata",
+      [".vibe/generated/nest-react-rn-preset/manifest.json#layout.agenticHarness"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "Generated starter preset metadata is rewritten to the selected harness instead of retaining the pi template default.",
+      evidence
+    )
+  ];
+};
+var piGeneratedManifest = {
+  schemaVersion: HARNESS_GENERATED_FILE_MANIFEST_SCHEMA_VERSION,
+  adapterId: "pi",
+  adapterCapabilityVersion: HARNESS_ADAPTER_CONTRACT_SCHEMA_VERSION,
+  noFallbackToPi: true,
+  families: [
+    commonConfigFamily("pi"),
+    family(
+      "context-files",
+      ["AGENTS.md", "CLAUDE.md"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "Existing Pi behavior emits both context files.",
+      piEvidence
+    ),
+    family(
+      "pi-skill-files",
+      [".pi/skills/<skill>/SKILL.md"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writePiHarnessAssets",
+      "Existing Pi behavior emits six validated skill files.",
+      piEvidence
+    ),
+    family(
+      "pi-prompt-templates",
+      [".pi/prompts/vibe-<skill>.md"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writePiHarnessAssets",
+      "Existing Pi behavior emits six validated prompt templates.",
+      piEvidence
+    ),
+    ...commonSelectedHarnessFamilies("pi"),
+    family(
+      "pi-extensions",
+      [".pi/extensions/<name>.ts"],
+      "blocked",
+      "future-adapter-lane",
+      "none",
+      "Executable Pi extensions are blocked until runtime/security proof exists.",
+      piBlockedEvidence
+    ),
+    family(
+      "pi-package-manifest",
+      ["package.json#pi"],
+      "blocked",
+      "future-adapter-lane",
+      "none",
+      "Pi package manifest generation is blocked for create/import.",
+      piBlockedEvidence
+    )
+  ]
+};
+var claudeGeneratedManifest = {
+  schemaVersion: HARNESS_GENERATED_FILE_MANIFEST_SCHEMA_VERSION,
+  adapterId: "claude-code",
+  adapterCapabilityVersion: HARNESS_ADAPTER_CONTRACT_SCHEMA_VERSION,
+  noFallbackToPi: true,
+  families: [
+    commonConfigFamily("claude-code"),
+    family(
+      "claude-context-file",
+      ["CLAUDE.md"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "CLAUDE.md auto-discovery is evidenced by Claude Code help and is the native project context file.",
+      claudeEvidence
+    ),
+    family(
+      "claude-custom-commands",
+      [
+        ".claude/commands/vibe-brainstorm.md",
+        ".claude/commands/vibe-grill-me.md",
+        ".claude/commands/vibe-task.md",
+        ".claude/commands/vibe-plan.md",
+        ".claude/commands/vibe-build.md",
+        ".claude/commands/vibe-ship.md"
+      ],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "Claude Code project custom commands are evidenced and generated for the six vibe workflow entrypoints.",
+      claudeEvidence
+    ),
+    ...commonSelectedHarnessFamilies("claude-code"),
+    family(
+      "claude-project-skills",
+      [".claude/skills/<name>/SKILL.md"],
+      "ready",
+      "future-adapter-lane",
+      "none",
+      "Project skills are evidenced but the core workflow avoids duplicate slash surfaces and does not generate skills by default.",
+      claudeEvidence
+    ),
+    family(
+      "claude-hooks",
+      [".claude/settings.json", ".claude/settings.local.json"],
+      "ready",
+      "future-adapter-lane",
+      "none",
+      "Hook settings/events are evidenced but executing hooks are not generated by default for trust/security reasons.",
+      claudeEvidence
+    ),
+    family(
+      "claude-plugins",
+      ["plugin.json", "commands/", "agents/", "skills/", "hooks/", "mcp"],
+      "ready",
+      "future-adapter-lane",
+      "none",
+      "Plugins are evidenced but optional/advanced; core create/import does not require plugin packaging.",
+      claudeEvidence
+    ),
+    family(
+      "claude-mcp-config",
+      [".mcp.json"],
+      "ready",
+      "future-adapter-lane",
+      "none",
+      "Project MCP config is evidenced but requires explicit approval and is not generated by default.",
+      claudeEvidence
+    ),
+    family(
+      "claude-explicit-agents-json",
+      ["future runner-owned --agents JSON", ".claude/agents/*.md"],
+      "ready",
+      "future-adapter-lane",
+      "future-runner",
+      "Agents are evidenced; generated runners may consume explicit --agents JSON when needed, while create/import emits no unconsumed agent assets.",
+      claudeEvidence
+    ),
+    family(
+      "claude-standalone-prompt-templates",
+      ["unsupported .claude/prompts tree"],
+      "unsupported",
+      "future-adapter-lane",
+      "none",
+      "No standalone project prompt-template loader distinct from commands/skills is evidenced.",
+      claudeBlockedEvidence
+    )
+  ]
+};
+var codexGeneratedManifest = {
+  schemaVersion: HARNESS_GENERATED_FILE_MANIFEST_SCHEMA_VERSION,
+  adapterId: "codex",
+  adapterCapabilityVersion: HARNESS_ADAPTER_CONTRACT_SCHEMA_VERSION,
+  noFallbackToPi: true,
+  families: [
+    commonConfigFamily("codex"),
+    family(
+      "codex-context-file",
+      ["AGENTS.md"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "AGENTS.md injection is evidenced by codex debug prompt-input.",
+      codexEvidence
+    ),
+    ...commonSelectedHarnessFamilies("codex"),
+    family(
+      "codex-project-skills",
+      [
+        ".codex/skills/vibe-brainstorm/SKILL.md",
+        ".codex/skills/vibe-grill-me/SKILL.md",
+        ".codex/skills/vibe-task/SKILL.md",
+        ".codex/skills/vibe-plan/SKILL.md",
+        ".codex/skills/vibe-build/SKILL.md",
+        ".codex/skills/vibe-ship/SKILL.md"
+      ],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "Codex project-local skills are evidenced and generated for the six vibe workflow entrypoints.",
+      codexEvidence
+    ),
+    family(
+      "codex-project-config",
+      [".codex/config.toml"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "Generate conservative documented defaults while runners still pass explicit sandbox and approval flags because project config is trust-gated.",
+      codexEvidence
+    ),
+    family(
+      "codex-native-commands",
+      ["unsupported .codex/commands tree"],
+      "unsupported",
+      "future-adapter-lane",
+      "none",
+      "No Codex native command file format is evidenced; command generation is unsupported.",
+      codexUnsupportedEvidence
+    ),
+    family(
+      "codex-standalone-prompt-templates",
+      ["unsupported .codex/prompts tree"],
+      "unsupported",
+      "future-adapter-lane",
+      "none",
+      "No standalone Codex prompt-template loader is evidenced; generated workflow prompts live in skills and docs.",
+      codexUnsupportedEvidence
+    ),
+    family(
+      "codex-hooks",
+      ["blocked Codex hook generated files"],
+      "blocked",
+      "future-adapter-lane",
+      "none",
+      "Codex hook generation is blocked pending a focused hook schema/trust witness.",
+      codexBlockedEvidence
+    ),
+    family(
+      "codex-plugins",
+      [".codex-plugin/plugin.json", "marketplace.json", "plugin skills/MCP/apps"],
+      "ready",
+      "future-adapter-lane",
+      "none",
+      "Plugins are evidenced but optional/explicit-install; create/import does not generate or auto-install plugins by default.",
+      codexEvidence
+    ),
+    family(
+      "codex-mcp-config",
+      ["~/.codex/config.toml#mcp_servers", "plugin MCP via .mcp.json/plugin.json"],
+      "ready",
+      "future-adapter-lane",
+      "none",
+      "MCP is evidenced but optional; create/import does not generate MCP servers by default.",
+      codexEvidence
+    ),
+    family(
+      "codex-output-schema",
+      [".vibe/schemas/architecture-agent-review.schema.json"],
+      "ready",
+      "I-15A-create-import-cli-ux-selected-harness",
+      "writeGeneratedArtifacts",
+      "codex exec --output-schema is evidenced and the generated architecture runner passes the schema file explicitly.",
+      codexEvidence
+    )
+  ]
+};
+var rendererExtensionPoint = (rendererId, adapterId, support, outputKind, generatedAssetFamilies, blockedAssetFamilies, summary, implementationBoundary, evidence, evidenceRefs = evidenceRefsForEvidence(evidence)) => ({
+  rendererId,
+  adapterId,
+  support,
+  outputKind,
+  generatedAssetFamilies,
+  blockedAssetFamilies,
+  summary,
+  implementationBoundary,
+  noFallbackToPi: true,
+  evidence,
+  evidenceRefs
+});
+var piRendererExtensionPoint = rendererExtensionPoint(
+  "renderPiSkill",
+  "pi",
+  "ready",
+  "pi-skill",
+  ["pi-skill-files", "pi-prompt-templates"],
+  ["pi-extensions", "pi-package-manifest", "agents", "plan-mode"],
+  "Renderer extension point for existing validated Pi skill/prompt template assets.",
+  "The renderer boundary delegates to the existing Pi template/writePiHarnessAssets path; it does not broaden executable extension support.",
+  piEvidence
+);
+var claudeRendererExtensionPoint = rendererExtensionPoint(
+  "renderClaudeCodeSkillOrCommand",
+  "claude-code",
+  "ready",
+  "claude-code-skill-or-command",
+  ["claude-custom-commands"],
+  [
+    "claude-project-skills",
+    "claude-hooks",
+    "claude-plugins",
+    "claude-mcp-config",
+    "claude-standalone-prompt-templates"
+  ],
+  "Renderer extension point for Claude Code native custom command assets.",
+  "The renderer emits CLAUDE.md plus .claude/commands/vibe-* Markdown/YAML command files; skills/hooks/plugins/MCP remain documented opt-in surfaces and do not fall back to Pi.",
+  claudeEvidence
+);
+var codexRendererExtensionPoint = rendererExtensionPoint(
+  "renderCodexSkillOrCommand",
+  "codex",
+  "ready",
+  "codex-skill-or-command",
+  ["codex-project-skills", "codex-project-config", "codex-output-schema"],
+  [
+    "codex-native-commands",
+    "codex-standalone-prompt-templates",
+    "codex-hooks",
+    "codex-plugins",
+    "codex-mcp-config",
+    "agents",
+    "plan-mode"
+  ],
+  "Renderer extension point for Codex native project-local skill assets.",
+  "The renderer emits AGENTS.md, .codex/skills/vibe-* SKILL.md files, and conservative .codex/config.toml; native slash commands, prompt templates, hooks, plugins, MCP, agents, and plan mode do not fall back to Pi.",
+  codexEvidence
+);
+var HARNESS_RENDERER_EXTENSION_POINTS = [
+  piRendererExtensionPoint,
+  claudeRendererExtensionPoint,
+  codexRendererExtensionPoint
+];
+var renderPiSkill = () => piRendererExtensionPoint;
+var renderClaudeCodeSkillOrCommand = () => claudeRendererExtensionPoint;
+var renderCodexSkillOrCommand = () => codexRendererExtensionPoint;
+var piAdapter = {
+  id: "pi",
+  displayName: "Pi Coding Agent",
+  capabilityMatrix: piCapabilities,
+  generatedFileManifest: piGeneratedManifest,
+  assetWriter: {
+    strategy: "pi-native-assets-and-context",
+    contextFiles: ["AGENTS.md", "CLAUDE.md"],
+    nativeAssetFamilies: ["pi-skill-files", "pi-prompt-templates"],
+    blockedAssetFamilies: ["pi-extensions", "pi-package-manifest", "agents", "plan-mode"],
+    unsupportedFeaturePolicy: "block",
+    noFallbackToPi: true
+  },
+  invocationModel: {
+    support: "ready",
+    binary: "pi",
+    nonInteractiveCommand: ["pi", "--approve", "--no-session", "--mode", "json", "-p", "<prompt>"],
+    interactiveCommand: ["pi"],
+    projectRootFlag: null,
+    requiresGitRepository: false,
+    missingRuntimeDiagnostic: "Pi CLI/auth/runtime unavailable for selected harness.",
+    evidence: piEvidence,
+    evidenceRefs: piEvidenceRefs
+  },
+  structuredOutput: {
+    support: "ready",
+    strategy: "json-event-parse-and-adapter-validation",
+    schemaFlag: null,
+    finalMessageCarrier: "JSON event stream parsed by adapter-side validator",
+    failClosedWhenMissing: true,
+    evidence: piEvidence,
+    evidenceRefs: piEvidenceRefs
+  },
+  verificationRunnerInvocation: {
+    support: "pending-live",
+    recommendedCommand: ["pi", "--approve", "--no-session", "--mode", "json", "-p", "<prompt>"],
+    defaultPermissionMode: "project trust required; default-deny tools unless explicitly allowed",
+    expectedStructuredOutput: "json-event-parse-and-adapter-validation",
+    unavailableRuntimeBehavior: "blocked-missing-prerequisite",
+    evidence: piEvidence,
+    evidenceRefs: dirtyTreeRunnerEvidenceRefs
+  },
+  securityTrustPolicy: {
+    support: "ready",
+    projectTrustRequired: true,
+    projectContextAutoload: ["AGENTS.md", "CLAUDE.md"],
+    sandbox: "not provided by Pi; use OS/container sandbox for unattended runs",
+    permissionModel: "--approve/--no-approve project trust plus adapter default-deny command policy",
+    credentials: "operator-auth-required",
+    destructiveOperations: "forbidden",
+    externalIntegrations: "disabled-by-default",
+    trustBoundary: "Project-local .pi resources and TypeScript extensions require project trust; create/import emits only non-executable skills/prompts/context.",
+    evidence: piEvidence,
+    evidenceRefs: piEvidenceRefs
+  },
+  rendererExtensionPoints: [piRendererExtensionPoint],
+  unsupportedFeatureBehavior: {
+    policy: "block",
+    diagnosticCode: "UNSUPPORTED_HARNESS_FEATURE",
+    message: "Unsupported Pi adapter features block instead of silently no-oping.",
+    blockedFamilies: ["pi-extensions", "pi-package-manifest", "agents", "plan-mode"]
+  },
+  handoffInstructions: handoffInstructionsFor("pi"),
+  runtimePrerequisiteDiagnostic: runtimePrerequisiteDiagnostic(
+    "pi",
+    "Pi Coding Agent",
+    "Pi CLI/auth/runtime unavailable for selected harness."
+  ),
+  witnessPlan: {
+    configWitnesses: ["config accepts agenticHarness=pi"],
+    createWitnesses: ["create pi preserves existing .pi skills/prompts and AGENTS.md/CLAUDE.md"],
+    importWitnesses: ["import pi preserves existing behavior and idempotent Pi assets"],
+    negativeWitnesses: ["unsupported feature families are listed as blocked"],
+    liveRuntimeWitness: "pending-live"
+  },
+  createImportSelectable: true
+};
+var claudeAdapter = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  capabilityMatrix: claudeCapabilities,
+  generatedFileManifest: claudeGeneratedManifest,
+  assetWriter: {
+    strategy: "claude-native-assets-and-context",
+    contextFiles: ["CLAUDE.md"],
+    nativeAssetFamilies: ["claude-custom-commands"],
+    blockedAssetFamilies: [
+      "claude-project-skills",
+      "claude-hooks",
+      "claude-plugins",
+      "claude-mcp-config",
+      "claude-explicit-agents-json",
+      "claude-standalone-prompt-templates"
+    ],
+    unsupportedFeaturePolicy: "block",
+    noFallbackToPi: true
+  },
+  invocationModel: {
+    support: "ready",
+    binary: "claude",
+    nonInteractiveCommand: [
+      "claude",
+      "-p",
+      "--output-format",
+      "json",
+      "--json-schema",
+      "<schema-json>",
+      "--permission-mode",
+      "plan",
+      "--allowedTools",
+      "Read,Grep,Glob,Bash(git diff:*),Bash(git status:*),Bash(git ls-files:*)",
+      "--disallowedTools",
+      "Edit,Write",
+      "--no-session-persistence",
+      "<prompt>"
+    ],
+    interactiveCommand: ["claude"],
+    projectRootFlag: "--add-dir",
+    requiresGitRepository: false,
+    missingRuntimeDiagnostic: "Claude Code CLI/auth/runtime/trust unavailable for selected harness.",
+    evidence: claudeEvidence,
+    evidenceRefs: claudeEvidenceRefs
+  },
+  structuredOutput: {
+    support: "ready",
+    strategy: "native-json-schema",
+    schemaFlag: "--json-schema",
+    finalMessageCarrier: "Claude Code print-mode JSON output validated by --json-schema plus adapter-side checks",
+    failClosedWhenMissing: true,
+    evidence: claudeEvidence,
+    evidenceRefs: claudeEvidenceRefs
+  },
+  verificationRunnerInvocation: {
+    support: "pending-live",
+    recommendedCommand: [
+      "claude",
+      "-p",
+      "--output-format",
+      "json",
+      "--json-schema",
+      "<schema-json>",
+      "--permission-mode",
+      "plan",
+      "--allowedTools",
+      "Read,Grep,Glob,Bash(git diff:*),Bash(git status:*),Bash(git ls-files:*)",
+      "--disallowedTools",
+      "Edit,Write",
+      "--no-session-persistence",
+      "<prompt>"
+    ],
+    defaultPermissionMode: "plan with Read/Grep/Glob and read-only git Bash allowlist; Edit/Write denied",
+    expectedStructuredOutput: "native-json-schema",
+    unavailableRuntimeBehavior: "blocked-missing-prerequisite",
+    evidence: claudeEvidence,
+    evidenceRefs: dirtyTreeRunnerEvidenceRefs
+  },
+  securityTrustPolicy: {
+    support: "ready",
+    projectTrustRequired: true,
+    projectContextAutoload: ["CLAUDE.md"],
+    sandbox: "permission modes and allowed/disallowed tools; no OS sandbox claim",
+    permissionModel: "--permission-mode default|acceptEdits|auto|dontAsk|plan|bypassPermissions with explicit --allowedTools/--disallowedTools; dangerous skip-permissions is not generated",
+    credentials: "operator-auth-required",
+    destructiveOperations: "approval-required",
+    externalIntegrations: "disabled-by-default",
+    trustBoundary: "Create/import emits CLAUDE.md and non-executing .claude/commands/vibe-* prompt assets. Hooks, plugins, MCP, and agents remain opt-in/trust-sensitive and --bare/--safe-mode disable generated native assets.",
+    evidence: claudeEvidence,
+    evidenceRefs: claudeEvidenceRefs
+  },
+  rendererExtensionPoints: [claudeRendererExtensionPoint],
+  unsupportedFeatureBehavior: {
+    policy: "block",
+    diagnosticCode: "UNSUPPORTED_HARNESS_FEATURE",
+    message: "Unsupported Claude Code standalone prompt-template assets block instead of silently falling back to Pi assets.",
+    blockedFamilies: ["claude-standalone-prompt-templates"]
+  },
+  handoffInstructions: handoffInstructionsFor("claude-code"),
+  runtimePrerequisiteDiagnostic: runtimePrerequisiteDiagnostic(
+    "claude",
+    "Claude Code",
+    "Claude Code CLI/auth/trust/runtime unavailable for selected harness."
+  ),
+  witnessPlan: {
+    configWitnesses: ["config accepts agenticHarness=claude-code"],
+    createWitnesses: [
+      "create claude-code writes CLAUDE.md, .claude/commands/vibe-* and no .pi assets"
+    ],
+    importWitnesses: [
+      "import claude-code writes CLAUDE.md, .claude/commands/vibe-* and no .pi assets"
+    ],
+    negativeWitnesses: [
+      "Claude standalone prompt templates are unsupported and no Pi fallback assets are generated"
+    ],
+    liveRuntimeWitness: "pending-live"
+  },
+  createImportSelectable: true
+};
+var codexAdapter = {
+  id: "codex",
+  displayName: "Codex CLI",
+  capabilityMatrix: codexCapabilities,
+  generatedFileManifest: codexGeneratedManifest,
+  assetWriter: {
+    strategy: "codex-native-assets-and-context",
+    contextFiles: ["AGENTS.md"],
+    nativeAssetFamilies: ["codex-project-skills", "codex-project-config"],
+    blockedAssetFamilies: [
+      "codex-native-commands",
+      "codex-standalone-prompt-templates",
+      "codex-hooks",
+      "codex-plugins",
+      "codex-mcp-config",
+      "agents",
+      "plan-mode"
+    ],
+    unsupportedFeaturePolicy: "block",
+    noFallbackToPi: true
+  },
+  invocationModel: {
+    support: "ready",
+    binary: "codex",
+    nonInteractiveCommand: [
+      "codex",
+      "exec",
+      "-c",
+      'approval_policy="never"',
+      "--cd",
+      ".",
+      "--sandbox",
+      "read-only",
+      "--json",
+      "--output-schema",
+      "<schema-file>",
+      "--output-last-message",
+      "<last-message-file>",
+      "<prompt>"
+    ],
+    interactiveCommand: ["codex"],
+    projectRootFlag: "--cd",
+    requiresGitRepository: false,
+    missingRuntimeDiagnostic: "Codex CLI/auth/runtime unavailable for selected harness.",
+    evidence: codexEvidence,
+    evidenceRefs: codexEvidenceRefs
+  },
+  structuredOutput: {
+    support: "ready",
+    strategy: "native-output-schema",
+    schemaFlag: "--output-schema",
+    finalMessageCarrier: "--output-last-message file plus JSONL events",
+    failClosedWhenMissing: true,
+    evidence: codexEvidence,
+    evidenceRefs: codexEvidenceRefs
+  },
+  verificationRunnerInvocation: {
+    support: "pending-live",
+    recommendedCommand: [
+      "codex",
+      "exec",
+      "-c",
+      'approval_policy="never"',
+      "--cd",
+      ".",
+      "--sandbox",
+      "read-only",
+      "--json",
+      "--output-schema",
+      "<schema-file>",
+      "--output-last-message",
+      "<last-message-file>",
+      "<prompt>"
+    ],
+    defaultPermissionMode: "read-only sandbox with approval_policy=never config override",
+    expectedStructuredOutput: "native-output-schema",
+    unavailableRuntimeBehavior: "blocked-missing-prerequisite",
+    evidence: codexEvidence,
+    evidenceRefs: dirtyTreeRunnerEvidenceRefs
+  },
+  securityTrustPolicy: {
+    support: "ready",
+    projectTrustRequired: true,
+    projectContextAutoload: ["AGENTS.md"],
+    sandbox: "--sandbox read-only|workspace-write|danger-full-access",
+    permissionModel: "approval_policy config override plus --sandbox read-only|workspace-write|danger-full-access selection",
+    credentials: "operator-auth-required",
+    destructiveOperations: "approval-required",
+    externalIntegrations: "disabled-by-default",
+    trustBoundary: "Create/import emits AGENTS.md, non-executable .codex/skills/vibe-* SKILL.md resources, and conservative .codex/config.toml. Runners still pass explicit read-only sandbox and approval_policy=never flags; commands, hooks, plugins, MCP, agents, and plan mode remain unsupported/blocked/optional with no Pi fallback.",
+    evidence: codexEvidence,
+    evidenceRefs: codexEvidenceRefs
+  },
+  rendererExtensionPoints: [codexRendererExtensionPoint],
+  unsupportedFeatureBehavior: {
+    policy: "block",
+    diagnosticCode: "UNSUPPORTED_HARNESS_FEATURE",
+    message: "Unsupported, blocked, or optional-not-generated Codex asset families do not silently fall back to Pi assets.",
+    blockedFamilies: [
+      "codex-native-commands",
+      "codex-standalone-prompt-templates",
+      "codex-hooks",
+      "codex-plugins",
+      "codex-mcp-config",
+      "agents",
+      "plan-mode"
+    ]
+  },
+  handoffInstructions: handoffInstructionsFor("codex"),
+  runtimePrerequisiteDiagnostic: runtimePrerequisiteDiagnostic(
+    "codex",
+    "Codex CLI",
+    "Codex CLI/auth/runtime unavailable for selected harness."
+  ),
+  witnessPlan: {
+    configWitnesses: ["config accepts agenticHarness=codex"],
+    createWitnesses: [
+      "create codex writes AGENTS.md, .codex/skills/vibe-*/SKILL.md, .codex/config.toml, runner schema metadata, and no .pi assets"
+    ],
+    importWitnesses: [
+      "import codex writes AGENTS.md, .codex/skills/vibe-*/SKILL.md, .codex/config.toml, and no .pi assets"
+    ],
+    negativeWitnesses: [
+      "Codex native slash commands, standalone prompt templates, hooks, agents, plan mode, plugins, and MCP are unsupported/blocked/optional with no Pi fallback assets generated"
+    ],
+    liveRuntimeWitness: "pending-live"
+  },
+  createImportSelectable: true
+};
+var HARNESS_ADAPTERS = [piAdapter, claudeAdapter, codexAdapter];
+var HARNESS_ADAPTER_REGISTRY = {
+  schemaVersion: HARNESS_ADAPTER_REGISTRY_SCHEMA_VERSION,
+  supportedAdapterIds: SUPPORTED_HARNESS_ADAPTER_IDS,
+  adapters: HARNESS_ADAPTERS,
+  rendererExtensionPoints: HARNESS_RENDERER_EXTENSION_POINTS
+};
+var isSupportedHarnessAdapterId = (value) => SUPPORTED_HARNESS_ADAPTER_IDS.includes(value);
+var getHarnessAdapter = (adapterId) => HARNESS_ADAPTERS.find((adapter) => adapter.id === adapterId);
+var listHarnessAdapters = () => [...HARNESS_ADAPTERS];
+var getHarnessAdapterRegistry = () => HARNESS_ADAPTER_REGISTRY;
+
+// src/capabilities/index.ts
+var PI_ADAPTER_ID = "pi";
+var PI_ADAPTER_CAPABILITY_SCHEMA_VERSION = "pi-adapter-capability-matrix/v1";
+var VIBE_ENGINEER_SKILLS = [...SKILL_IDS];
+var known2 = (source, notes) => ({
+  state: "known",
+  source,
+  notes
+});
+var unknown = (source, notes) => ({
+  state: "unknown",
+  source,
+  notes
+});
+var deferred = (source, notes) => ({
+  state: "deferred",
+  source,
+  notes
+});
+var surface = (evidence, support, details, downstreamConsequence) => ({
+  evidence,
+  support,
+  details,
+  downstreamConsequence
+});
+var piSkill = (skillId) => ({
+  skillId,
+  nativeCommand: `/skill:${skillId}`,
+  resourceFamily: "pi-skill-files",
+  evidence: known2(
+    "DL-03 skill protocols + DL-06 pi skills decision",
+    "The six locked skills are generated as Agent Skills-compatible SKILL.md resources."
+  ),
+  readiness: "ready",
+  protocolSource: "DL-03-skill-protocols.md"
+});
+var nonPiAdapter = (adapterId, displayName, evidence) => ({
+  adapterId,
+  displayName,
+  evidenceStatus: evidence,
+  versionCompatibility: {
+    harnessName: displayName,
+    harnessVersionRange: "unknown",
+    resourceFormatVersion: "unknown",
+    runtimeRequirements: ["future evidence-backed decision required"],
+    compatibilityEvidence: evidence
+  },
+  skillsCommandsSurface: {
+    ...surface(
+      evidence,
+      evidence.state === "deferred" ? "deferred" : "unknown",
+      "No v1 native generated-resource contract is authorized for this harness.",
+      "Any dependent selection or generation for this harness must block until a future adapter decision supplies evidence."
+    ),
+    nativeFormat: "unknown",
+    autoloadDiscovery: ["unknown"],
+    skills: []
+  },
+  promptTemplateSurface: surface(
+    evidence,
+    evidence.state === "deferred" ? "deferred" : "unknown",
+    "Prompt template semantics are not evidenced for v1.",
+    "Prompt generation must block for this harness."
+  ),
+  hookEventSupport: surface(
+    evidence,
+    evidence.state === "deferred" ? "deferred" : "unknown",
+    "Hook/event semantics are not evidenced for v1.",
+    "Hook, tool, event, UI, plan-mode, or subagent generation must block."
+  ),
+  subagentCapability: {
+    ...surface(
+      evidence,
+      evidence.state === "deferred" ? "deferred" : "unknown",
+      "Subagent capability is not evidenced for v1.",
+      "Subagent-dependent behavior must block."
+    ),
+    implementationKind: "unsupported",
+    requiresGeneratedExtension: false
+  },
+  planModeCapability: {
+    ...surface(
+      evidence,
+      evidence.state === "deferred" ? "deferred" : "unknown",
+      "Plan-mode capability is not evidenced for v1.",
+      "Plan-mode-dependent behavior must block."
+    ),
+    implementationKind: "unsupported",
+    requiresGeneratedExtension: false
+  },
+  contextFileConventions: surface(
+    evidence,
+    evidence.state === "deferred" ? "deferred" : "unknown",
+    "Context-file conventions are not evidenced for v1.",
+    "Context file generation must block for this harness."
+  ),
+  commandInvocationModel: {
+    interactive: surface(
+      evidence,
+      "unknown",
+      "Unknown invocation model.",
+      "Invocation must block."
+    ),
+    printMode: surface(
+      evidence,
+      "unknown",
+      "Unknown print/non-interactive model.",
+      "Invocation must block."
+    ),
+    jsonMode: surface(
+      evidence,
+      "unknown",
+      "Unknown machine-readable event model.",
+      "Automation must block."
+    ),
+    rpcMode: surface(evidence, "unknown", "Unknown RPC model.", "Automation must block."),
+    sdk: surface(evidence, "unknown", "Unknown SDK model.", "Automation must block."),
+    shellCommandPolicy: "blocked"
+  },
+  generatedFiles: {
+    evidence,
+    manifestSchemaVersion: "pi-generated-file-manifest/v1",
+    families: [],
+    downstreamConsequence: "No non-pi generated files may be emitted by v1 lanes."
+  },
+  packageDistribution: {
+    ...surface(
+      evidence,
+      evidence.state === "deferred" ? "deferred" : "unknown",
+      "Package distribution semantics are not evidenced for v1.",
+      "Package generation or install claims must block."
+    ),
+    distributionKinds: [],
+    trustUpdatePolicy: "blocked until future adapter evidence exists"
+  },
+  securityTrust: {
+    evidence,
+    projectTrustRequired: false,
+    extensionExecution: "none",
+    commandPolicy: "default-deny",
+    sandboxCapability: "unknown",
+    credentialPolicy: "unknown-blocked",
+    destructiveOperations: "forbidden",
+    externalIntegration: "unknown-blocked",
+    trustBoundary: "No v1 trust boundary is declared; non-pi rows are non-selectable."
+  },
+  capabilityFlags: {
+    skills: false,
+    prompts: false,
+    hooks: false,
+    extensions: false,
+    subagents: false,
+    planMode: false,
+    contextFiles: false,
+    rpc: false,
+    sdk: false,
+    jsonMode: false,
+    packages: false,
+    ui: false,
+    unsupportedFeaturePolicy: "block"
+  },
+  realBoundaryWitness: {
+    evidence,
+    boundaryStatus: evidence.state === "deferred" ? "deferred" : "unknown",
+    producer: "future adapter lane",
+    carrier: "future generated-resource manifest",
+    consumer: "future harness runtime/API consumer",
+    evidencePath: "future evidence-backed decision required",
+    runtimeExecutionClaim: "not-claimed"
+  },
+  selection: {
+    manifestSelectable: false,
+    createImportSelectable: false,
+    readiness: evidence.state === "blocked" ? "blocked" : evidence.state === "deferred" ? "deferred" : "unknown",
+    reason: "Non-pi harnesses are explicit future/deferred/unknown rows and are never ready or selectable in v1."
+  }
+});
+var piAdapter2 = {
+  adapterId: PI_ADAPTER_ID,
+  displayName: "Pi Coding Agent",
+  evidenceStatus: known2(
+    "DL-06-agentic-harness-integrations.md",
+    "Pi is the only v1 live adapter target; this row declares the typed manifest contract and does not claim live runtime execution."
+  ),
+  versionCompatibility: {
+    harnessName: "pi",
+    harnessVersionRange: "unknown until I-14B/live runtime records installed pi version",
+    resourceFormatVersion: "Agent Skills standard plus pi-specific prompt/template/extension/package resource formats",
+    runtimeRequirements: [
+      "Node/TypeScript extension runtime",
+      "project trust for project-local .pi resources",
+      "DL-22 default-deny command policy"
+    ],
+    compatibilityEvidence: known2(
+      "DL-06 pi mechanisms and explicit limitations",
+      "Design evidence is known; live runtime compatibility remains I-14B pending-live."
+    )
+  },
+  skillsCommandsSurface: {
+    ...surface(
+      known2("DL-03 + DL-06", "All six locked skills map to pi Agent Skills slash commands."),
+      "ready",
+      "Generate `.pi/skills/<skill>/SKILL.md` and/or `.agents/skills/<skill>/SKILL.md` assets exposing `/skill:<skill>`.",
+      "Downstream lanes may consume the typed mapping, but I-14B owns actual file generation/runtime loading."
+    ),
+    nativeFormat: "Agent Skills SKILL.md",
+    autoloadDiscovery: [".pi/skills/<skill>/SKILL.md", ".agents/skills/<skill>/SKILL.md"],
+    skills: VIBE_ENGINEER_SKILLS.map((skillId) => piSkill(skillId))
+  },
+  promptTemplateSurface: surface(
+    known2(
+      "DL-06 pi prompt templates",
+      "Pi prompt templates are `.pi/prompts/*.md` markdown files with filename-derived slash commands and frontmatter/arguments."
+    ),
+    "ready",
+    "Reusable slash-command prompt templates may be declared in `.pi/prompts/<name>.md`.",
+    "Downstream generation must validate template family metadata before writing files."
+  ),
+  hookEventSupport: surface(
+    known2(
+      "DL-06 pi extensions",
+      "Pi TypeScript extensions can register commands/tools and subscribe to events; deterministic gates must not be advisory-only."
+    ),
+    "ready",
+    "Optional `.pi/extensions/**` TypeScript extensions can provide commands, tools, hooks/events, permission gates, and dynamic resources.",
+    "Executable extension files require DL-22 trust/security metadata and later runtime proof."
+  ),
+  subagentCapability: {
+    ...surface(
+      known2(
+        "DL-06 explicit pi limitations",
+        "Pi does not ship built-in subagents; subagent behavior is extension/package-built only."
+      ),
+      "blocked",
+      "No built-in subagent claim is made in I-14A.",
+      "Any subagent-dependent lane must wait for generated extension/package implementation and live proof."
+    ),
+    implementationKind: "extension-built",
+    requiresGeneratedExtension: true
+  },
+  planModeCapability: {
+    ...surface(
+      known2(
+        "DL-06 explicit pi limitations",
+        "Pi does not ship built-in plan mode; plan-mode-like behavior is extension/package-built only."
+      ),
+      "blocked",
+      "No built-in plan-mode claim is made in I-14A.",
+      "Any plan-mode-dependent lane must wait for generated extension/package implementation and live proof."
+    ),
+    implementationKind: "extension-built",
+    requiresGeneratedExtension: true
+  },
+  contextFileConventions: surface(
+    known2(
+      "DL-06 context files",
+      "Pi loads AGENTS.md and optional CLAUDE.md context files subject to trust and load timing."
+    ),
+    "ready",
+    "Context file families are `AGENTS.md` and optional `CLAUDE.md`, with generated content preserving project-owned instructions.",
+    "Downstream writers must use the generated-file manifest and DL-22 trust fields before emitting context files."
+  ),
+  commandInvocationModel: {
+    interactive: surface(
+      known2("DL-06 CLI modes", "Interactive mode is user-facing operation."),
+      "ready",
+      "User operation through `pi` interactive mode.",
+      "No automation may infer machine success from prose."
+    ),
+    printMode: surface(
+      known2("DL-06 CLI modes", "`pi -p`/`--print` is available for one-shot prompts."),
+      "ready",
+      "One-shot prompt mode can be used by future runtime witnesses where safe.",
+      "Future runtime lanes must validate machine-readable outputs where they rely on automation."
+    ),
+    jsonMode: surface(
+      known2("DL-06 JSON mode", "`--mode json` provides event-stream observation."),
+      "ready",
+      "JSON mode is the preferred observation surface for event-stream runtime proof.",
+      "I-14A does not execute live pi runtime; I-14B owns it."
+    ),
+    rpcMode: surface(
+      known2("DL-06 RPC", "RPC `get_commands` can observe generated commands."),
+      "ready",
+      "RPC command listing is a preferred real-boundary observation point.",
+      "I-14A proves manifest API consumption only; live pi RPC is pending I-14B."
+    ),
+    sdk: surface(
+      known2("DL-06 SDK", "SDK/ResourceLoader APIs can observe generated resources."),
+      "ready",
+      "SDK resource loading can be used by future live witnesses.",
+      "I-14A does not claim SDK runtime loading."
+    ),
+    shellCommandPolicy: "default-deny"
+  },
+  generatedFiles: {
+    evidence: known2(
+      "DL-06 pi generated-file families",
+      "The generated-file manifest enumerates every permitted pi family and its owner/trust/version/consumer fields."
+    ),
+    manifestSchemaVersion: "pi-generated-file-manifest/v1",
+    families: [...GENERATED_FILE_FAMILY_IDS],
+    downstreamConsequence: "Downstream lanes must validate the manifest before generating pi files; malformed or missing family metadata blocks."
+  },
+  packageDistribution: {
+    ...surface(
+      known2(
+        "DL-06 pi packages",
+        "Pi packages may declare resources through a package.json `pi` key; trust/update behavior must be explicit."
+      ),
+      "ready",
+      "Primary v1 generation uses project-local files; optional package distribution is declared but not generated in I-14A.",
+      "Package distribution requires explicit generated-file manifest metadata and later lane implementation."
+    ),
+    distributionKinds: ["project-local-files", "pi-package"],
+    trustUpdatePolicy: "Project-local files require project trust; package install/update/trust behavior must be explicit before use."
+  },
+  securityTrust: {
+    evidence: known2(
+      "DL-22 + DL-06",
+      "Adapter declares project trust, executable extension, command policy, sandbox non-claims, credential, destructive-operation, and external-integration defaults."
+    ),
+    projectTrustRequired: true,
+    extensionExecution: "typescript-extension",
+    commandPolicy: "default-deny",
+    sandboxCapability: "not_provided",
+    credentialPolicy: "no-credentials-required",
+    destructiveOperations: "forbidden",
+    externalIntegration: "disabled-by-default",
+    trustBoundary: "Project-local pi resources and TypeScript extensions run only after trust; I-14A claims no OS/network/process sandbox beyond policy declarations."
+  },
+  capabilityFlags: {
+    skills: true,
+    prompts: true,
+    hooks: true,
+    extensions: true,
+    subagents: false,
+    planMode: false,
+    contextFiles: true,
+    rpc: true,
+    sdk: true,
+    jsonMode: true,
+    packages: true,
+    ui: false,
+    unsupportedFeaturePolicy: "block"
+  },
+  realBoundaryWitness: {
+    evidence: known2(
+      "I-14A implementer witness",
+      "Actual package API is consumed by fixture generator/validator and persisted downstream summary; live pi runtime remains out of lane."
+    ),
+    boundaryStatus: "implemented",
+    producer: "@vibe-engineer/adapter-pi subpath APIs under packages/adapters/pi/src/{capabilities,generated-file-manifest,schema}",
+    carrier: "packages/adapters/pi/fixtures/manifest and examples/harness-integrations/pi/manifest-fixtures JSON carriers",
+    consumer: ".vibe/work/I-14A-pi-adapter-capability-generated-file-manifest/witnesses/manifest-api-consumer.mjs",
+    evidencePath: ".vibe/work/I-14A-pi-adapter-capability-generated-file-manifest/downstream-summary.json",
+    runtimeExecutionClaim: "not-claimed"
+  },
+  selection: {
+    manifestSelectable: true,
+    createImportSelectable: false,
+    readiness: "ready",
+    reason: "Ready only as a typed manifest/API contract for downstream consumers; create/import selected-harness behavior belongs to I-15A."
+  }
+};
+var PI_ADAPTER_CAPABILITY_MATRIX = {
+  schemaVersion: PI_ADAPTER_CAPABILITY_SCHEMA_VERSION,
+  producedByLane: "I-14A-pi-adapter-capability-generated-file-manifest",
+  adapterPackage: "@vibe-engineer/adapter-pi",
+  adapters: [
+    piAdapter2,
+    nonPiAdapter(
+      "claude-code",
+      "Claude Code",
+      deferred(
+        "DL-06 other harness disposition",
+        "No local authoritative Claude Code harness generated-resource docs were provided for v1."
+      )
+    ),
+    nonPiAdapter(
+      "codex",
+      "Codex",
+      deferred(
+        "DL-06 other harness disposition",
+        "No local authoritative Codex harness generated-resource docs were provided for v1."
+      )
+    ),
+    nonPiAdapter(
+      "opencode",
+      "OpenCode",
+      deferred(
+        "DL-06 other harness disposition",
+        "Local pi docs mention OpenCode providers, not OpenCode harness asset semantics."
+      )
+    ),
+    nonPiAdapter(
+      "later-integrations",
+      "Later integrations",
+      unknown(
+        "DL-06 future integrations",
+        "Future harnesses require future evidence-backed decisions."
+      )
+    )
+  ]
+};
+var getPiAdapterCapabilityMatrix = () => structuredClone(PI_ADAPTER_CAPABILITY_MATRIX);
+var validatePiAdapterCapabilityMatrix = (value) => validateCapabilityMatrix(value);
+var getAdapterCapabilityById = (matrix, adapterId) => matrix.adapters.find((adapter) => adapter.adapterId === adapterId);
+var isAdapterManifestSelectable = (matrix, adapterId) => {
+  const validation = validateCapabilityMatrix(matrix);
+  if (!validation.valid) {
+    return false;
+  }
+  const adapter = getAdapterCapabilityById(matrix, adapterId);
+  return adapter?.selection.manifestSelectable === true && adapter.selection.readiness === "ready";
+};
+
+export {
+  HARNESS_ADAPTER_CONTRACT_SCHEMA_VERSION,
+  HARNESS_GENERATED_FILE_MANIFEST_SCHEMA_VERSION,
+  HARNESS_ADAPTER_REGISTRY_SCHEMA_VERSION,
+  SUPPORTED_HARNESS_ADAPTER_IDS,
+  HARNESS_RENDERER_EXTENSION_POINTS,
+  renderPiSkill,
+  renderClaudeCodeSkillOrCommand,
+  renderCodexSkillOrCommand,
+  HARNESS_ADAPTERS,
+  HARNESS_ADAPTER_REGISTRY,
+  isSupportedHarnessAdapterId,
+  getHarnessAdapter,
+  listHarnessAdapters,
+  getHarnessAdapterRegistry,
+  PI_ADAPTER_ID,
+  PI_ADAPTER_CAPABILITY_SCHEMA_VERSION,
+  VIBE_ENGINEER_SKILLS,
+  PI_ADAPTER_CAPABILITY_MATRIX,
+  getPiAdapterCapabilityMatrix,
+  validatePiAdapterCapabilityMatrix,
+  getAdapterCapabilityById,
+  isAdapterManifestSelectable
+};