release-skill 0.9.5 → 0.9.7

package/bin/release-skill-cli.mjs

@@ -5,7 +5,7 @@ import { basename, dirname, join, resolve } from 'node:path';
 import { execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
 import { parseNodeMajor, meetsMinimum, computeReadinessStatus } from '../src/core/node-version.mjs';
-import { registerPathRedactor } from '../src/core/errors.mjs';
+import { EXIT_CODE_MAP, MISSING_PARAMETERS, registerPathRedactor } from '../src/core/errors.mjs';
 import { redactSensitivePaths } from '../src/core/redact.mjs';
 
 // Process output errors can be emitted immediately after a large console
@@ -37,7 +37,7 @@ registerPathRedactor(redactSensitivePaths);
 
 const execFile = promisify(execFileCb);
 
-const COMMANDS = new Set(['help', 'setup', 'assess', 'prepare', 'approve', 'publish', 'reconcile', 'verify', 'ship', 'post-release', 'attest', 'hooks', 'artifacts', 'docs', 'distribute', 'route', 'lineage']);
+const COMMANDS = new Set(['help', 'setup', 'assess', 'prepare', 'approve', 'publish', 'reconcile', 'verify', 'postverify', 'ship', 'post-release', 'attest', 'hooks', 'artifacts', 'docs', 'distribute', 'route', 'lineage']);
 
 /**
  * Wait until writes already queued on a process output stream have reached
@@ -307,6 +307,11 @@ function getCapabilityMaturity() {
       mode: 'fresh consumer verification (protocol-tested; no OS/network sandbox)',
       description: 'Recheck remote state, exact npm installation, CLI help, and automated Claude/Codex installs before VERIFIED; Kimi/CodeBuddy remain unverified manual follow-ups',
     },
+    postverify: {
+      available: true,
+      mode: 'independent postVerify execution',
+      description: 'Run approved postVerify hooks from a VERIFIED run in an independent run; never reads or writes ship state',
+    },
     distribute: {
       available: true,
       mode: 'controlled production (protocol-tested; no OS/network sandbox)',
@@ -340,6 +345,7 @@ Commands:
   publish    Publish frozen GitHub/npm artifacts after approval
   reconcile  Resume PARTIAL state from evidence; conflicts require a human
   verify     Fresh remote and consumer verification; only this reaches VERIFIED
+  postverify Run approved postVerify hooks from a VERIFIED run in an independent run
   ship       Resume one durable prepare -> approve -> publish -> verify flow; completes a parked
              postVerify hook once its checkpoint approval is provided (--hook-approval)
   post-release Inspect optional local finishing work after VERIFIED; update installed host plugins
@@ -354,10 +360,10 @@ Commands:
 
 Options:
   --root <path>    Project root directory (default: cwd)
-  --plan <path>    Path to the release plan file
+  --plan <path>    Path to the release plan file (required for approve/publish/reconcile/verify/postverify)
   --run <path>     Path to the release run file, or a run directory whose release-run.json
-                   is resolved automatically (required for reconcile/verify)
-  --approval <path> Path to the approval record
+                   is resolved automatically (required for reconcile/verify/postverify)
+  --approval <path> Path to the release-level approval record (required for publish/postverify)
   --production     Prepare immutable Git/npm production artifacts
   --output <path>  Override prepare/approve output path (non-production only)
   --run-dir <path> Override prepare run directory; production requires one direct child of .release-skill/runs
@@ -394,7 +400,7 @@ Options:
   --install-path <path> Actual managed plugin path when closure verification requires it
   --install-channel <desktop|cli> CodeBuddy installation channel when required
   --approve         Approve the ship plan (boolean; plan digest is auto-resolved)
-  --hook-approval <path> Checkpoint approval for a requiresApproval postPublish hook (ship/distribute; repeatable)
+  --hook-approval <path> Checkpoint approval for one requiresApproval hook (ship/distribute/postverify; repeatable)
   --state <path>    Override the durable ship state file
   --update-local-hosts Update installed plugins for selected local hosts after VERIFIED
   --hosts <ids>     Comma-separated local hosts for post-release update. No local host is updated unless --hosts contains at least one id
@@ -1539,6 +1545,124 @@ if (command === 'verify') {
   }
 }
 
+// --- PostVerify command routing ---
+if (command === 'postverify') {
+  if (args.includes('--help') || args.includes('-h')) {
+    const helpText = `release-skill postverify - Run approved postVerify hooks from a VERIFIED run
+
+Usage:
+  release-skill postverify [--root <path>] --plan <path> --approval <path> --run <path> [options]
+
+Required options:
+  --plan <path>             Path to the release plan file
+  --approval <path>         Path to the release-level approval record
+  --run <path>              Path to the VERIFIED verify run file or directory
+
+Optional options:
+  --root <path>             Project root directory (default: cwd)
+  --hook-approval <path>    Checkpoint approval for a requiresApproval postVerify hook (repeatable)
+  --json                    Output results as JSON
+  -h, --help                Show this help message and exit
+
+This command creates an independent postVerify run and never reads or writes ship state.`;
+    if (hasJson) {
+      console.log(JSON.stringify({
+        command: 'postverify',
+        status: 'HELP',
+        usage: 'release-skill postverify [--root <path>] --plan <path> --approval <path> --run <path> [options]',
+        options: {
+          '--root': 'Project root directory (default: cwd)',
+          '--plan': 'Path to the release plan file (required)',
+          '--approval': 'Path to the release-level approval record (required)',
+          '--run': 'Path to the VERIFIED verify run file or directory (required)',
+          '--hook-approval': 'Checkpoint approval for a requiresApproval postVerify hook (repeatable)',
+          '--json': 'Output results as JSON',
+          '-h, --help': 'Show this help message and exit',
+        },
+        message: 'Creates an independent postVerify run and never reads or writes ship state.',
+      }, null, 2));
+    } else {
+      console.log(helpText);
+    }
+    await exitAfterFlush(0);
+  }
+
+  let malformedValuedFlag;
+  const value = (flag) => {
+    let firstValue;
+    for (let i = 0; i < args.length; i += 1) {
+      if (args[i] !== flag) continue;
+      const next = args[i + 1];
+      if (!next || next.startsWith('-')) {
+        malformedValuedFlag ??= flag;
+        continue;
+      }
+      firstValue ??= next;
+    }
+    return firstValue;
+  };
+  const root = resolve(value('--root') ?? process.cwd());
+  const planPath = value('--plan');
+  const approvalPath = value('--approval');
+  const runPath = value('--run');
+  const postpublishApprovalPaths = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === '--hook-approval') {
+      const next = args[i + 1];
+      if (!next || next.startsWith('-')) {
+        malformedValuedFlag ??= '--hook-approval';
+      } else {
+        postpublishApprovalPaths.push(resolve(next));
+      }
+    }
+  }
+
+  if (malformedValuedFlag || !planPath || !approvalPath || !runPath) {
+    const msg = 'postverify requires --plan <path>, --approval <path>, and --run <path>';
+    if (hasJson) {
+      console.log(JSON.stringify({ error: MISSING_PARAMETERS, message: msg, exitCode: EXIT_CODE_MAP[MISSING_PARAMETERS] }));
+    } else {
+      console.error(`Error: ${msg}`);
+    }
+    await exitAfterFlush(EXIT_CODE_MAP[MISSING_PARAMETERS]);
+  }
+
+  try {
+    const { postVerifyRelease } = await import('../src/commands/postverify.mjs');
+    const result = await postVerifyRelease({
+      planPath: resolve(planPath),
+      approvalPath: resolve(approvalPath),
+      sourceRunPath: resolve(runPath),
+      root,
+      ...(postpublishApprovalPaths.length > 0 ? { postpublishApprovalPaths } : {}),
+    });
+
+    if (hasJson) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`PostVerify status: ${result.status}`);
+      for (const cp of result.checkpoints ?? []) {
+        console.log(`  ${cp.actionId}: ${cp.status}`);
+      }
+      if (result.runPath) console.log(`PostVerify run: ${result.runPath}`);
+    }
+
+    await exitAfterFlush(result.status === 'DISTRIBUTED' ? 0 : 1);
+  } catch (err) {
+    if (hasJson) {
+      console.log(JSON.stringify({
+        error: err.code ?? 'UNKNOWN_ERROR',
+        message: err.message,
+        details: err.details ?? {},
+        exitCode: err.exitCode ?? 1,
+      }));
+    } else {
+      console.error(`Error: ${err.message}`);
+    }
+    await exitAfterFlush(err.exitCode ?? 1);
+  }
+}
+
 // --- Publish command routing ---
 if (command === 'publish') {
 

package/bin/release-skill.bundle.mjs

@@ -9,9 +9,9 @@ const __bundlePkgRoot = __bundleResolve(__bundleDirname(__bundleFileURLToPath(im
 // Provide a real require() for CJS packages bundled into ESM (e.g. yaml, ajv).
 const __bundleRealRequire = __bundleCreateRequire(import.meta.url);
 // Package identity injected at build time — closure-independent --version probe.
-const __bundlePkg = Object.freeze({"name":"release-skill","version":"0.9.5"});
+const __bundlePkg = Object.freeze({"name":"release-skill","version":"0.9.7"});
 // Build-time source digest for the BUNDLE_STALE freshness gate (see above).
-const __bundleSourceDigest = "cbcc967eb1306a8f2e88e404a9ffbdb8bfaf0ffb8863fe8c5521cbb4d44346c1";
+const __bundleSourceDigest = "938bc6828f17e2248a4fe167bcd3353b43848ec1a494dc17dc663d390847150c";
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -109520,9 +109520,27 @@ async function checkSkillResourceClosure({
   result2.receiptDigest = digestDocument(receiptProjection(result2));
   return result2;
 }
-function evaluateDeclaredHostSurfaceCoverage(expectedHosts, surfaces) {
+function evaluateDeclaredHostSurfaceCoverage(expectedHosts, surfaces, coverageClaims = []) {
   const missing = [];
+  const observedById = new Map((surfaces ?? []).map((surface) => [surface.id, surface]));
+  const claimsByHost = /* @__PURE__ */ new Map();
+  for (const claim of coverageClaims ?? []) {
+    const hostClaims = claimsByHost.get(claim.host) ?? [];
+    hostClaims.push(claim);
+    claimsByHost.set(claim.host, hostClaims);
+  }
   for (const expectedHost of [...new Set(expectedHosts ?? [])].sort((a, b) => a.localeCompare(b))) {
+    const declaredClaims = claimsByHost.get(expectedHost) ?? [];
+    if (declaredClaims.length > 0) {
+      const missingClaim = declaredClaims.find((claim) => {
+        const surface3 = observedById.get(claim.surfaceId);
+        return !surface3 || !(surface3.skillCount >= 1);
+      });
+      if (!missingClaim) continue;
+      const surface2 = observedById.get(missingClaim.surfaceId);
+      missing.push({ host: expectedHost, skillCount: surface2?.skillCount ?? 0 });
+      continue;
+    }
     const surface = (surfaces ?? []).find((item) => item.host === expectedHost);
     if (!surface || !(surface.skillCount >= 1)) {
       missing.push({ host: expectedHost, skillCount: surface?.skillCount ?? 0 });
@@ -109640,6 +109658,39 @@ function transportPayload(entries) {
     contentDigest
   }));
 }
+function foundationPayloadMembers(observation) {
+  return observation.members.map((member) => {
+    if (member.type === "file") {
+      return {
+        path: member.path,
+        type: member.type,
+        mode: member.statMode & ~146,
+        size: member.bytes,
+        contentDigest: member.sha256
+      };
+    }
+    if (member.type === "directory") {
+      return { path: member.path, type: member.type, mode: member.statMode };
+    }
+    return {
+      path: member.path,
+      type: member.type,
+      mode: member.statMode,
+      size: member.bytes,
+      targetBase64: member.targetBase64
+    };
+  });
+}
+async function observeMarketplaceInstallTree(installPath) {
+  const canonicalInstallPath = await realpath22(installPath);
+  const rootBinding = await createFilesystemRootBinding(canonicalInstallPath);
+  const observation = await observeFilesystemTree({
+    root: canonicalInstallPath,
+    rootBinding,
+    symlinkPolicy: { mode: "record" }
+  });
+  return foundationPayloadMembers(observation);
+}
 function resolveMarketplaceRoot(platform, marketplaceIndexPath) {
   const defaultMarketplace = platform.manifestPaths.marketplace;
   if (!defaultMarketplace) {
@@ -109869,10 +109920,10 @@ async function verifyInstalledMarketplacePayload(action, context, installPath, c
     throw new Error(`unsupported marketplace payload contract: ${JSON.stringify(payloadContract)}`);
   }
   if (payloadContract === PAYLOAD_CONTRACT_DECLARED_MANIFEST || payloadContract === PAYLOAD_CONTRACT_EXTERNAL_MARKETPLACE) {
-    const installedSnapshot2 = await computeFrozenSnapshot(installPath);
+    const installedMembers = await observeMarketplaceInstallTree(installPath);
     const authorityPayload = transportPayload(authorityEntries);
     const installedByPath = new Map(
-      transportPayload(installedSnapshot2.entries).map((entry) => [entry.path, entry])
+      installedMembers.map((entry) => [entry.path, entry])
     );
     const conflicts = [];
     for (const authorityEntry of authorityPayload) {
@@ -109897,11 +109948,19 @@ async function verifyInstalledMarketplacePayload(action, context, installPath, c
       );
     }
     const authorityPaths = new Set(authorityPayload.map((entry) => entry.path));
-    const extraPaths = installedSnapshot2.entries.map((entry) => entry.path).filter((path40) => !authorityPaths.has(path40));
+    const extraMembers = installedMembers.filter((entry) => entry.type !== "directory" && !authorityPaths.has(entry.path));
+    const extraPaths = extraMembers.map((entry) => entry.path);
     const extraInstalledPaths = extraPaths.slice(0, EXTRA_INSTALLED_PATHS_CAP);
+    const extraInstalledLinks = extraMembers.filter((entry) => entry.type === "symlink").slice(0, EXTRA_INSTALLED_PATHS_CAP).map((entry) => ({
+      path: entry.path,
+      targetBase64: entry.targetBase64,
+      bytes: entry.size,
+      statMode: entry.mode
+    }));
     return {
       manifestDigest: action.manifestDigest,
       extraInstalledPaths,
+      ...extraInstalledLinks.length > 0 ? { extraInstalledLinks } : {},
       ...extraPaths.length > EXTRA_INSTALLED_PATHS_CAP ? { extraInstalledPathsTotal: extraPaths.length } : {}
     };
   }
@@ -109917,6 +109976,7 @@ function extraInstalledPathsAudit(binding) {
   if (!binding || !Array.isArray(binding.extraInstalledPaths)) return {};
   return {
     extraInstalledPaths: binding.extraInstalledPaths,
+    ...Array.isArray(binding.extraInstalledLinks) && binding.extraInstalledLinks.length > 0 ? { extraInstalledLinks: binding.extraInstalledLinks } : {},
     ...binding.extraInstalledPathsTotal !== void 0 ? { extraInstalledPathsTotal: binding.extraInstalledPathsTotal } : {}
   };
 }
@@ -112320,6 +112380,7 @@ var init_plugin_marketplace = __esm({
   async "src/adapters/plugin-marketplace.mjs"() {
     init_contract();
     init_installation_contract();
+    init_src2();
     init_frozen();
     await init_registry2();
     await init_kimi();
@@ -112332,6 +112393,8 @@ var init_plugin_marketplace = __esm({
     PAYLOAD_CONTRACT_EXTERNAL_MARKETPLACE = "external-marketplace-v1";
     EXTRA_INSTALLED_PATHS_CAP = 200;
     PAYLOAD_CONFLICT_REPORT_CAP = 10;
+    __name(foundationPayloadMembers, "foundationPayloadMembers");
+    __name(observeMarketplaceInstallTree, "observeMarketplaceInstallTree");
     CONSUMER_INSTALL_RECIPE_VERSION = "consumer-install-v1";
     __name(resolveMarketplaceRoot, "resolveMarketplaceRoot");
     __name(extractDeclaredPluginSource, "extractDeclaredPluginSource");
@@ -112451,6 +112514,23 @@ async function deriveSurfaceHostBinding({ manifest, pluginRoot, platform, snapsh
   const host = await normalizeHostId(platform.buildAdapter.name);
   return { surfaceId, host };
 }
+function groupSurfaceHostBindings(claims = []) {
+  if (!Array.isArray(claims)) {
+    throw new TypeError("surfaceHostBindings must be an array");
+  }
+  const bySurface = /* @__PURE__ */ new Map();
+  for (const claim of claims) {
+    if (!claim || typeof claim !== "object" || typeof claim.surfaceId !== "string" || typeof claim.host !== "string") {
+      throw new TypeError("surfaceHostBindings entries must be objects with string surfaceId and host");
+    }
+    const existing = bySurface.get(claim.surfaceId) ?? [];
+    existing.push({ surfaceId: claim.surfaceId, host: claim.host });
+    bySurface.set(claim.surfaceId, existing);
+  }
+  const coverageClaims = [...bySurface.values()].flat().sort((left, right) => left.surfaceId.localeCompare(right.surfaceId) || left.host.localeCompare(right.host));
+  const checkerBindings = [...bySurface.values()].filter((surfaceClaims) => surfaceClaims.length === 1).map(([claim]) => claim).sort((left, right) => left.surfaceId.localeCompare(right.surfaceId) || left.host.localeCompare(right.host));
+  return { coverageClaims, checkerBindings };
+}
 var SKILLS_NORMALIZERS;
 var init_surface_host_bindings = __esm({
   async "src/core/surface-host-bindings.mjs"() {
@@ -112468,6 +112548,7 @@ var init_surface_host_bindings = __esm({
     __name(pluginRootFromManifestRelativePath, "pluginRootFromManifestRelativePath");
     __name(assertDeclaredSkillsDirExists, "assertDeclaredSkillsDirExists");
     __name(deriveSurfaceHostBinding, "deriveSurfaceHostBinding");
+    __name(groupSurfaceHostBindings, "groupSurfaceHostBindings");
   }
 });
 
@@ -113898,11 +113979,16 @@ async function verifyRelease(options) {
         const unit = (plan.units ?? []).find((u) => u.id === unitId);
         const dist = unit?.distributions?.find((d) => d.type === platform.distributionType);
         let binding = null;
+        let frozenPluginRoot = null;
         const contract2 = dist?.installationContract;
         if (contract2?.normalizedManifest) {
+          frozenPluginRoot = pluginRootFromManifestRelativePath(contract2.manifestRelativePath);
           binding = await deriveSurfaceHostBinding({
             manifest: contract2.normalizedManifest,
-            pluginRoot: pluginRootFromManifestRelativePath(contract2.manifestRelativePath),
+            // Adapter observations are already rooted at the installed
+            // plugin. The frozen manifest's skills path is therefore
+            // relative to '.', not to the snapshot-root manifest path.
+            pluginRoot: ".",
             platform,
             snapshotDir: check.observation.installPath
           });
@@ -113915,6 +114001,7 @@ async function verifyRelease(options) {
           unitId,
           surfaceId: binding?.surfaceId ?? ".",
           binding,
+          frozenPluginRoot,
           unit
         });
       }
@@ -113997,7 +114084,7 @@ async function verifyRelease(options) {
             );
           }
           const pluginDistCount = (surface.unit?.distributions ?? []).filter((d) => d.type !== "npm").length;
-          if (pluginDistCount === 1) {
+          if (pluginDistCount === 1 && surface.frozenPluginRoot === ".") {
             const observedReceipt = createSkillResourceClosureReceipt(closureResult, {
               unitId: surface.unitId,
               preparedAt: expectedUnitReceipt.preparedAt ?? null,
@@ -129591,10 +129678,11 @@ async function runPrepareSkillResourceClosureGate({
       });
       if (binding) surfaceHostBindings.push(binding);
     }
+    const { checkerBindings, coverageClaims } = groupSurfaceHostBindings(surfaceHostBindings);
     const closureResult = await checkSkillResourceClosure({
       snapshotDir: manifest.outputDir,
       host: "root",
-      surfaceHostBindings
+      surfaceHostBindings: checkerBindings
     });
     const receipt = createSkillResourceClosureReceipt(closureResult, {
       unitId: unit.id,
@@ -129639,7 +129727,8 @@ async function runPrepareSkillResourceClosureGate({
     }
     const hostCoverage = evaluateDeclaredHostSurfaceCoverage(
       expectedHosts,
-      closureResult.surfaces
+      closureResult.surfaces,
+      coverageClaims
     );
     if (!hostCoverage.passed) {
       await evidence.append({
@@ -129663,7 +129752,7 @@ async function runPrepareSkillResourceClosureGate({
         }
       );
     }
-    for (const binding of surfaceHostBindings) {
+    for (const binding of coverageClaims) {
       const boundSurface = closureResult.surfaces.find(
         (surface) => surface.id === binding.surfaceId
       );
@@ -133273,10 +133362,11 @@ async function publishRelease(options) {
           });
           if (binding) surfaceHostBindings.push(binding);
         }
+        const { checkerBindings, coverageClaims } = groupSurfaceHostBindings(surfaceHostBindings);
         const closureResult = await checkSkillResourceClosure({
           snapshotDir,
           host: "root",
-          surfaceHostBindings
+          surfaceHostBindings: checkerBindings
         });
         if (closureResult.findings.length > 0) {
           await evidence.append({
@@ -133292,6 +133382,31 @@ async function publishRelease(options) {
             { unitId, findings: closureResult.findings }
           );
         }
+        const expectedHosts = [];
+        for (const distribution of frozenUnit?.distributions ?? []) {
+          const platform = PLATFORMS.find((item) => item.distributionType === distribution.type);
+          if (platform) expectedHosts.push(await normalizeHostId(platform.buildAdapter.name));
+        }
+        const hostCoverage = evaluateDeclaredHostSurfaceCoverage(
+          expectedHosts,
+          closureResult.surfaces,
+          coverageClaims
+        );
+        if (!hostCoverage.passed) {
+          await evidence.append({
+            phase: "safety-gate",
+            gate: "skill-resource-closure",
+            status: "failed",
+            unitId,
+            reason: "declared-host-surface-missing",
+            missingHosts: hostCoverage.missing
+          });
+          throw new ReleaseError(
+            GATE_FAILED,
+            `skill resource closure recheck failed for unit "${unitId}": declared host surface(s) missing or empty: ${hostCoverage.missing.map((item) => item.host).join(", ")}`,
+            { unitId, missingHosts: hostCoverage.missing }
+          );
+        }
         const observed = createSkillResourceClosureReceipt(closureResult, {
           unitId,
           preparedAt: expected.preparedAt ?? null,
@@ -145779,7 +145894,7 @@ guardOutputStream(process.stdout);
 guardOutputStream(process.stderr);
 registerPathRedactor(redactSensitivePaths);
 var execFile19 = promisify26(execFileCb22);
-var COMMANDS = /* @__PURE__ */ new Set(["help", "setup", "assess", "prepare", "approve", "publish", "reconcile", "verify", "ship", "post-release", "attest", "hooks", "artifacts", "docs", "distribute", "route", "lineage"]);
+var COMMANDS = /* @__PURE__ */ new Set(["help", "setup", "assess", "prepare", "approve", "publish", "reconcile", "verify", "postverify", "ship", "post-release", "attest", "hooks", "artifacts", "docs", "distribute", "route", "lineage"]);
 function flushOutputStream(stream) {
   if (!stream?.writable || stream.destroyed || stream.writableEnded || outputStreamStates.get(stream)?.failed) {
     return Promise.resolve();
@@ -145970,6 +146085,11 @@ function getCapabilityMaturity() {
       mode: "fresh consumer verification (protocol-tested; no OS/network sandbox)",
       description: "Recheck remote state, exact npm installation, CLI help, and automated Claude/Codex installs before VERIFIED; Kimi/CodeBuddy remain unverified manual follow-ups"
     },
+    postverify: {
+      available: true,
+      mode: "independent postVerify execution",
+      description: "Run approved postVerify hooks from a VERIFIED run in an independent run; never reads or writes ship state"
+    },
     distribute: {
       available: true,
       mode: "controlled production (protocol-tested; no OS/network sandbox)",
@@ -146003,6 +146123,7 @@ Commands:
   publish    Publish frozen GitHub/npm artifacts after approval
   reconcile  Resume PARTIAL state from evidence; conflicts require a human
   verify     Fresh remote and consumer verification; only this reaches VERIFIED
+  postverify Run approved postVerify hooks from a VERIFIED run in an independent run
   ship       Resume one durable prepare -> approve -> publish -> verify flow; completes a parked
              postVerify hook once its checkpoint approval is provided (--hook-approval)
   post-release Inspect optional local finishing work after VERIFIED; update installed host plugins
@@ -146017,10 +146138,10 @@ Commands:
 
 Options:
   --root <path>    Project root directory (default: cwd)
-  --plan <path>    Path to the release plan file
+  --plan <path>    Path to the release plan file (required for approve/publish/reconcile/verify/postverify)
   --run <path>     Path to the release run file, or a run directory whose release-run.json
-                   is resolved automatically (required for reconcile/verify)
-  --approval <path> Path to the approval record
+                   is resolved automatically (required for reconcile/verify/postverify)
+  --approval <path> Path to the release-level approval record (required for publish/postverify)
   --production     Prepare immutable Git/npm production artifacts
   --output <path>  Override prepare/approve output path (non-production only)
   --run-dir <path> Override prepare run directory; production requires one direct child of .release-skill/runs
@@ -146057,7 +146178,7 @@ Options:
   --install-path <path> Actual managed plugin path when closure verification requires it
   --install-channel <desktop|cli> CodeBuddy installation channel when required
   --approve         Approve the ship plan (boolean; plan digest is auto-resolved)
-  --hook-approval <path> Checkpoint approval for a requiresApproval postPublish hook (ship/distribute; repeatable)
+  --hook-approval <path> Checkpoint approval for one requiresApproval hook (ship/distribute/postverify; repeatable)
   --state <path>    Override the durable ship state file
   --update-local-hosts Update installed plugins for selected local hosts after VERIFIED
   --hosts <ids>     Comma-separated local hosts for post-release update. No local host is updated unless --hosts contains at least one id
@@ -147076,6 +147197,117 @@ if (command === "verify") {
     await exitAfterFlush(err.exitCode ?? 1);
   }
 }
+if (command === "postverify") {
+  if (args.includes("--help") || args.includes("-h")) {
+    const helpText = `release-skill postverify - Run approved postVerify hooks from a VERIFIED run
+
+Usage:
+  release-skill postverify [--root <path>] --plan <path> --approval <path> --run <path> [options]
+
+Required options:
+  --plan <path>             Path to the release plan file
+  --approval <path>         Path to the release-level approval record
+  --run <path>              Path to the VERIFIED verify run file or directory
+
+Optional options:
+  --root <path>             Project root directory (default: cwd)
+  --hook-approval <path>    Checkpoint approval for a requiresApproval postVerify hook (repeatable)
+  --json                    Output results as JSON
+  -h, --help                Show this help message and exit
+
+This command creates an independent postVerify run and never reads or writes ship state.`;
+    if (hasJson) {
+      console.log(JSON.stringify({
+        command: "postverify",
+        status: "HELP",
+        usage: "release-skill postverify [--root <path>] --plan <path> --approval <path> --run <path> [options]",
+        options: {
+          "--root": "Project root directory (default: cwd)",
+          "--plan": "Path to the release plan file (required)",
+          "--approval": "Path to the release-level approval record (required)",
+          "--run": "Path to the VERIFIED verify run file or directory (required)",
+          "--hook-approval": "Checkpoint approval for a requiresApproval postVerify hook (repeatable)",
+          "--json": "Output results as JSON",
+          "-h, --help": "Show this help message and exit"
+        },
+        message: "Creates an independent postVerify run and never reads or writes ship state."
+      }, null, 2));
+    } else {
+      console.log(helpText);
+    }
+    await exitAfterFlush(0);
+  }
+  let malformedValuedFlag;
+  const value = /* @__PURE__ */ __name((flag) => {
+    let firstValue;
+    for (let i = 0; i < args.length; i += 1) {
+      if (args[i] !== flag) continue;
+      const next = args[i + 1];
+      if (!next || next.startsWith("-")) {
+        malformedValuedFlag ??= flag;
+        continue;
+      }
+      firstValue ??= next;
+    }
+    return firstValue;
+  }, "value");
+  const root = resolve41(value("--root") ?? process.cwd());
+  const planPath = value("--plan");
+  const approvalPath = value("--approval");
+  const runPath = value("--run");
+  const postpublishApprovalPaths = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--hook-approval") {
+      const next = args[i + 1];
+      if (!next || next.startsWith("-")) {
+        malformedValuedFlag ??= "--hook-approval";
+      } else {
+        postpublishApprovalPaths.push(resolve41(next));
+      }
+    }
+  }
+  if (malformedValuedFlag || !planPath || !approvalPath || !runPath) {
+    const msg = "postverify requires --plan <path>, --approval <path>, and --run <path>";
+    if (hasJson) {
+      console.log(JSON.stringify({ error: MISSING_PARAMETERS, message: msg, exitCode: EXIT_CODE_MAP[MISSING_PARAMETERS] }));
+    } else {
+      console.error(`Error: ${msg}`);
+    }
+    await exitAfterFlush(EXIT_CODE_MAP[MISSING_PARAMETERS]);
+  }
+  try {
+    const { postVerifyRelease: postVerifyRelease2 } = await init_postverify().then(() => postverify_exports);
+    const result2 = await postVerifyRelease2({
+      planPath: resolve41(planPath),
+      approvalPath: resolve41(approvalPath),
+      sourceRunPath: resolve41(runPath),
+      root,
+      ...postpublishApprovalPaths.length > 0 ? { postpublishApprovalPaths } : {}
+    });
+    if (hasJson) {
+      console.log(JSON.stringify(result2, null, 2));
+    } else {
+      console.log(`PostVerify status: ${result2.status}`);
+      for (const cp4 of result2.checkpoints ?? []) {
+        console.log(`  ${cp4.actionId}: ${cp4.status}`);
+      }
+      if (result2.runPath) console.log(`PostVerify run: ${result2.runPath}`);
+    }
+    await exitAfterFlush(result2.status === "DISTRIBUTED" ? 0 : 1);
+  } catch (err) {
+    if (hasJson) {
+      console.log(JSON.stringify({
+        error: err.code ?? "UNKNOWN_ERROR",
+        message: err.message,
+        details: err.details ?? {},
+        exitCode: err.exitCode ?? 1
+      }));
+    } else {
+      console.error(`Error: ${err.message}`);
+    }
+    await exitAfterFlush(err.exitCode ?? 1);
+  }
+}
 if (command === "publish") {
   const rootIdx = args.indexOf("--root");
   const rawRoot = rootIdx !== -1 && args[rootIdx + 1] ? args[rootIdx + 1] : process.cwd();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-skill",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "Safe preparation and frozen GitHub/npm production publishing with full happy end verification",
   "author": {
     "name": "广州市风荷科技有限公司"

package/platform-manifest.json

@@ -2,11 +2,11 @@
   "schemaVersion": "1.0.0",
   "platformId": "release-skill",
   "platformName": "release-skill Plugin Platform",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "logicalRoot": "skills-src/",
-  "logicalRootDigest": "3ead4305d76f86d100ca328e5051fceea9adc9fd308f2658b1bc24642b6af302",
-  "projectionDigest": "811660beafb951a5c2121128f3b142caf3dbe1fcf92a59183e6528983a5abfe8",
-  "projectionId": "release-skill:platform:0.9.5",
+  "logicalRootDigest": "4338c7c5a7efd38ca372049526e5bdd198087491f76702cd21d491741bfad835",
+  "projectionDigest": "c4d40afd481d78907d51ef9be1dc2238834d566b9a9792f1d25da19f57368d7d",
+  "projectionId": "release-skill:platform:0.9.7",
   "manifestRequired": true,
   "projectionSources": {
     "skills-src-root": {