release-skill 0.9.17 → 0.9.19

package/src/commands/post-release-local.mjs

@@ -1,12 +1,19 @@
-import { access, readFile } from 'node:fs/promises';
+import { access, readFile, mkdir, mkdtemp, cp, rename, rm, lstat, realpath, chmod } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { join, relative } from 'node:path';
+import { join, relative, isAbsolute, normalize } from 'node:path';
 
 import {
   readFileContained,
+  readFileStrict,
   resolveContained,
   superviseProcess,
   withTemporaryWorkspace,
+  createTemporaryWorkspace,
+  createFilesystemRootBinding,
+  observeFilesystemTree,
+  createFixedSetPublicationManifest,
+  publishFixedSet,
+  replaceFixedSetAtomic,
 } from 'skill-family-harness-node';
 
 import { getPlatform } from '../platforms/registry.mjs';
@@ -45,10 +52,11 @@ const QODER_PLUGIN_LIST_ARGS = Object.freeze(['plugins', 'list', '--json']);
 const QODER_MARKETPLACE_LIST_ARGS = Object.freeze(['plugins', 'marketplace', 'list', '--json']);
 const QODER_PAYLOAD_CONTRACT = 'external-marketplace-v1';
 
-function attachFoundationFailure(error, { envelope, stdout }) {
+function attachFoundationFailure(error, { envelope, stdout, stderr }) {
   Object.defineProperties(error, {
     foundationEnvelope: { value: envelope, enumerable: false },
     foundationStdout: { value: stdout, enumerable: false },
+    foundationStderr: { value: stderr, enumerable: false },
   });
   return error;
 }
@@ -177,6 +185,17 @@ function hubTargets(plan) {
       workbuddy: 'Handle manually; WorkBuddy cannot pin a Hub ref in this flow (it follows the CodeBuddy manual boundary).',
     };
     return local.hosts.map((host) => {
+      if (host === 'cursor') {
+        return {
+          targetKind: 'cursor-local', executionMode: 'executable',
+          unitId: declaration.unitId, host, plugin: local.plugin,
+          version: unit?.targetVersion,
+          snapshotPath: unit?.frozenSnapshot?.path,
+          manifestDigest: unit?.frozenSnapshot?.manifestDigest,
+          cursor: local.cursor, timeoutMs: 300_000,
+          message: `Install or replace the complete frozen ${local.plugin} Cursor Local plugin; quit Cursor first and restart it afterwards.`,
+        };
+      }
       if (host === 'qoder') {
         return {
           targetKind: 'hub-backed',
@@ -202,6 +221,7 @@ function hubTargets(plan) {
         unitId: declaration.unitId,
         host,
         plugin: local.plugin,
+        version: unit?.targetVersion,
         hub,
         message: `${manualInstruction[host]} Install or upgrade ${local.plugin} from Hub ${hub.name}; release-skill does not execute or probe this action.`,
         ...(unit?.publicRepo ? { publicRepo: unit.publicRepo } : {}),
@@ -296,9 +316,23 @@ function buildShipNextStep({ root, statePath, unitIds }) {
   };
 }
 
+function buildFinishCommand({ root, planPath, runPath }) {
+  if (![root, planPath, runPath].every((value) => typeof value === 'string' && value.length > 0)) return undefined;
+  return {
+    argv: [
+      'release-skill', 'post-release',
+      '--root', root,
+      '--plan', planPath,
+      '--run', runPath,
+      '--finish',
+    ],
+  };
+}
+
 export function derivePostReleaseChecklist(plan, {
   runPath,
   root,
+  planPath,
   statePath,
   unitIds,
   postVerifyComplete = false,
@@ -320,10 +354,12 @@ export function derivePostReleaseChecklist(plan, {
   const hasPendingPostVerify = postVerifyHooks(plan).length > 0 && !postVerifyComplete && targets.length > 0;
   const hasStatePath = typeof statePath === 'string' && statePath.length > 0;
   const selectedUnitIds = Array.isArray(unitIds) ? unitIds : undefined;
+  const finishCommand = hasPendingPostVerify ? undefined : buildFinishCommand({ root, planPath, runPath });
   return {
     command: 'post-release',
     status: 'AWAITING_USER_DECISION',
     planDigest: plan.digest,
+    ...(finishCommand ? { finishCommand } : {}),
     merge: {
       promptRequired: uncovered.length > 0,
       alreadyHandledByRelease: uncovered.length === 0,
@@ -574,12 +610,14 @@ async function defaultRun(command, args, options = {}) {
         watchdogReason: envelope.watchdogReason,
         ...(envelope.evidence?.spawnError ? { spawnError: envelope.evidence.spawnError } : {}),
       };
-      throw attachFoundationFailure(error, { envelope, stdout });
+      throw attachFoundationFailure(error, { envelope, stdout, stderr });
     }
     return { stdout, stderr };
   }, { prefix: 'release-skill-host-command-' });
 }
 
+export { defaultRun as runLocalFinishCommand };
+
 async function commandAvailable(command, host, run) {
   try {
     await run(command, ['--version'], { timeout: 10_000, env: hostEnvironment(host) });
@@ -1388,49 +1426,120 @@ proc unexpectedDirectoryTrust {} {
   exit 147
 }
 
-proc confirmInitialDirectoryTrust {} {
-  global expect_out promptPattern
-  set dialogBuffer $expect_out(buffer)
-  expect {
-    -nocase -re {❯[^\\r\\n]*No,[ \\t]*exit} {
-      append dialogBuffer $expect_out(buffer)
+proc readDirectoryTrustDialog {prefix state timeoutCode unknownCode eofCode} {
+  global expect_out
+  set dialogBuffer $prefix
+  set cleanedPrefix [cleanScreen $dialogBuffer]
+  if {![regexp -nocase {Trust this folder\\?} $cleanedPrefix]} {
+    expect {
+      -nocase -re {Trust this folder\\?} {
+        append dialogBuffer $expect_out(buffer)
+      }
+      timeout { failTimeout $state $timeoutCode $unknownCode }
+      eof { failEof $state $eofCode }
     }
-    -re {❯[^\\r\\n]*\\r*\\n} {
-      puts stderr "KIMI_TUI_STATE:directory-trust:selection-unknown"
-      exit 143
+    set cleanedPrefix [cleanScreen $dialogBuffer]
+  }
+  set framed [regexp -nocase {(^|\\n)[ \\t]*─{8,}[ \\t]*\\n[ \\t]*Trust this folder\\?} $cleanedPrefix]
+  if {$framed} {
+    expect {
+      -re {(^|\\r|\\n)[ \\t]*─{8,}[ \\t]*\\r*\\n} {
+        append dialogBuffer $expect_out(buffer)
+      }
+      timeout { failTimeout $state $timeoutCode $unknownCode }
+      eof { failEof $state $eofCode }
     }
-    timeout {
-      puts stderr "KIMI_TUI_STATE:directory-trust-selected-row:timeout"
-      exit 140
+  } else {
+    expect {
+      -nocase -re {↑↓[^\\r\\n]*navigate[^\\r\\n]*(?:Esc[^\\r\\n]*)?\\r*\\n} {
+        append dialogBuffer $expect_out(buffer)
+      }
+      timeout { failTimeout $state $timeoutCode $unknownCode }
+      eof { failEof $state $eofCode }
     }
-    eof { failEof directory-trust-selected-row 141 }
   }
-  expect {
-    -nocase -re {(?:^|\\r|\\n)[ \\t]+Trust this folder[ \\t]*\\r*\\n} {
-      append dialogBuffer $expect_out(buffer)
+  return [cleanScreen $dialogBuffer]
+}
+
+proc directoryTrustAction {dialog state unknownCode} {
+  set inDialog 0
+  set labels {}
+  set selectedCount 0
+  set selectedIndex -1
+  set selectedLabel ""
+  set trustCount 0
+  set trustIndex -1
+  foreach rawLine [split $dialog "\\n"] {
+    set line [string trim $rawLine]
+    if {[regexp -nocase {^Trust this folder\\?$} $line]} {
+      set inDialog 1
+      continue
+    }
+    if {!$inDialog} { continue }
+    if {$line eq ""} { continue }
+    set selected [regexp {^❯[ \\t]*} $line]
+    if {$selected} {
+      regsub {^❯[ \\t]*} $line {} label
+      set label [string trim $label]
+    } else {
+      set label $line
     }
-    -re {(?:^|\\r|\\n)[^\\r\\n]*\\r*\\n} {
-      puts stderr "KIMI_TUI_STATE:directory-trust:selection-unknown"
-      exit 143
+    set knownAction [expr {
+      [string equal -nocase $label "Trust this folder"]
+      || [string equal -nocase $label "No, exit"]
+      || [string equal -nocase $label "Don't trust"]
+    }]
+    if {!$knownAction && $selected} {
+      puts stderr "KIMI_TUI_STATE:$state:selection-unknown"
+      exit $unknownCode
+    }
+    if {!$knownAction} { continue }
+    set index [llength $labels]
+    lappend labels $label
+    if {[string equal -nocase $label "Trust this folder"]} {
+      incr trustCount
+      set trustIndex $index
+    }
+    if {$selected} {
+      incr selectedCount
+      set selectedIndex $index
+      set selectedLabel $label
     }
-    timeout { failTimeout directory-trust-target-row 148 150 }
-    eof { failEof directory-trust-target-row 149 }
   }
-  set dialog [cleanScreen $dialogBuffer]
-  if {![regexp -nocase {(^|\\n)[^\\n]*❯[^\\n]*No,[ \\t]*exit} $dialog]
-      || ![regexp -nocase {(^|\\n)[ \\t]+Trust this folder[ \\t]*($|\\n)} $dialog]} {
-    puts stderr "KIMI_TUI_STATE:directory-trust:selection-unknown"
-    exit 143
+  if {[llength $labels] != 2 || $trustCount != 1 || $selectedCount != 1} {
+    puts stderr "KIMI_TUI_STATE:$state:selection-unknown"
+    exit $unknownCode
   }
-  send -- "\\033\\[B"
-  expect {
-    -nocase -re {❯[^\\r\\n]*Trust this folder} {}
-    -re {❯[^\\r\\n]*\\r*\\n} {
+  if {[string equal -nocase $selectedLabel "Trust this folder"]} {
+    return selected-trust
+  }
+  if {![string equal -nocase $selectedLabel "No, exit"]
+      && ![string equal -nocase $selectedLabel "Don't trust"]} {
+    puts stderr "KIMI_TUI_STATE:$state:selection-unknown"
+    exit $unknownCode
+  }
+  if {$selectedIndex + 1 == $trustIndex} { return move-down }
+  if {$selectedIndex - 1 == $trustIndex} { return move-up }
+  puts stderr "KIMI_TUI_STATE:$state:selection-unknown"
+  exit $unknownCode
+}
+
+proc confirmInitialDirectoryTrust {} {
+  global expect_out promptPattern
+  set dialog [readDirectoryTrustDialog $expect_out(buffer) directory-trust-selected-row 140 143 141]
+  set action [directoryTrustAction $dialog directory-trust 143]
+  if {$action eq "move-down"} {
+    send -- "\\033\\[B"
+  } elseif {$action eq "move-up"} {
+    send -- "\\033\\[A"
+  }
+  if {$action ne "selected-trust"} {
+    set confirmedDialog [readDirectoryTrustDialog "" directory-trust-confirm-selection 144 146 145]
+    set confirmedAction [directoryTrustAction $confirmedDialog directory-trust-confirm-selection 146]
+    if {$confirmedAction ne "selected-trust"} {
       puts stderr "KIMI_TUI_STATE:directory-trust-confirm-selection:unknown"
       exit 146
     }
-    timeout { failTimeout directory-trust-confirm-selection 144 146 }
-    eof { failEof directory-trust-confirm-selection 145 }
   }
   send -- "\\033\\[13u"
   expect {
@@ -1679,6 +1788,160 @@ async function runKimiUpdate(target, detected, run, kimiHome, {
   return { status: 'UPDATED', version: target.version, restartRequired: true };
 }
 
+async function observeCursorClosure(root) {
+  return observeFilesystemTree({ root, rootBinding: await createFilesystemRootBinding(root) });
+}
+
+async function cursorMainProcessRunning(run) {
+  const result = await run('/bin/ps', ['-axo', 'comm='], { timeout: 30_000 });
+  if (typeof result?.stdout !== 'string' || result.stdout.trim().length === 0) throw new Error('Cursor process observation is unavailable');
+  return result.stdout.split('\n').some((line) => /(?:^|\/)Cursor$/u.test(line.trim()));
+}
+
+async function runCursorLocalUpdate(target, {
+  root, run, cursorPluginsRoot, cursorPlatform = process.platform,
+  cursorIsRunning = () => cursorMainProcessRunning(run),
+  cursorPublication = { publishFixedSet, replaceFixedSetAtomic },
+  cursorMoveBackup = rename,
+}) {
+  const frozen = await verifyFrozenSnapshot({ root, snapshotPath: target.snapshotPath, expectedDigest: target.manifestDigest });
+  if (!target.cursor?.sourcePath) throw new Error('Cursor local update requires a frozen cursor.sourcePath');
+  if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/u.test(target.plugin)) throw new Error('Cursor plugin identity must use a valid Cursor plugin name');
+  const source = await resolveContained(frozen.snapshotDir, target.cursor.sourcePath);
+  const identity = JSON.parse(await readFileContained(source, '.cursor-plugin/plugin.json', { encoding: 'utf8' }));
+  if (typeof identity.name !== 'string' || !/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/u.test(identity.name)
+    || identity.name !== target.plugin || identity.version !== target.version) throw new Error('Cursor frozen plugin manifest identity conflicts with the release unit');
+  if (typeof cursorPluginsRoot !== 'string' || !isAbsolute(cursorPluginsRoot) || normalize(cursorPluginsRoot) !== cursorPluginsRoot) {
+    throw new Error('Cursor local update requires --cursor-plugins-root <normalized-absolute-directory>');
+  }
+  if (cursorPlatform !== 'darwin') return { status: 'MANUAL_REQUIRED', reason: 'Cursor Local automatic installation currently supports macOS only' };
+  try {
+    if (await cursorIsRunning() !== false) return { status: 'MANUAL_REQUIRED', reason: 'Quit the Cursor main process before updating Local plugins' };
+  } catch (cause) {
+    return { status: 'MANUAL_REQUIRED', reason: `Cannot confirm Cursor has exited: ${cause.message}` };
+  }
+  // Bind the caller-selected root before creating any staging directory.
+  await createFilesystemRootBinding(cursorPluginsRoot);
+  const pluginsRoot = await realpath(cursorPluginsRoot);
+  const sourceObservation = await observeCursorClosure(source);
+  const workspace = await createTemporaryWorkspace({ prefix: 'release-skill-cursor-local-' });
+  let sibling;
+  let preserve = false;
+  try {
+    const candidate = join(workspace.root, 'plugin');
+    await cp(source, candidate, { recursive: true, errorOnExist: true, force: false });
+    if ((await observeCursorClosure(candidate)).membersDigest !== sourceObservation.membersDigest) throw new Error('Cursor candidate differs from the frozen source closure');
+    await chmod(candidate, 0o700);
+    if (target.cursor.dependencyInstall !== undefined) {
+      if (target.cursor.dependencyInstall !== 'npm-ci-ignore-scripts') throw new Error('Unsupported Cursor dependency installation policy');
+      await run('npm', ['ci', '--ignore-scripts', '--prefix', candidate], {
+        cwd: candidate, timeout: target.timeoutMs, env: hostEnvironment('cursor'),
+      });
+      // npm may add dependencies, but must not mutate the frozen plugin inputs.
+      for (const member of sourceObservation.members.filter((entry) => entry.type === 'file')) {
+        await readFileStrict(candidate, member.path, { expectedSha256: member.sha256 });
+      }
+    }
+    const prepared = await observeCursorClosure(candidate);
+    await verifyFrozenSnapshot({ root, snapshotPath: target.snapshotPath, expectedDigest: target.manifestDigest });
+    try {
+      if (await cursorIsRunning() !== false) return { status: 'MANUAL_REQUIRED', reason: 'Cursor started while preparing the plugin; quit Cursor and rerun the update' };
+    } catch (cause) {
+      return { status: 'MANUAL_REQUIRED', reason: `Cannot confirm Cursor has exited before publication: ${cause.message}` };
+    }
+    const local = await resolveContained(pluginsRoot, 'local');
+    await mkdir(local, { recursive: true });
+    await createFilesystemRootBinding(local);
+    const targetPath = await resolveContained(local, target.plugin);
+    let installed = false;
+    let previousClosure;
+    try {
+      await lstat(targetPath);
+      installed = true;
+    } catch (cause) { if (cause.code !== 'ENOENT') throw cause; }
+    if (installed) {
+      const current = JSON.parse(await readFileContained(targetPath, '.cursor-plugin/plugin.json', { encoding: 'utf8' }));
+      if (current.name !== target.plugin || typeof current.version !== 'string') throw new Error('Cursor installed plugin manifest identity conflicts with the frozen plugin');
+      const observed = await observeCursorClosure(targetPath);
+      previousClosure = observed.membersDigest;
+      if (current.version === target.version && observed.membersDigest === prepared.membersDigest) return { status: 'ALREADY_CURRENT', version: target.version, installPath: targetPath };
+    }
+    // Cursor is closed, so this same-parent candidate cannot be discovered by
+    // a live scanner. Only this uniquely-created directory may be cleaned.
+    sibling = await mkdtemp(join(local, `.${target.plugin}-stage-`));
+    await cp(candidate, sibling, { recursive: true, errorOnExist: false, force: false });
+    if ((await observeCursorClosure(sibling)).membersDigest !== prepared.membersDigest) throw new Error('Cursor publication candidate closure drift');
+    const publication = { sourceRoot: sibling, targetParent: local, targetSegment: target.plugin };
+    let backupPath;
+    if (installed) {
+      try {
+        await cursorPublication.replaceFixedSetAtomic(publication);
+      } catch (cause) {
+        preserve = cause.details?.phase === 'post-commit' || cause.details?.publicationState === 'indeterminate' || cause.details?.commitState === 'indeterminate';
+        throw cause;
+      }
+      // Foundation has proved the exchanged mapping. The old complete plugin
+      // is now owned by the user and must leave the Local scanner namespace.
+      preserve = true;
+      try {
+        const backups = await resolveContained(pluginsRoot, `backups/${target.plugin}`);
+        await mkdir(backups, { recursive: true });
+        await createFilesystemRootBinding(backups);
+        const backupDirectory = await mkdtemp(join(backups, 'release-'));
+        backupPath = join(backupDirectory, 'plugin');
+        await cursorMoveBackup(sibling, backupPath);
+        sibling = undefined;
+        preserve = false;
+      } catch (cause) {
+        // One explicit reverse exchange is justified only by the verified
+        // success above and an old directory still at the displaced path.
+        if ((await observeCursorClosure(sibling)).membersDigest !== previousClosure
+          || (await observeCursorClosure(targetPath)).membersDigest !== prepared.membersDigest) throw cause;
+        await cursorPublication.replaceFixedSetAtomic(publication);
+        preserve = false;
+        throw new Error(`Cursor backup move failed; original plugin restored: ${cause.message}`);
+      }
+    } else {
+      const manifest = await createFixedSetPublicationManifest(publication);
+      const receipt = await cursorPublication.publishFixedSet({ ...publication, manifest });
+      if (receipt.status !== 'succeeded') {
+        preserve = receipt.status === 'indeterminate' || receipt.commitState !== 'not-committed';
+        const error = new Error(`Cursor publication failed: ${receipt.error?.message ?? receipt.status}`);
+        error.details = receipt;
+        throw error;
+      }
+      sibling = undefined;
+    }
+    if ((await observeCursorClosure(targetPath)).membersDigest !== prepared.membersDigest) throw new Error('Cursor installed plugin closure drift after publication');
+    return {
+      status: 'UPDATED', version: target.version, installPath: targetPath,
+      ...(backupPath ? { backupPath } : {}), restartRequired: true,
+      reloadInstruction: 'Restart Cursor or run Reload Window, then verify the Local source, version and Skill invocation.',
+    };
+  } catch (error) {
+    if (preserve) error.details = { ...error.details, candidatePath: sibling, workspacePath: workspace.root, manualAction: 'Keep both directories intact; inspect the Cursor Local publication mapping before retrying.' };
+    throw error;
+  } finally {
+    if (!preserve) {
+      // Sealed snapshots carry read-only directories. Restore owner access
+      // only in this invocation's disposable copies before Foundation cleanup.
+      for (const cleanupRoot of [sibling, workspace.root].filter(Boolean)) {
+        const closure = await observeFilesystemTree({
+          root: cleanupRoot,
+          rootBinding: await createFilesystemRootBinding(cleanupRoot),
+          symlinkPolicy: { mode: 'record' },
+        });
+        await chmod(cleanupRoot, 0o700);
+        for (const member of closure.members.filter((entry) => entry.type === 'directory')) {
+          await chmod(await resolveContained(cleanupRoot, member.path), member.statMode | 0o700);
+        }
+      }
+      if (sibling) await rm(sibling, { recursive: true, force: false });
+      await workspace.dispose();
+    }
+  }
+}
+
 function aggregateStatus(results) {
   const statuses = new Set(results.map((entry) => entry.status));
   const completed = results.some((entry) => ['UPDATED', 'ALREADY_CURRENT'].includes(entry.status));
@@ -1718,6 +1981,11 @@ async function updateLocalHostPluginsInternal({
   detect = (host) => defaultDetect(host, defaultRun),
   run = defaultRun,
   kimiHome,
+  cursorPluginsRoot,
+  cursorPlatform,
+  cursorIsRunning,
+  cursorPublication,
+  cursorMoveBackup,
   verifyInstalledPayload = verifyInstalledMarketplacePayload,
 } = {}) {
   const effectiveKimiHome = kimiHome ?? process.env.KIMI_CODE_HOME ?? join(homedir(), '.kimi-code');
@@ -1732,6 +2000,7 @@ async function updateLocalHostPluginsInternal({
     item.executionMode !== 'manual' && selected.has(item.host)
   ));
   for (const target of targets) {
+    if (target.host === 'cursor') continue;
     if (target.host === 'qoder') assertQoderExecutableTarget(target);
     else assertExecutableTarget(target);
   }
@@ -1739,6 +2008,13 @@ async function updateLocalHostPluginsInternal({
   const results = [];
   for (const target of targets) {
     try {
+      if (target.host === 'cursor') {
+        const outcome = await runCursorLocalUpdate(target, {
+          root, run, cursorPluginsRoot, cursorPlatform, cursorIsRunning, cursorPublication, cursorMoveBackup,
+        });
+        results.push({ host: target.host, unitId: target.unitId, ...outcome });
+        continue;
+      }
       const detected = await detect(target.host);
       if (!detected?.available) {
         results.push({

package/src/commands/prepare.mjs

@@ -25,7 +25,7 @@ import { promisify } from 'node:util';
 
 const execFile = promisify(execFileCb);
 
-import { classifyPathInput, writeFileAtomic, withTemporaryWorkspace } from 'skill-family-harness-node';
+import { classifyPathInput, writeFileAtomic, withTemporaryWorkspace, resolveContained, readFileStrict } from 'skill-family-harness-node';
 import { loadProjectConfig } from '../core/config.mjs';
 import { captureBaseline } from '../core/baseline.mjs';
 import { runHook } from '../core/hooks.mjs';
@@ -63,6 +63,7 @@ import {
   assertSelfBootstrapFacts,
 } from '../core/derived-artifact-gates.mjs';
 import { isFoundationPluginVerificationEligible } from '../core/foundation-plugin-verification.mjs';
+import { assertCursorHostScenario } from '../core/foundation-host-verification.mjs';
 import { PKG_ROOT } from '../core/pkg-root.mjs';
 import { writeFrozenMarker, FROZEN_MARKER_FILENAME } from '../core/frozen-marker.mjs';
 import {
@@ -897,12 +898,21 @@ async function processSnapshots(config, root, evidence, runDir, production = fal
 }
 
 /** Validate Hub-backed plugin identities against the already frozen snapshot. */
-async function validateFrozenLocalHostUpdatePlugins(unitResults) {
-  for (const { unit, manifest } of unitResults) {
+async function validateFrozenLocalHostUpdatePlugins(unitResults, resolvedVersions) {
+  for (const [index, { unit, manifest }] of unitResults.entries()) {
     const declaration = unit.postPublish?.localHostUpdate;
     if (!declaration) continue;
+    if (declaration.hosts.includes('cursor')) {
+      const source = await resolveContained(manifest.outputDir, declaration.cursor.sourcePath);
+      const receipt = await readFileStrict(source, '.cursor-plugin/plugin.json', { encoding: 'utf8' });
+      const cursor = JSON.parse(receipt.content);
+      if (typeof cursor.name !== 'string' || !/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/u.test(cursor.name)
+        || cursor.name !== declaration.plugin || cursor.version !== resolvedVersions[index]) {
+        throw new ReleaseError(GATE_FAILED, `unit "${unit.id}" Cursor local plugin manifest must match the frozen plugin name and target version`);
+      }
+    }
     const manifestEntries = (manifest.entries ?? [])
-      .filter((entry) => /(?:^|\/)\.(?:claude|codex|kimi|codebuddy)-plugin\/plugin\.json$/u.test(entry.path));
+      .filter((entry) => /(?:^|\/)\.(?:claude|codex|kimi|codebuddy|qoder|cursor)-plugin\/plugin\.json$/u.test(entry.path));
     const identities = new Set();
     for (const entry of manifestEntries) {
       try {
@@ -1884,6 +1894,7 @@ export function buildExternalActions(unitResults, resolvedVersions, productionAs
       // Undeclared stays absent so legacy frozen plans remain byte-identical.
       const frozenUnitDists = frozenDistributions?.get(unit.id) ?? null;
       for (const platform of PLATFORMS) {
+        if (platform.actionType === null) continue;
         const dist = frozenUnitDists
           ? frozenUnitDists.find((d) => d.type === platform.distributionType)
           : (unit.distributions ?? []).find((d) => d.type === platform.distributionType);
@@ -1896,6 +1907,10 @@ export function buildExternalActions(unitResults, resolvedVersions, productionAs
         // but no frozen ref/marketplaceCommitSha (production-only bindings),
         // keeping the two loops' shapes aligned for plan completeness.
         const externalMarketplace = dist.marketplaceRepo !== undefined && dist.marketplaceRepo !== null;
+        const marketplaceSource = dist.marketplaceSource
+          ?? (platform.id === 'qoder' && externalMarketplace
+            ? `https://github.com/${dist.marketplaceRepo}.git`
+            : undefined);
         // Normalized marketplace form: explicit mutually exclusive declaration.
         // bundled-family: marketplace and plugin live in the same repo.
         // standalone-index: external marketplace repo indexes a separate plugin repo.
@@ -1937,7 +1952,7 @@ export function buildExternalActions(unitResults, resolvedVersions, productionAs
             consumer: platform.id,
             plugin: dist.plugin,
             ...(dist.marketplace !== undefined ? { marketplace: dist.marketplace } : {}),
-            ...(dist.marketplaceSource !== undefined ? { marketplaceSource: dist.marketplaceSource } : {}),
+            ...(marketplaceSource !== undefined ? { marketplaceSource } : {}),
             repo: externalMarketplace ? dist.marketplaceRepo : unit.publicRepo,
             version,
             entrySkill: dist.entrySkill,
@@ -1965,7 +1980,7 @@ export function buildExternalActions(unitResults, resolvedVersions, productionAs
             installed: true,
             plugin: dist.plugin,
             ...(dist.marketplace !== undefined ? { marketplace: dist.marketplace } : {}),
-            ...(dist.marketplaceSource !== undefined ? { marketplaceSource: dist.marketplaceSource } : {}),
+            ...(marketplaceSource !== undefined ? { marketplaceSource } : {}),
             version,
             entrySkill: dist.entrySkill,
             ...(externalMarketplace ? { marketplaceLocation: 'external', repo: dist.marketplaceRepo } : {}),
@@ -2127,6 +2142,7 @@ export function buildExternalActions(unitResults, resolvedVersions, productionAs
     // entrySkillFound/manifestDigest expected). Marketplace identity follows
     // the distribution declaration, same as the non-production loop.
     for (const platform of PLATFORMS) {
+      if (platform.actionType === null) continue;
       const dist = frozenUnitDists
         ? frozenUnitDists.find((d) => d.type === platform.distributionType)
         : (unit.distributions ?? []).find((d) => d.type === platform.distributionType);
@@ -2143,6 +2159,10 @@ export function buildExternalActions(unitResults, resolvedVersions, productionAs
       // bind this unit's own frozen snapshot — the payload authority is the unit
       // snapshot, unchanged. Inline form (no marketplaceRepo) is byte-identical.
       const externalMarketplace = dist.marketplaceRepo !== undefined && dist.marketplaceRepo !== null;
+      const marketplaceSource = dist.marketplaceSource
+        ?? (platform.id === 'qoder' && externalMarketplace
+          ? `https://github.com/${dist.marketplaceRepo}.git`
+          : undefined);
       const freeze = externalMarketplace ? externalFreezes.get(`${unit.id} ${dist.type}`) : null;
       // Normalized marketplace form: explicit mutually exclusive declaration.
       // All four platforms carry marketplaceForm and sourceDescriptor.
@@ -2181,7 +2201,7 @@ export function buildExternalActions(unitResults, resolvedVersions, productionAs
           consumer: platform.id,
           plugin: dist.plugin,
           ...(dist.marketplace !== undefined ? { marketplace: dist.marketplace } : {}),
-          ...(dist.marketplaceSource !== undefined ? { marketplaceSource: dist.marketplaceSource } : {}),
+          ...(marketplaceSource !== undefined ? { marketplaceSource } : {}),
           repo: externalMarketplace ? dist.marketplaceRepo : unit.publicRepo,
           ref: externalMarketplace ? freeze.ref : resolvedTag,
           version: unitVersion,
@@ -2225,7 +2245,7 @@ export function buildExternalActions(unitResults, resolvedVersions, productionAs
           consumer: platform.id,
           plugin: dist.plugin,
           ...(dist.marketplace !== undefined ? { marketplace: dist.marketplace } : {}),
-          ...(dist.marketplaceSource !== undefined ? { marketplaceSource: dist.marketplaceSource } : {}),
+          ...(marketplaceSource !== undefined ? { marketplaceSource } : {}),
           repo: externalMarketplace ? dist.marketplaceRepo : unit.publicRepo,
           version: unitVersion,
           ref: externalMarketplace ? freeze.ref : resolvedTag,
@@ -2613,6 +2633,35 @@ async function resolveDistributionManifestFacts(unitResults, resolvedVersions) {
       if (!platform || dist.type === 'npm') continue;
       const key = `${unit.id} ${dist.type}`;
 
+      if (platform.installMethod === 'foundation-host-verification') {
+        assertCursorHostScenario(dist.hostVerification);
+        const entrySkillPath = resolve(snapshotDir, 'skills', dist.entrySkill, 'SKILL.md');
+        let entrySkillStat;
+        try {
+          entrySkillStat = await lstat(entrySkillPath);
+        } catch (err) {
+          throw new ReleaseError(
+            GATE_FAILED,
+            `unit "${unit.id}" ${dist.type} entry skill "${dist.entrySkill}" is absent from the frozen payload`,
+            { unitId: unit.id, distributionType: dist.type, cause: err.code },
+          );
+        }
+        if (!entrySkillStat.isFile() || entrySkillStat.isSymbolicLink()) {
+          throw new ReleaseError(
+            GATE_FAILED,
+            `unit "${unit.id}" ${dist.type} entry skill must be a regular non-symlink SKILL.md`,
+            { unitId: unit.id, distributionType: dist.type },
+          );
+        }
+        distributionFacts.set(key, {
+          kind: 'host-verification',
+          platform,
+          entrySkill: dist.entrySkill,
+          entrySkillRelativePath: `skills/${dist.entrySkill}/SKILL.md`,
+        });
+        continue;
+      }
+
       // 校验 marketplaceSourceType：从配置读取，不允许硬编码默认值
       const sourceTypeResult = validateMarketplaceSourceSelection(platform.id, dist, dist);
       if (!sourceTypeResult.valid) {
@@ -2829,6 +2878,7 @@ async function runPrepareSkillResourceClosureGate({
         (p) => p.distributionType === distribution.type,
       );
       if (!platform) continue;
+      if (platform.installMethod === 'foundation-host-verification') continue;
       const frozenManifest = frozenManifestByDist.get(
         `${unit.id} ${distribution.type}`,
       );
@@ -2903,6 +2953,7 @@ async function runPrepareSkillResourceClosureGate({
         (p) => p.distributionType === distribution.type,
       );
       if (!platform) continue;
+      if (platform.installMethod === 'foundation-host-verification') continue;
       expectedHosts.push(await normalizeHostId(platform.buildAdapter.name));
     }
     const hostCoverage = evaluateDeclaredHostSurfaceCoverage(
@@ -4267,7 +4318,7 @@ export async function prepareRelease(options) {
     const { unitResults, snapshotDigests } = await processSnapshots(
       selectedConfig, realRoot, evidence, runDir, production,
     );
-    await validateFrozenLocalHostUpdatePlugins(unitResults);
+    await validateFrozenLocalHostUpdatePlugins(unitResults, resolvedVersions);
 
     // Snapshot gates always run on disposable writable copies. The public
     // snapshot authority is re-digested after every gate and is never exposed
@@ -4488,6 +4539,20 @@ export async function prepareRelease(options) {
         if (!platform || dist.type === 'npm') return dist;
         const key = `${unit.id} ${dist.type}`;
         const facts = distributionFacts.get(key);
+        if (facts?.kind === 'host-verification') {
+          const { hostVerification, ...frozenDistribution } = dist;
+          return {
+            ...frozenDistribution,
+            hostVerificationContract: {
+              contractVersion: 1,
+              scenario: structuredClone(hostVerification),
+              hostId: facts.platform.id,
+              payloadDigest: productionAssets?.[idx]?.manifestDigest ?? manifest.snapshotDigest,
+              manifestRelativePath: facts.entrySkillRelativePath,
+              entrySkill: facts.entrySkill,
+            },
+          };
+        }
 
         // includeMarketplaceEntry 代表"契约实际包含一条市场条目"，
         // 不能只代表平台理论上支持市场条目。

package/src/commands/publish.mjs

@@ -662,6 +662,7 @@ export async function publishRelease(options) {
         for (const dist of frozenUnit?.distributions ?? []) {
           const platform = PLATFORMS.find((p) => p.distributionType === dist.type);
           if (!platform) continue;
+          if (platform.installMethod === 'foundation-host-verification') continue;
           const contract = dist.installationContract;
           if (!contract?.normalizedManifest) continue;
           const pluginRoot = pluginRootFromManifestRelativePath(contract.manifestRelativePath);
@@ -696,7 +697,9 @@ export async function publishRelease(options) {
         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));
+          if (platform && platform.installMethod !== 'foundation-host-verification') {
+            expectedHosts.push(await normalizeHostId(platform.buildAdapter.name));
+          }
         }
         const hostCoverage = evaluateDeclaredHostSurfaceCoverage(
           expectedHosts,