@acidicsoil/portable-capabilities 0.1.9 → 0.1.13

package/dist-release/cli.js

@@ -1997,13 +1997,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} source - expected values are default/config/env/cli/implied
        * @return {Command} `this` command for chaining
        */
-      setOptionValueWithSource(key, value, source3) {
+      setOptionValueWithSource(key, value, source2) {
         if (this._storeOptionsAsProperties) {
           this[key] = value;
         } else {
           this._optionValues[key] = value;
         }
-        this._optionValueSources[key] = source3;
+        this._optionValueSources[key] = source2;
         return this;
       }
       /**
@@ -2024,13 +2024,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {string}
        */
       getOptionValueSourceWithGlobals(key) {
-        let source3;
+        let source2;
         this._getCommandAndAncestors().forEach((cmd) => {
           if (cmd.getOptionValueSource(key) !== void 0) {
-            source3 = cmd.getOptionValueSource(key);
+            source2 = cmd.getOptionValueSource(key);
           }
         });
-        return source3;
+        return source2;
       }
       /**
        * Get user arguments from implied or explicit arguments.
@@ -2900,8 +2900,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const getErrorMessage = (option2) => {
           const bestOption = findBestOptionFromValue(option2);
           const optionKey = bestOption.attributeName();
-          const source3 = this.getOptionValueSource(optionKey);
-          if (source3 === "env") {
+          const source2 = this.getOptionValueSource(optionKey);
+          if (source2 === "env") {
             return `environment variable '${bestOption.envVar}'`;
           }
           return `option '${bestOption.flags}'`;
@@ -7802,11 +7802,11 @@ var getToStream = (destination7, to = "stdin") => {
   }
   return destinationStream;
 };
-var getFromStream = (source3, from = "stdout") => {
+var getFromStream = (source2, from = "stdout") => {
   const isWritable = false;
-  const { options, fileDescriptors } = SUBPROCESS_OPTIONS.get(source3);
+  const { options, fileDescriptors } = SUBPROCESS_OPTIONS.get(source2);
   const fdNumber = getFdNumber(fileDescriptors, from, isWritable);
-  const sourceStream = fdNumber === "all" ? source3.all : source3.stdio[fdNumber];
+  const sourceStream = fdNumber === "all" ? source2.all : source2.stdio[fdNumber];
   if (sourceStream === null || sourceStream === void 0) {
     throw new TypeError(getInvalidStdioOptionMessage(fdNumber, from, options, isWritable));
   }
@@ -9508,17 +9508,17 @@ var PASSTHROUGH_LISTENERS_PER_STREAM = 1;
 
 // node_modules/.pnpm/execa@10.0.0/node_modules/execa/lib/io/pipeline.js
 import { finished as finished3 } from "node:stream/promises";
-var pipeStreams = (source3, destination7) => {
-  source3.pipe(destination7);
-  onSourceFinish(source3, destination7);
-  onDestinationFinish(source3, destination7);
+var pipeStreams = (source2, destination7) => {
+  source2.pipe(destination7);
+  onSourceFinish(source2, destination7);
+  onDestinationFinish(source2, destination7);
 };
-var onSourceFinish = async (source3, destination7) => {
-  if (isStandardStream(source3) || isStandardStream(destination7)) {
+var onSourceFinish = async (source2, destination7) => {
+  if (isStandardStream(source2) || isStandardStream(destination7)) {
     return;
   }
   try {
-    await finished3(source3, { cleanup: true, readable: true, writable: false });
+    await finished3(source2, { cleanup: true, readable: true, writable: false });
   } catch {
   }
   endDestinationStream(destination7);
@@ -9528,19 +9528,19 @@ var endDestinationStream = (destination7) => {
     destination7.end();
   }
 };
-var onDestinationFinish = async (source3, destination7) => {
-  if (isStandardStream(source3) || isStandardStream(destination7)) {
+var onDestinationFinish = async (source2, destination7) => {
+  if (isStandardStream(source2) || isStandardStream(destination7)) {
     return;
   }
   try {
     await finished3(destination7, { cleanup: true, readable: false, writable: true });
   } catch {
   }
-  abortSourceStream(source3);
+  abortSourceStream(source2);
 };
-var abortSourceStream = (source3) => {
-  if (source3.readable) {
-    source3.destroy();
+var abortSourceStream = (source2) => {
+  if (source2.readable) {
+    source2.destroy();
   }
 };
 
@@ -10264,7 +10264,7 @@ var createWritableStream = (subprocess, writableOptions) => Writable3.toWeb(subp
 var createTransformStream = (subprocess, duplexOptions) => Duplex3.toWeb(subprocess.duplex(duplexOptions));
 
 // node_modules/.pnpm/execa@10.0.0/node_modules/execa/lib/pipe/pipe-arguments.js
-var normalizePipeArguments = ({ source: source3, sourcePromise, boundOptions, createNested }, ...pipeArguments) => {
+var normalizePipeArguments = ({ source: source2, sourcePromise, boundOptions, createNested }, ...pipeArguments) => {
   const startTime = getStartTime();
   const {
     destination: destination7,
@@ -10273,8 +10273,8 @@ var normalizePipeArguments = ({ source: source3, sourcePromise, boundOptions, cr
     from,
     unpipeSignal
   } = getDestinationStream(boundOptions, createNested, pipeArguments);
-  const { sourceStream, sourceError } = getSourceStream(source3, from);
-  const { options: sourceOptions, fileDescriptors } = SUBPROCESS_OPTIONS.get(source3);
+  const { sourceStream, sourceError } = getSourceStream(source2, from);
+  const { options: sourceOptions, fileDescriptors } = SUBPROCESS_OPTIONS.get(source2);
   return {
     sourcePromise,
     sourceStream,
@@ -10327,9 +10327,9 @@ var getDestination = (boundOptions, createNested, firstArgument, ...pipeArgument
   throw new TypeError(`The first argument must be a template string, an options object, or an Execa subprocess: ${firstArgument}`);
 };
 var mapDestinationArguments = ({ options }) => ({ options: { ...options, stdin: "pipe", piped: true } });
-var getSourceStream = (source3, from) => {
+var getSourceStream = (source2, from) => {
   try {
-    const sourceStream = getFromStream(source3, from);
+    const sourceStream = getFromStream(source2, from);
     return { sourceStream };
   } catch (error) {
     return { sourceError: error };
@@ -11733,7 +11733,7 @@ function writeEnvelope(envelope, format2) {
 }
 
 // packages/cli/src/release.ts
-var cliVersion = true ? "0.1.9" : createRequire(import.meta.url)("../../../package.json").version;
+var cliVersion = true ? "0.1.13" : createRequire(import.meta.url)("../../../package.json").version;
 
 // packages/adapters/src/antigravity/materialize.ts
 import { resolve as resolve2 } from "node:path";
@@ -11892,7 +11892,7 @@ var antigravityRuntimeDescriptor = {
   schemaVersion: "1.0",
   id: "antigravity",
   aliases: ["google-antigravity", "antigravity-cli"],
-  supportedVersions: [">=2.0.0"],
+  supportedVersions: [">=1.1.4 <2.0.0"],
   locations: [
     {
       id: "antigravity-project-skills",
@@ -11991,11 +11991,11 @@ var antigravityRuntimeDescriptor = {
       evidenceState: "source-observed"
     },
     {
-      id: "antigravity-2.0-rules",
+      id: "antigravity-workspace-rules",
       semanticKind: "rule",
       integrationMode: "declarative",
       adapterId: markdown,
-      discovery: "2.0 workspace rules are discovered from .agents/rules.",
+      discovery: "Workspace rules may be discovered from .agents/rules when verified for a supported client.",
       invocation: "Rules apply according to their activation mode.",
       precedence: ["workspace", "global"],
       evidenceClaimIds: ["antigravity.cli.discovery.rules"],
@@ -12003,11 +12003,11 @@ var antigravityRuntimeDescriptor = {
       evidenceState: "source-observed"
     },
     {
-      id: "antigravity-2.0-agents",
+      id: "antigravity-workspace-agents",
       semanticKind: "agent",
       integrationMode: "declarative",
       adapterId: markdown,
-      discovery: "Custom agents are discovered from .agents/agents.",
+      discovery: "Workspace agents may be discovered from .agents/agents when verified for a supported client.",
       invocation: "Invoke through the native subagent interface.",
       precedence: ["workspace", "global"],
       evidenceClaimIds: ["antigravity.cli.discovery.agents"],
@@ -12015,11 +12015,11 @@ var antigravityRuntimeDescriptor = {
       evidenceState: "source-observed"
     },
     {
-      id: "antigravity-2.0-hooks",
+      id: "antigravity-workspace-hooks",
       semanticKind: "hook",
       integrationMode: "declarative",
       adapterId: hook,
-      discovery: "hooks.json is discovered at workspace scope.",
+      discovery: "Workspace hooks may be discovered from hooks.json when verified for a supported client.",
       invocation: "Hooks participate in native tool and invocation events.",
       precedence: ["workspace", "global", "plugin"],
       evidenceClaimIds: ["antigravity.cli.hooks"],
@@ -12027,11 +12027,11 @@ var antigravityRuntimeDescriptor = {
       evidenceState: "source-observed"
     },
     {
-      id: "antigravity-2.0-mcp",
+      id: "antigravity-workspace-mcp",
       semanticKind: "mcp",
       integrationMode: "declarative",
       adapterId: mcp,
-      discovery: "mcp_config.json is discovered at workspace scope.",
+      discovery: "Workspace MCP may be discovered from mcp_config.json when verified for a supported client.",
       invocation: "MCP servers are exposed as native tools.",
       precedence: ["workspace", "global"],
       evidenceClaimIds: ["antigravity.cli.mcp"],
@@ -12079,148 +12079,148 @@ var antigravityRuntimeDescriptor = {
 // packages/adapters/src/antigravity/runtime-evidence.ts
 import { createHash as createHash7 } from "node:crypto";
 var digest2 = (value) => createHash7("sha256").update(value).digest("hex");
-var retrievedAt = "2026-08-10T00:00:00.000Z";
-var source = "docs/RFC/runtime-capability-profiles-revised.md";
-var sourceClaim = (id, category, subject, assertion, locator, state = "source-observed", mode = "2.0") => ({
-  schemaVersion: "1.0",
-  id,
-  runtimeId: "antigravity",
-  category,
-  subject,
-  assertion,
-  versionRange: `product-mode:${mode}; >=2.0.0`,
-  sourceType: "official-source",
-  source,
-  sourceLocator: locator,
-  sourceDigest: digest2(`${id}:${assertion}:${locator}`),
-  state,
-  confidence: state === "unknown" ? "medium" : "high",
-  verificationStatus: state === "unknown" ? "unverified" : "verified",
-  stability: state === "unknown" ? "version-gated" : "stable",
-  verifiedAt: retrievedAt
-});
+var retrievedAt = "2026-08-15T00:00:00.000Z";
+var cliVersionRange = ">=1.1.4 <2.0.0";
+var cliDocs = "https://codelabs.developers.google.com/antigravity/how-to-create-agent-skills-for-antigravity-cli";
+var productDocs = "https://www.antigravity.google/product/antigravity-cli";
+var sourceClaim = (id, category, subject, assertion, locator, options = {}) => {
+  const state = options.state ?? "source-observed";
+  return {
+    schemaVersion: "1.0",
+    id,
+    runtimeId: "antigravity",
+    category,
+    subject,
+    assertion,
+    versionRange: options.versionRange ?? cliVersionRange,
+    sourceType: "official-docs",
+    source: options.source ?? cliDocs,
+    sourceLocator: locator,
+    sourceDigest: digest2(`${id}:${assertion}:${locator}`),
+    state,
+    confidence: state === "unknown" ? "low" : "high",
+    verificationStatus: state === "unknown" ? "unverified" : "verified",
+    stability: state === "unknown" ? "version-gated" : "stable",
+    verifiedAt: retrievedAt
+  };
+};
 var antigravityRuntimeEvidence = [
   sourceClaim(
     "antigravity.location.project-skills",
     "location",
     "workspace skill root",
-    "Antigravity discovers workspace skills beneath .agents/skills.",
-    "Section 9: .agents/skills/<name>/SKILL.md"
+    "Antigravity CLI discovers workspace skills beneath .agents/skills.",
+    "Skill location: .agents/skills/<skill-name>/SKILL.md"
   ),
   sourceClaim(
     "antigravity.location.project-rules",
     "location",
     "workspace rule root",
-    "Antigravity discovers workspace rules beneath .agents/rules.",
-    "Section 9: .agents/rules/*.md"
+    "The native workspace rule path is not established by the verified CLI skill documentation.",
+    "Workspace rule path: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.location.project-agents",
     "location",
     "workspace agent root",
-    "Antigravity discovers custom agents beneath .agents/agents.",
-    "Section 3: .agents/agents/<name>.md"
+    "The native workspace agent path is not established by the verified CLI skill documentation.",
+    "Workspace agent path: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.location.project-hooks",
     "location",
     "workspace hook config",
-    "Antigravity discovers workspace hooks from .agents/hooks.json.",
-    "Section 3: .agents/hooks.json"
+    "The native workspace hook path is not established by the verified CLI skill documentation.",
+    "Workspace hook path: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.location.project-mcp",
     "location",
     "workspace MCP config",
-    "Antigravity discovers workspace MCP servers from .agents/mcp_config.json.",
-    "Section 3: .agents/mcp_config.json"
+    "The native workspace MCP configuration path is not established by the verified CLI skill documentation.",
+    "Workspace MCP path: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.location.plugins",
     "location",
     "CLI plugin staging root",
-    "Antigravity CLI stages plugins beneath the documented Gemini plugin root.",
-    "Section 2: ~/.gemini/antigravity-cli/plugins/<plugin-name>/"
+    "The native CLI plugin staging path is not established by the verified CLI skill documentation.",
+    "CLI plugin staging path: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.workflow.storage",
     "location",
     "workflow storage",
     "Workflow physical storage path is not established by primary public documentation.",
-    "Section 9: workflow storage unknown",
-    "unknown"
+    "Workflow storage path: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.cli.discovery.skills",
     "discovery",
     "CLI skill discovery",
-    "Antigravity CLI discovers project skills from .agents/skills.",
-    "Section 3; CLI mode; source observation only",
-    "source-observed",
-    "cli"
+    "Antigravity CLI automatically discovers project skills from .agents/skills.",
+    "Skill discovery and /skills listing"
   ),
   sourceClaim(
     "antigravity.cli.invocation.skills",
     "invocation",
     "CLI skill invocation",
-    "Antigravity CLI skill invocation is documented but not runtime-observed.",
-    "Section 6; CLI mode; runtime unavailable",
-    "source-observed",
-    "cli"
+    "Antigravity CLI can list and invoke a discovered skill from the project workspace.",
+    "Launch with agy; invoke through the skill-aware CLI workflow"
   ),
   sourceClaim(
     "antigravity.ide.discovery.skills",
     "discovery",
     "IDE skill discovery",
-    "Antigravity IDE uses the shared .agents/skills workspace root.",
-    "Section 3; IDE mode; runtime unavailable",
-    "source-observed",
-    "ide"
+    "IDE skill discovery is not established by the verified CLI skill documentation.",
+    "IDE skill discovery: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.cli.discovery.rules",
     "discovery",
-    "2.0 rule discovery",
-    "Workspace rules are discovered from .agents/rules.",
-    "Section 3; Antigravity 2.0 mode",
-    "source-observed",
-    "2.0"
+    "workspace rule discovery",
+    "Workspace rule discovery is not established by the verified CLI skill documentation.",
+    "Workspace rule discovery: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.cli.discovery.agents",
     "discovery",
-    "2.0 agent discovery",
-    "Custom agents are discovered from .agents/agents.",
-    "Section 3; Antigravity 2.0 mode",
-    "source-observed",
-    "2.0"
+    "workspace agent discovery",
+    "Workspace agent discovery is not established by the verified CLI skill documentation.",
+    "Workspace agent discovery: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.cli.hooks",
     "hooks",
-    "2.0 hook registration",
-    "Workspace hooks use .agents/hooks.json and typed tool decisions.",
-    "Section 6; Antigravity 2.0 mode",
-    "source-observed",
-    "2.0"
+    "workspace hook registration",
+    "Workspace hook registration is not established by the verified CLI skill documentation.",
+    "Workspace hook registration: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.cli.mcp",
     "mcp",
-    "2.0 MCP registration",
-    "Workspace MCP uses .agents/mcp_config.json.",
-    "Section 3; Antigravity 2.0 mode",
-    "source-observed",
-    "2.0"
+    "workspace MCP registration",
+    "Workspace MCP registration is not established by the verified CLI skill documentation.",
+    "Workspace MCP registration: not established",
+    { source: productDocs, state: "unknown" }
   ),
   sourceClaim(
     "antigravity.cli.plugins",
     "plugin",
     "CLI plugin registration",
-    "CLI plugins require staged bundles with plugin.json.",
-    "Section 5; CLI mode",
-    "source-observed",
-    "cli"
+    "CLI plugin registration is not established by the verified CLI skill documentation.",
+    "CLI plugin registration: not established",
+    { source: productDocs, state: "unknown" }
   )
 ];
 
@@ -13073,6 +13073,7 @@ var codexRuntimeEvidence = Object.freeze([
 ]);
 
 // packages/adapters/src/dcode/materialize.ts
+import { readFile as readFile3 } from "node:fs/promises";
 import { resolve as resolve5 } from "node:path";
 var marker4 = "<!-- portable-capabilities:owned dcode -->";
 function destination4(value) {
@@ -13118,7 +13119,32 @@ function registration3(operation) {
   return `${JSON.stringify({ adapterId: operation.adapterId, kind: operation.kind, target: operation.target }, null, 2)}
 `;
 }
-function prepareDCodeMaterialization(plan, root) {
+async function mergedInstructions(root, path9, operations, removedIds) {
+  let existing;
+  try {
+    existing = await readFile3(resolve5(root, path9), "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (!existing && operations.length === 0) return void 0;
+  const selectedIds = new Set(operations.map((operation) => operation.id));
+  const existingText = existing ?? "";
+  const firstHeading = existingText.search(/^## .+$/mu);
+  const preamble = firstHeading >= 0 ? existingText.slice(0, firstHeading).trim() : existingText.trim();
+  const sections = firstHeading >= 0 ? existingText.slice(firstHeading).split(/(?=^## .+$)/mu) : [];
+  const retained = sections.filter((section) => {
+    const id = section.match(/^## ([^\n]+)/u)?.[1] ?? "";
+    return !selectedIds.has(id) && !removedIds.some((removedId) => id.startsWith(`${removedId}:`));
+  }).map((section) => section.trim());
+  const generated = operations.slice().sort((left, right) => left.id.localeCompare(right.id)).map((operation) => `## ${operation.id}
+
+${operation.content.trim()}`);
+  const sectionsToWrite = [...retained, ...generated];
+  return sectionsToWrite.length > 0 ? `${preamble || marker4}
+${sectionsToWrite.join("\n\n")}
+` : void 0;
+}
+async function prepareDCodeMaterialization(plan, root) {
   if (plan.runtimeId !== "dcode") throw new Error(`DCode adapter cannot prepare ${plan.runtimeId}`);
   const mutations = [];
   const diagnostics = [];
@@ -13220,28 +13246,39 @@ function prepareDCodeMaterialization(plan, root) {
         );
     }
   }
-  if (instructionOperations.length > 0) {
+  const instructionRemovals = plan.operations.filter(
+    (operation) => operation.kind === "RemoveOwnedArtifact" && /^\.deepagents\/skills\/[^/]+\/SKILL\.md$/u.test(destination4(operation.detail))
+  );
+  if (instructionOperations.length > 0 || instructionRemovals.length > 0) {
     const instructionPath = ".deepagents/AGENTS.md";
     confined4(root, instructionPath);
-    const content = instructionOperations.sort((left, right) => left.id.localeCompare(right.id)).map((operation) => `## ${operation.id}
-
-${operation.content.trim()}`).join("\n\n");
-    const first = instructionOperations[0];
-    mutations.push({
-      path: instructionPath,
-      kind: "write",
-      content: `<!-- portable-capabilities:owned dcode -->
-${content}
-`,
-      mode: 420,
-      operationId: "dcode:shared-instructions",
-      sourceProjectionOperationId: first.sourceProjectionOperationId,
-      ownershipIntent: first.ownershipIntent,
-      approval: first.approval,
-      rollback: first.rollback,
-      upgrade: first.upgrade,
-      uninstall: first.uninstall
+    const first = instructionOperations[0] ?? instructionRemovals[0];
+    if (!first) throw new Error("DCode shared instruction operation is missing");
+    const removedIds = instructionRemovals.flatMap((operation) => {
+      const match = operation.detail.match(/^\.deepagents\/skills\/([^/]+)\/SKILL\.md$/u);
+      return match?.[1] ? [match[1]] : [];
     });
+    const content = await mergedInstructions(
+      root,
+      instructionPath,
+      instructionOperations,
+      removedIds
+    );
+    mutations.push(
+      content ? {
+        path: instructionPath,
+        kind: "write",
+        content,
+        mode: 420,
+        operationId: "dcode:shared-instructions",
+        sourceProjectionOperationId: first.sourceProjectionOperationId,
+        ownershipIntent: first.ownershipIntent,
+        approval: first.approval,
+        rollback: first.rollback,
+        upgrade: first.upgrade,
+        uninstall: first.uninstall
+      } : { path: instructionPath, kind: "remove", ...metadata3(first) }
+    );
   }
   return Object.freeze({
     runtimeId: plan.runtimeId,
@@ -13253,7 +13290,7 @@ ${content}
 
 // packages/adapters/src/dcode/runtime-descriptor.ts
 var markdown3 = "materialize-markdown";
-var source2 = "source-observed";
+var source = "source-observed";
 var dcodeRuntimeDescriptor = {
   schemaVersion: "1.0",
   id: "dcode",
@@ -13312,7 +13349,7 @@ var dcodeRuntimeDescriptor = {
       precedence: ["project"],
       evidenceClaimIds: ["dcode.discovery.cli-skill", "dcode.invocation.cli-skill"],
       stability: "stable",
-      evidenceState: source2
+      evidenceState: source
     },
     {
       id: "dcode-cli-instructions",
@@ -13324,7 +13361,7 @@ var dcodeRuntimeDescriptor = {
       precedence: ["project"],
       evidenceClaimIds: ["dcode.location.project-root"],
       stability: "stable",
-      evidenceState: source2
+      evidenceState: source
     },
     {
       id: "dcode-cli-sync-subagents",
@@ -13336,7 +13373,7 @@ var dcodeRuntimeDescriptor = {
       precedence: ["project", "user"],
       evidenceClaimIds: ["dcode.cli.sync-subagents"],
       stability: "version-gated",
-      evidenceState: source2
+      evidenceState: source
     },
     {
       id: "dcode-cli-memory",
@@ -13348,7 +13385,7 @@ var dcodeRuntimeDescriptor = {
       precedence: ["project", "user"],
       evidenceClaimIds: ["dcode.cli.memory"],
       stability: "version-gated",
-      evidenceState: source2
+      evidenceState: source
     },
     {
       id: "dcode-cli-mcp",
@@ -13360,7 +13397,7 @@ var dcodeRuntimeDescriptor = {
       precedence: ["project", "user"],
       evidenceClaimIds: ["dcode.cli.mcp"],
       stability: "version-gated",
-      evidenceState: source2
+      evidenceState: source
     },
     {
       id: "dcode-cli-configuration",
@@ -13372,7 +13409,7 @@ var dcodeRuntimeDescriptor = {
       precedence: ["project", "user"],
       evidenceClaimIds: ["dcode.cli.configuration"],
       stability: "version-gated",
-      evidenceState: source2
+      evidenceState: source
     },
     {
       id: "dcode-cli-advisory-hooks",
@@ -13384,7 +13421,7 @@ var dcodeRuntimeDescriptor = {
       precedence: ["project", "user"],
       evidenceClaimIds: ["dcode.hooks.advisory"],
       stability: "version-gated",
-      evidenceState: source2
+      evidenceState: source
     },
     {
       id: "dcode-sdk-tools",
@@ -13396,7 +13433,7 @@ var dcodeRuntimeDescriptor = {
       precedence: ["sdk"],
       evidenceClaimIds: ["dcode.sdk.tools"],
       stability: "version-gated",
-      evidenceState: source2
+      evidenceState: source
     },
     {
       id: "dcode-cli-async-subagents",
@@ -15048,7 +15085,8 @@ var piRuntimeDescriptor = {
 // packages/adapters/src/pi/runtime-evidence.ts
 import { createHash as createHash13 } from "node:crypto";
 var digest8 = (value) => createHash13("sha256").update(value).digest("hex");
-var observedAt2 = "2026-08-08T04:24:00-05:00";
+var observedAt2 = "2026-08-15T00:00:00.000Z";
+var skillsDocs = "https://pi.dev/docs/latest/skills";
 var piRuntimeEvidence = [
   {
     schemaVersion: "1.0",
@@ -15110,13 +15148,13 @@ var piRuntimeEvidence = [
     runtimeId: "pi",
     category: "discovery",
     subject: "native skill discovery",
-    assertion: "Pi natively discovers a project skill with extensions disabled.",
-    versionRange: "=0.64.0",
-    sourceType: "runtime-probe",
-    source: "pi",
-    sourceLocator: "packages/conformance/src/tracer/pi-native-evidence.json",
-    sourceDigest: digest8("Pi native discovery with extensions disabled"),
-    state: "runtime-observed",
+    assertion: "Pi discovers project skills beneath .pi/skills.",
+    versionRange: ">=0.64.0",
+    sourceType: "official-docs",
+    source: skillsDocs,
+    sourceLocator: "Project skills: .pi/skills/",
+    sourceDigest: digest8("Pi project skills .pi/skills official docs"),
+    state: "source-observed",
     confidence: "high",
     verificationStatus: "verified",
     stability: "stable",
@@ -15128,13 +15166,13 @@ var piRuntimeEvidence = [
     runtimeId: "pi",
     category: "invocation",
     subject: "native skill invocation",
-    assertion: "Pi invokes a discovered project skill with extensions disabled.",
-    versionRange: "=0.64.0",
-    sourceType: "runtime-probe",
-    source: "pi",
-    sourceLocator: "packages/conformance/src/tracer/pi-native-evidence.json",
-    sourceDigest: digest8("Pi native invocation with extensions disabled"),
-    state: "runtime-observed",
+    assertion: "Pi loads a discovered skill when its description matches the task or the user invokes /skill:name.",
+    versionRange: ">=0.64.0",
+    sourceType: "official-docs",
+    source: skillsDocs,
+    sourceLocator: "Skill loading and invocation: /skill:name",
+    sourceDigest: digest8("Pi skill invocation official docs"),
+    state: "source-observed",
     confidence: "high",
     verificationStatus: "verified",
     stability: "stable",
@@ -15253,19 +15291,19 @@ function normalizeSetupRequest(input) {
 // packages/cli/src/setup/service.ts
 import { createHash as createHash16 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
-import { readdir as readdir3, readFile as readFile5 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile6 } from "node:fs/promises";
 import { dirname as dirname4, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve11 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { parse as parse3 } from "yaml";
 
 // packages/cli/src/installation/lifecycle.ts
 import { createHash as createHash15 } from "node:crypto";
-import { chmod, copyFile, lstat as lstat2, mkdir as mkdir3, readFile as readFile4, rename as rename2, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { chmod, copyFile, lstat as lstat2, mkdir as mkdir3, readFile as readFile5, rename as rename2, rm, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve as resolve10, sep } from "node:path";
 
 // packages/cli/src/installation/manifest.ts
 import { createHash as createHash14 } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile3, rename, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile4, rename, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join2 } from "node:path";
 var installationManifestName = ".portable-capabilities-manifest.json";
 var installationJournalName = ".portable-capabilities-journal.json";
@@ -15319,7 +15357,7 @@ function verifyInstallationManifestDigest(manifest) {
   }
 }
 async function digestFile(path9) {
-  return digestBytes(await readFile3(path9));
+  return digestBytes(await readFile4(path9));
 }
 function manifestPath(targetRoot) {
   return join2(targetRoot, installationManifestName);
@@ -15330,7 +15368,7 @@ function journalPath(targetRoot) {
 async function readInstallationManifest(targetRoot) {
   try {
     const parsed = JSON.parse(
-      await readFile3(manifestPath(targetRoot), "utf8")
+      await readFile4(manifestPath(targetRoot), "utf8")
     );
     if (parsed.schemaVersion !== "1.1.0" || !Array.isArray(parsed.entries)) {
       throw new Error("Invalid installation manifest shape");
@@ -15400,10 +15438,10 @@ async function writeJournal(targetRoot, journal) {
   );
   await rename2(temporary, path9);
 }
-async function copyAtomically(source3, target, mode) {
+async function copyAtomically(source2, target, mode) {
   await mkdir3(dirname3(target), { recursive: true });
   const temporary = `${target}.pc-stage-${process.pid}`;
-  await copyFile(source3, temporary);
+  await copyFile(source2, temporary);
   await chmod(temporary, mode);
   await rename2(temporary, target);
 }
@@ -15422,13 +15460,13 @@ function result(operation, state, values = {}) {
   };
 }
 async function backupPath(targetRoot, transactionRoot, path9) {
-  const source3 = await assertNoSymlinkInPreparedPath(targetRoot, path9);
-  if (!await pathExists(source3)) return false;
+  const source2 = await assertNoSymlinkInPreparedPath(targetRoot, path9);
+  if (!await pathExists(source2)) return false;
   await assertNoSymlinkInPreparedPath(targetRoot, path9);
   const target = join3(transactionRoot, "backup", path9);
   await mkdir3(dirname3(target), { recursive: true });
   await assertNoSymlinkInPreparedPath(targetRoot, path9);
-  await copyFile(source3, target);
+  await copyFile(source2, target);
   return true;
 }
 async function restoreTransaction(targetRoot, transactionRoot, mutations, manifestHadOriginal, options) {
@@ -15607,6 +15645,19 @@ async function assertPlanPathsSafe(targetRoot, plan) {
 }
 async function executePreparedInstallation(options) {
   const manifest = await readInstallationManifest(options.targetRoot);
+  const operation = options.preparedOperation ?? "install";
+  if (options.preparedDiagnostics?.length) {
+    return result(operation, "degraded", {
+      ok: false,
+      diagnostics: options.preparedDiagnostics
+    });
+  }
+  if (options.preparedMutations.length === 0) {
+    return result(operation, "degraded", {
+      ok: false,
+      diagnostics: ["No prepared mutations can be installed"]
+    });
+  }
   const duplicatePaths = /* @__PURE__ */ new Set();
   for (const mutation of options.preparedMutations) {
     if (duplicatePaths.has(mutation.path)) {
@@ -15635,7 +15686,7 @@ async function executePreparedInstallation(options) {
     const exists = await pathExists(target);
     if (mutation.ownershipIntent === "preserve-user" && exists) continue;
     if (exists && mutation.kind === "write" && mutation.ownershipIntent === "own") {
-      const current = await readFile4(target, "utf8");
+      const current = await readFile5(target, "utf8");
       const ownedEntry = manifest?.entries.find((entry) => entry.path === mutation.path);
       const isManifestOwned = ownedEntry !== void 0 && await digestFile(target) === ownedEntry.digest;
       if (!current.includes("portable-capabilities:owned") && !isManifestOwned)
@@ -15681,7 +15732,6 @@ async function executePreparedInstallation(options) {
     packageIdentities,
     entries: nextEntries
   };
-  const operation = options.preparedOperation ?? "install";
   if (options.dryRun)
     return result(operation, manifest ? "healthy" : "missing", {
       dryRun: true,
@@ -15716,63 +15766,6 @@ async function statusInstallation(targetRoot) {
     manifest
   });
 }
-async function removeInstallation(targetRoot, faultInjector, capabilityIds) {
-  const manifest = await readInstallationManifest(targetRoot);
-  if (!manifest) return result("remove", "missing", { ok: false });
-  const selected = new Set(capabilityIds ?? []);
-  const scoped = (path9) => {
-    if (selected.size === 0) return true;
-    const normalized = path9.replaceAll("\\", "/");
-    return [...selected].some(
-      (id) => normalized.includes(`/skills/${id}/`) || normalized.endsWith(`/skills/${id}`)
-    );
-  };
-  const classifications = await classifyManifestEntries(manifest);
-  const unchanged = new Set(
-    classifications.unchanged.filter((entry) => scoped(entry.path)).map((entry) => entry.path)
-  );
-  const removes = manifest.entries.filter((entry) => unchanged.has(entry.path)).map((entry) => entry.path);
-  const preserved = manifest.entries.filter((entry) => !unchanged.has(entry.path));
-  const nextManifest = preserved.length ? (() => {
-    const entries = Object.freeze(preserved);
-    const preservedPaths = new Set(entries.map((entry) => entry.path));
-    const packageIdentities = Object.freeze(
-      manifest.packageIdentities.filter((identity3) => preservedPaths.has(identity3.lockPath))
-    );
-    const packageDigest = packageEntriesDigest(entries, packageIdentities);
-    const base = {
-      runtimeId: manifest.runtimeId,
-      packageVersion: manifest.packageVersion,
-      targetRoot: manifest.targetRoot,
-      journalVersion: manifest.journalVersion,
-      lifecycleState: "modified",
-      packageIdentities,
-      entries
-    };
-    return {
-      ...manifest,
-      ...base,
-      packageDigest,
-      installationDigest: installationOwnershipDigest(packageDigest, base)
-    };
-  })() : void 0;
-  return commitPlan(
-    "remove",
-    {
-      sourceRoot: targetRoot,
-      targetRoot,
-      runtimeId: manifest.runtimeId,
-      packageVersion: manifest.packageVersion,
-      ...faultInjector ? { faultInjector } : {}
-    },
-    {
-      writes: [],
-      removes,
-      preserved: preserved.map((entry) => entry.path),
-      ...nextManifest ? { nextManifest } : {}
-    }
-  );
-}
 
 // packages/cli/src/setup/service.ts
 function roleFacet(role, name) {
@@ -15833,7 +15826,7 @@ async function loadCanonicalArtifact(catalogRoot, capabilityId) {
   if (!capabilityId || /[\\/]/u.test(capabilityId))
     throw new Error("capability IDs must be single path segments");
   const file = resolve11(catalogRoot, "roles", `${capabilityId}.yaml`);
-  const role = parse3(await readFile5(file, "utf8"));
+  const role = parse3(await readFile6(file, "utf8"));
   if (role.schemaVersion !== "1.0" || role.id !== capabilityId || !role.purpose || !Array.isArray(role.inputs) || !role.output || !role.family || !role.taxonomy || !Array.isArray(role.precedence) || !Array.isArray(role.requiredBehavior) || !Array.isArray(role.forbiddenBehavior) || !Array.isArray(role.evaluation?.criteria)) {
     throw new Error(`Invalid canonical capability: ${file}`);
   }
@@ -15842,7 +15835,7 @@ async function loadCanonicalArtifact(catalogRoot, capabilityId) {
   const schemaRelativePath = relative3(resolve11(catalogRoot), schemaFile);
   if (isAbsolute3(schemaRelativePath) || schemaRelativePath.startsWith(".."))
     throw new Error(`Canonical output schema escapes catalog: ${role.output.schema}`);
-  const schemaContent = await readFile5(schemaFile, "utf8");
+  const schemaContent = await readFile6(schemaFile, "utf8");
   const contract = operationalContract(role);
   const contractContent = `${JSON.stringify(
     { ...role, output: { ...role.output, schema: "resources/output.schema.json" } },
@@ -15915,6 +15908,35 @@ function previewSetup(request, artifact, descriptor, claims, ownershipManifest)
   const body = { ...plan, selectedSurfaces, conversions, conflicts };
   return { ...body, digest: stableDigest(body) };
 }
+function negotiationDiagnostics(previews) {
+  return previews.flatMap(
+    (preview) => preview.negotiations.filter((negotiation) => negotiation.installationMode !== "automatic").map((negotiation) => {
+      const evidence = negotiation.evidenceClaimIds.join(", ") || "no evidence claims";
+      return `${negotiation.intent}: ${negotiation.installationMode} (${negotiation.reason}) [${evidence}]`;
+    })
+  );
+}
+function composeInstallationPlan(previews, artifacts, runtimeId) {
+  const first = previews[0]?.installationPlan;
+  if (!first) throw new Error("at least one installation plan is required");
+  const operations = previews.flatMap((preview, index) => {
+    const capabilityId = artifacts[index]?.id;
+    if (!capabilityId) throw new Error("installation plan is missing its capability");
+    return preview.installationPlan.operations.map((operation) => ({
+      ...operation,
+      id: `${capabilityId}:${operation.id}`,
+      sourceProjectionOperationId: `${capabilityId}:${operation.sourceProjectionOperationId}`
+    }));
+  });
+  const base = {
+    schemaVersion: first.schemaVersion,
+    id: `installation:${runtimeId}:${artifacts.map((artifact) => artifact.id).join(",")}`,
+    runtimeId,
+    scope: first.scope,
+    operations
+  };
+  return { ...base, digest: stableDigest(base) };
+}
 function defaultCatalogRoot() {
   const moduleDir = dirname4(fileURLToPath4(import.meta.url));
   const packagedCatalog = [resolve11(moduleDir, "catalog"), resolve11(moduleDir, "../catalog")].find(
@@ -15973,23 +15995,35 @@ async function executeSetupSelection(request, artifacts, descriptor, claims, con
     ...context.faultInjector ? { faultInjector: context.faultInjector } : {}
   };
   const runtime = resolveProductionRuntime(executionRequest.runtimeId);
-  const lifecycle = executionRequest.intent === "setup" || executionRequest.intent === "update" ? await executePreparedInstallation({
-    ...lifecycleOptions,
-    preparedOperation: executionRequest.intent === "update" ? "upgrade" : "install",
-    preparedMutations: (await Promise.all(
-      previews.map((preview) => runtime.prepare(preview.installationPlan, targetRoot))
-    )).flatMap((prepared) => prepared.mutations)
-  }) : executionRequest.intent === "remove" ? await removeInstallation(
-    targetRoot,
-    context.faultInjector,
-    executionRequest.capabilityIds
-  ) : await statusInstallation(targetRoot);
+  const lifecycle = executionRequest.intent === "setup" || executionRequest.intent === "update" || executionRequest.intent === "remove" ? await (async () => {
+    const installationPlan = composeInstallationPlan(
+      previews,
+      planningArtifacts,
+      executionRequest.runtimeId
+    );
+    const prepared = await runtime.prepare(installationPlan, targetRoot);
+    if (prepared.runtimeId !== installationPlan.runtimeId || prepared.planId !== installationPlan.id) {
+      throw new Error(`Materializer returned an invalid ${executionRequest.runtimeId} plan`);
+    }
+    const duplicatePath = prepared.mutations.map((mutation) => mutation.path).find((path9, index, paths) => paths.indexOf(path9) !== index);
+    if (duplicatePath)
+      throw new Error(`Selection produced duplicate prepared path: ${duplicatePath}`);
+    const preparedDiagnostics = [
+      ...prepared.diagnostics?.map(
+        (diagnostic6) => `${diagnostic6.kind}: ${diagnostic6.message}`
+      ) ?? [],
+      ...executionRequest.intent === "remove" ? [] : negotiationDiagnostics(previews)
+    ];
+    return executePreparedInstallation({
+      ...lifecycleOptions,
+      preparedOperation: executionRequest.intent === "update" ? "upgrade" : executionRequest.intent === "remove" ? "remove" : "install",
+      preparedMutations: prepared.mutations,
+      ...preparedDiagnostics.length > 0 ? { preparedDiagnostics } : {}
+    });
+  })() : await statusInstallation(targetRoot);
   return { request, previews, lifecycle };
 }
 
-// packages/cli/src/wizard.ts
-import { execFileSync } from "node:child_process";
-
 // node_modules/.pnpm/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
 import { styleText } from "node:util";
 import { stdout, stdin } from "node:process";
@@ -17197,6 +17231,73 @@ ${r2}
   }
 }).prompt();
 
+// packages/cli/src/setup/probe.ts
+import { execFileSync } from "node:child_process";
+var executables = Object.freeze({
+  antigravity: "agy",
+  "claude-code": "claude",
+  codex: "codex",
+  dcode: "dcode",
+  "oh-my-pi": "omp",
+  opencode: "opencode",
+  pi: "pi"
+});
+function resolveRuntimeProbe(runtimeId) {
+  const runtime = resolveProductionRuntime(runtimeId);
+  const canonicalId = runtime.descriptor.id;
+  const executable = executables[canonicalId];
+  if (!executable) throw new Error(`No runtime probe configured for ${canonicalId}`);
+  return {
+    runtimeId: canonicalId,
+    executable,
+    args: ["--version"],
+    supportedVersions: runtime.descriptor.supportedVersions
+  };
+}
+function parseVersion2(output) {
+  return output.match(/\bv?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/u)?.[1];
+}
+function defaultRun(probe) {
+  return execFileSync(probe.executable, probe.args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 5e3
+  });
+}
+function probeRuntimeVersion(runtimeId, options = {}) {
+  const probe = resolveRuntimeProbe(runtimeId);
+  let output;
+  try {
+    output = (options.run ?? defaultRun)(probe);
+  } catch (error) {
+    const code = error.code;
+    const unavailable = code === "ENOENT" || code === "EACCES";
+    return {
+      status: unavailable ? "unavailable" : "failed",
+      runtimeId: probe.runtimeId,
+      executable: probe.executable,
+      reason: unavailable ? `${probe.executable} is not installed or is not executable` : error instanceof Error ? error.message : String(error)
+    };
+  }
+  const version = parseVersion2(output);
+  if (!version)
+    return {
+      status: "unknown-version",
+      runtimeId: probe.runtimeId,
+      executable: probe.executable,
+      reason: "version probe returned no parseable semantic version"
+    };
+  if (!probe.supportedVersions.some((range) => isRuntimeVersionInRange(range, version)))
+    return {
+      status: "unsupported-version",
+      runtimeId: probe.runtimeId,
+      executable: probe.executable,
+      version,
+      reason: `version ${version} is outside the supported runtime ranges`
+    };
+  return { status: "detected", runtimeId: probe.runtimeId, executable: probe.executable, version };
+}
+
 // packages/cli/src/wizard.ts
 var supportedRuntimes = [...productionRuntimeRegistry.keys()];
 function unwrap(value) {
@@ -17207,17 +17308,6 @@ function unwrap(value) {
   }
   return value;
 }
-function detectRuntimeVersion(runtime) {
-  try {
-    const output = execFileSync(runtime, ["--version"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    return output.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0] ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
 async function runInstallWizard() {
   intro("Portable Capabilities setup");
   try {
@@ -17237,6 +17327,12 @@ async function runInstallWizard() {
         options: supportedRuntimes.map((value) => ({ value, label: value }))
       })
     );
+    const probe = probeRuntimeVersion(runtime);
+    if (probe.status !== "detected" || !probe.version) {
+      log.error(`${runtime}: ${probe.reason ?? probe.status}`);
+      process.exitCode = 4;
+      return;
+    }
     const target = String(
       unwrap(
         await text({
@@ -17254,7 +17350,7 @@ async function runInstallWizard() {
     );
     const request = normalizeSetupRequest({
       runtimeId: runtime,
-      runtimeVersion: detectRuntimeVersion(runtime),
+      runtimeVersion: probe.version,
       scope: "project",
       projectDirectory: target,
       capabilityIds,
@@ -17276,7 +17372,7 @@ async function runInstallWizard() {
       runtimeEntry.claims,
       { sourceRoot: process.cwd(), packageVersion: cliVersion }
     );
-    if (!result2.lifecycle || !result2.lifecycle.ok) {
+    if (!result2.lifecycle?.ok) {
       for (const diagnostic6 of result2.lifecycle?.diagnostics ?? ["Approval required."])
         log.error(diagnostic6);
       process.exitCode = 4;