release-skill 0.9.16 → 0.9.18

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';
@@ -14,6 +21,7 @@ import { resolveCodeBuddyMarketplace } from '../platforms/codebuddy.mjs';
 import { verifyInstalledMarketplacePayload } from '../adapters/plugin-marketplace.mjs';
 import { normalizePostPublishView, postPublishActionId } from '../core/postpublish.mjs';
 import { loadRun, validateRunLineage } from '../core/run.mjs';
+import { verifyFrozenSnapshot } from '../snapshot/frozen.mjs';
 
 const HOSTS_BY_ACTION = Object.freeze({
   'claude-marketplace-install': ['claude'],
@@ -40,6 +48,9 @@ const SAFE_ENV_KEYS = Object.freeze([
 ]);
 const CODEBUDDY_PLUGIN_LIST_ARGS = Object.freeze(['plugin', 'list', '--json']);
 const CODEBUDDY_MARKETPLACE_LIST_ARGS = Object.freeze(['plugin', 'marketplace', 'list']);
+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 }) {
   Object.defineProperties(error, {
@@ -172,17 +183,49 @@ function hubTargets(plan) {
       codebuddy: 'Handle manually; CodeBuddy cannot pin a Hub ref in this flow.',
       workbuddy: 'Handle manually; WorkBuddy cannot pin a Hub ref in this flow (it follows the CodeBuddy manual boundary).',
     };
-    return local.hosts.map((host) => ({
-      targetKind: 'hub-backed',
-      executionMode: 'manual',
-      unitId: declaration.unitId,
-      host,
-      plugin: local.plugin,
-      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 } : {}),
-      ...(tag ? { frozenTag: tag } : {}),
-    }));
+    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',
+          executionMode: 'executable',
+          unitId: declaration.unitId,
+          host,
+          plugin: local.plugin,
+          marketplace: hub.name,
+          hub,
+          version: unit?.targetVersion,
+          pluginRepo: unit?.publicRepo,
+          pluginCommit: unit?.frozenSnapshot?.commit,
+          snapshotPath: unit?.frozenSnapshot?.path,
+          manifestDigest: unit?.frozenSnapshot?.manifestDigest,
+          timeoutMs: 300_000,
+          message: `Update ${local.plugin} from Qoder Hub ${hub.name}; a new session or /plugins reload is required before treating the updated plugin as loaded.`,
+          ...(tag ? { frozenTag: tag } : {}),
+        };
+      }
+      return {
+        targetKind: 'hub-backed',
+        executionMode: 'manual',
+        unitId: declaration.unitId,
+        host,
+        plugin: local.plugin,
+        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 } : {}),
+        ...(tag ? { frozenTag: tag } : {}),
+      };
+    });
   });
 }
 
@@ -240,6 +283,23 @@ function assertExecutableTarget(target) {
   }
 }
 
+function assertQoderExecutableTarget(target) {
+  for (const field of [
+    'unitId', 'plugin', 'marketplace', 'version', 'pluginRepo',
+    'pluginCommit', 'snapshotPath', 'manifestDigest',
+  ]) {
+    if (typeof target[field] !== 'string' || target[field].length === 0) {
+      throw new Error(`Qoder local host update target is missing ${field}`);
+    }
+  }
+  if (!/^[a-f0-9]{40}$/u.test(target.pluginCommit)) {
+    throw new Error(`Qoder local host update requires the frozen public commit for unit ${target.unitId}`);
+  }
+  if (!/^[a-f0-9]{64}$/u.test(target.manifestDigest)) {
+    throw new Error(`Qoder local host update requires the frozen snapshot digest for unit ${target.unitId}`);
+  }
+}
+
 function buildShipNextStep({ root, statePath, unitIds }) {
   const argv = ['release-skill', 'ship'];
   if (typeof root === 'string' && root.length > 0) argv.push('--root', root);
@@ -268,8 +328,12 @@ export function derivePostReleaseChecklist(plan, {
   const uncovered = units.filter((unit) => (
     !BRANCH_ACTION_INCLUDED.has(unit.productionConfig?.branchStrategy)
   ));
-  const executableTargets = pluginTargets(plan);
-  const manualTargets = hubTargets(plan);
+  const declaredHubTargets = hubTargets(plan);
+  const executableTargets = [
+    ...pluginTargets(plan),
+    ...declaredHubTargets.filter((target) => target.executionMode === 'executable'),
+  ];
+  const manualTargets = declaredHubTargets.filter((target) => target.executionMode === 'manual');
   const targets = mergePostReleaseTargets(executableTargets, manualTargets);
   const hasPendingPostVerify = postVerifyHooks(plan).length > 0 && !postVerifyComplete && targets.length > 0;
   const hasStatePath = typeof statePath === 'string' && statePath.length > 0;
@@ -717,6 +781,215 @@ function normalizeGitSource(source) {
     .replace(/\/$/u, '');
 }
 
+function normalizeHubGitSource(source, githubHost) {
+  return String(source ?? '')
+    .replace(/^git\+/, '')
+    .replace(new RegExp(`^https://${String(githubHost).replaceAll('.', '\\.').replaceAll('-', '\\-')}/`), '')
+    .replace(new RegExp(`^git@${String(githubHost).replaceAll('.', '\\.').replaceAll('-', '\\-')}:`), '')
+    .replace(/\.git$/u, '')
+    .replace(/\/$/u, '');
+}
+
+async function observeQoderMarketplace(target, command, env, run) {
+  const listed = await run(command, [...QODER_MARKETPLACE_LIST_ARGS], {
+    env,
+    timeout: target.timeoutMs,
+  });
+  const parsed = parseJson(listed.stdout, 'qoder marketplace list');
+  if (!Array.isArray(parsed)) throw new Error('qoder marketplace list did not return an array');
+  const matches = parsed.filter((entry) => entry?.name === target.marketplace);
+  if (matches.length === 0) return { installed: false };
+  if (matches.length !== 1) {
+    throw new Error(`qoder marketplace list returned conflicting entries for ${target.marketplace}`);
+  }
+  const [found] = matches;
+  if (
+    found.source?.source !== 'git'
+    || normalizeHubGitSource(found.source.url, target.hub.githubHost) !== target.hub.repo
+  ) {
+    throw new Error(`qoder marketplace ${target.marketplace} does not point to ${target.hub.repo}`);
+  }
+  if (typeof found.installLocation !== 'string' || found.installLocation.length === 0) {
+    throw new Error(`qoder marketplace ${target.marketplace} has no observable checkout root`);
+  }
+  const [remote, branch] = await Promise.all([
+    run('git', ['-C', found.installLocation, 'remote', 'get-url', 'origin'], {
+      env,
+      timeout: 30_000,
+    }),
+    run('git', ['-C', found.installLocation, 'symbolic-ref', '-q', 'HEAD'], {
+      env,
+      timeout: 30_000,
+    }),
+  ]);
+  if (
+    normalizeHubGitSource(remote.stdout.trim(), target.hub.githubHost) !== target.hub.repo
+    || branch.stdout.trim() !== target.hub.ref
+  ) {
+    throw new Error(`qoder marketplace ${target.marketplace} checkout does not match the frozen Hub source`);
+  }
+  return { installed: true, root: found.installLocation, found };
+}
+
+async function observeQoderPlugin(target, command, env, run) {
+  const listed = await run(command, [...QODER_PLUGIN_LIST_ARGS], {
+    env,
+    timeout: target.timeoutMs,
+  });
+  const parsed = parseJson(listed.stdout, 'qoder plugin list');
+  if (!Array.isArray(parsed)) throw new Error('qoder plugin list did not return an array');
+  const selector = `${target.plugin}@${target.marketplace}`;
+  const matches = parsed.filter((entry) => entry?.id === selector);
+  if (matches.length === 0) return { installed: false };
+  if (matches.length !== 1) {
+    throw new Error(`qoder plugin list returned conflicting entries for ${selector}`);
+  }
+  const [found] = matches;
+  if (
+    found.name !== target.plugin
+    || found.source !== selector
+    || found.scope !== 'user'
+    || typeof found.installPath !== 'string'
+    || found.installPath.length === 0
+  ) {
+    throw new Error(`qoder plugin ${selector} does not match its frozen user-scope identity`);
+  }
+  return {
+    installed: true,
+    exact: found.version === target.version,
+    installPath: found.installPath,
+    found,
+  };
+}
+
+async function readQoderManifest(root, label) {
+  const manifest = parseJson(
+    await readFileContained(root, '.qoder-plugin/plugin.json', { encoding: 'utf8' }),
+    label,
+  );
+  if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
+    throw new Error(`${label} did not return an object`);
+  }
+  return manifest;
+}
+
+function assertQoderPluginManifest(target, manifest, label) {
+  if (
+    manifest.name !== target.plugin
+    || manifest.version !== target.version
+    || manifest.skills !== './adapters/qoder/skills/'
+  ) {
+    throw new Error(`${label} does not match the frozen Qoder plugin identity and projection path`);
+  }
+}
+
+async function assertFrozenQoderManifest(target, root) {
+  const { snapshotDir: snapshotRoot } = await verifyFrozenSnapshot({
+    root,
+    snapshotPath: target.snapshotPath,
+    expectedDigest: target.manifestDigest,
+  });
+  const manifest = await readQoderManifest(snapshotRoot, 'frozen Qoder plugin manifest');
+  assertQoderPluginManifest(target, manifest, 'frozen Qoder plugin manifest');
+}
+
+async function assertQoderHubEntry(target, marketplaceRoot) {
+  const marketplace = parseJson(
+    await readFileContained(marketplaceRoot, 'marketplace.json', { encoding: 'utf8' }),
+    'Qoder Hub marketplace manifest',
+  );
+  if (marketplace?.name !== target.marketplace || !Array.isArray(marketplace.plugins)) {
+    throw new Error('Qoder Hub marketplace manifest does not match the frozen marketplace');
+  }
+  const matches = marketplace.plugins.filter((entry) => entry?.name === target.plugin);
+  if (matches.length !== 1) {
+    throw new Error(`Qoder Hub marketplace manifest must contain exactly one ${target.plugin} entry`);
+  }
+  const source = matches[0]?.source;
+  if (
+    source?.source !== 'url'
+    || normalizeHubGitSource(source.url, target.hub.githubHost) !== target.pluginRepo
+    || source.sha !== target.pluginCommit
+  ) {
+    throw new Error('Qoder Hub entry does not match the frozen public source identity');
+  }
+}
+
+async function verifyQoderInstalledPayload({
+  target,
+  root,
+  installPath,
+  verifyInstalledPayload,
+}) {
+  const manifest = await readQoderManifest(installPath, 'installed Qoder plugin manifest');
+  assertQoderPluginManifest(target, manifest, 'installed Qoder plugin manifest');
+  await verifyInstalledPayload({
+    snapshotPath: target.snapshotPath,
+    manifestDigest: target.manifestDigest,
+    payloadContract: QODER_PAYLOAD_CONTRACT,
+    marketplaceLocation: 'external',
+  }, { root }, installPath, 'qoder');
+}
+
+async function runQoderUpdate(target, detected, run, {
+  root,
+  verifyInstalledPayload,
+}) {
+  const env = hostEnvironment('qoder');
+  await assertFrozenQoderManifest(target, root);
+  const marketplace = await observeQoderMarketplace(target, detected.command, env, run);
+  if (!marketplace.installed) {
+    return {
+      status: 'MANUAL_REQUIRED',
+      reason: `qoder marketplace ${target.marketplace} is not installed; no marketplace was added`,
+    };
+  }
+  const before = await observeQoderPlugin(target, detected.command, env, run);
+  if (!before.installed) {
+    return {
+      status: 'MANUAL_REQUIRED',
+      reason: 'qoder target plugin is not installed; no initial installation was performed',
+    };
+  }
+  if (before.exact) {
+    await assertQoderHubEntry(target, marketplace.root);
+    await verifyQoderInstalledPayload({
+      target,
+      root,
+      installPath: before.installPath,
+      verifyInstalledPayload,
+    });
+    return { status: 'ALREADY_CURRENT', version: target.version };
+  }
+
+  await run(detected.command, ['plugins', 'marketplace', 'update', target.marketplace], {
+    env,
+    timeout: target.timeoutMs,
+  });
+  const refreshed = await observeQoderMarketplace(target, detected.command, env, run);
+  if (!refreshed.installed) {
+    throw new Error(`qoder marketplace ${target.marketplace} disappeared after refresh`);
+  }
+  await assertQoderHubEntry(target, refreshed.root);
+  await run(detected.command, [
+    'plugins', 'update', `${target.plugin}@${target.marketplace}`, '--scope', 'user',
+  ], { env, timeout: target.timeoutMs });
+  const after = await observeQoderPlugin(target, detected.command, env, run);
+  if (!after.exact) throw new Error('qoder did not update to the frozen plugin version');
+  await verifyQoderInstalledPayload({
+    target,
+    root,
+    installPath: after.installPath,
+    verifyInstalledPayload,
+  });
+  return {
+    status: 'UPDATED',
+    version: target.version,
+    restartRequired: true,
+    reloadInstruction: 'Start a new Qoder session or run /plugins reload before checking the loaded version.',
+  };
+}
+
 function parseFrozenRemoteRef(target, stdout) {
   const directRefs = new Map();
   const peeledRefs = new Map();
@@ -1046,14 +1319,14 @@ expect {
       eof { failEof remove-confirmation 126 }
     }
     expect {
-      -nocase -re {Trust this folder\\?} { directoryTrust }
+      -nocase -re {Trust this folder\\?} { unexpectedDirectoryTrust }
       -re $promptPattern {}
       timeout { failTimeout remove-prompt 128 130 }
       eof { failEof remove-prompt 129 }
     }
   }
   -re $promptPattern {}
-  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -nocase -re {Trust this folder\\?} { unexpectedDirectoryTrust }
   timeout { failTimeout remove-dialog 122 124 }
   eof { failEof remove-dialog 123 }
 }
@@ -1128,9 +1401,133 @@ proc failEof {state code} {
   exit $code
 }
 
-proc directoryTrust {} {
-  puts stderr "KIMI_TUI_STATE:directory-trust:manual-required"
-  exit 80
+proc unexpectedDirectoryTrust {} {
+  puts stderr "KIMI_TUI_STATE:directory-trust:unexpected"
+  exit 147
+}
+
+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 }
+    }
+    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 }
+    }
+  } 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 }
+    }
+  }
+  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
+    }
+    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
+    }
+  }
+  if {[llength $labels] != 2 || $trustCount != 1 || $selectedCount != 1} {
+    puts stderr "KIMI_TUI_STATE:$state:selection-unknown"
+    exit $unknownCode
+  }
+  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
+    }
+  }
+  send -- "\\033\\[13u"
+  expect {
+    -nocase -re {Trust this folder\\?} { unexpectedDirectoryTrust }
+    -re $promptPattern {}
+    timeout { failTimeout directory-trust-prompt 151 153 }
+    eof { failEof directory-trust-prompt 152 }
+  }
 }
 
 proc submitCommand {command} {
@@ -1146,7 +1543,7 @@ if {[catch {exec stty columns 240 rows 60 < $spawn_out(slave,name)} resizeError]
   exit 131
 }
 expect {
-  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -nocase -re {Trust this folder\\?} { confirmInitialDirectoryTrust }
   -re $promptPattern {}
   timeout { failTimeout initial-prompt 101 103 }
   eof { failEof initial-prompt 102 }
@@ -1154,7 +1551,7 @@ expect {
 ${removeCommand}submitCommand "/plugins install $installUrl"
 set dialogBuffer ""
 expect {
-  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -nocase -re {Trust this folder\\?} { unexpectedDirectoryTrust }
   -nocase -re {(?:Install third-party plugin|Trust and install from)[ \\t]} {
     append dialogBuffer $expect_out(buffer)
   }
@@ -1162,7 +1559,7 @@ expect {
   eof { failEof plugin-trust-anchor 105 }
 }
 expect {
-  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -nocase -re {Trust this folder\\?} { unexpectedDirectoryTrust }
   -nocase -re {❯[^\\r\\n]*(?:Exit|Cancel|Trust and install)} {
     append dialogBuffer $expect_out(buffer)
   }
@@ -1198,7 +1595,7 @@ if {[regexp -nocase {(^|\\n)[^\\n]*❯[^\\n]*trust and install} $dialog]} {
 } elseif {[regexp -nocase {(^|\\n)[^\\n]*❯[^\\n]*(cancel|exit)} $dialog]} {
   send -- "\\033\\[B"
   expect {
-    -nocase -re {Trust this folder\\?} { directoryTrust }
+    -nocase -re {Trust this folder\\?} { unexpectedDirectoryTrust }
     -nocase -re {❯[^\\r\\n]*Trust and install} {}
     -re {❯[^\\r\\n]*\\r*\\n} {
       puts stderr "KIMI_TUI_STATE:plugin-trust-confirm-selection:unknown"
@@ -1214,7 +1611,7 @@ if {[regexp -nocase {(^|\\n)[^\\n]*❯[^\\n]*trust and install} $dialog]} {
 }
 
 expect {
-  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -nocase -re {Trust this folder\\?} { unexpectedDirectoryTrust }
   -nocase -re {Install finished[^\\r\\n]*see details below\\.} {}
   -nocase -re {Installing plugin from[^\\r\\n]*(?:\\r|\\n)} {
     exp_continue -continue_timer
@@ -1234,14 +1631,14 @@ expect {
   eof { failEof install-result 137 }
 }
 expect {
-  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -nocase -re {Trust this folder\\?} { unexpectedDirectoryTrust }
   -re $promptPattern {}
   timeout { failTimeout post-install-prompt 114 116 }
   eof { failEof post-install-prompt 115 }
 }
 submitCommand "/reload"
 expect {
-  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -nocase -re {Trust this folder\\?} { unexpectedDirectoryTrust }
   -re $promptPattern {}
   timeout { failTimeout reload-prompt 117 119 }
   eof { failEof reload-prompt 118 }
@@ -1343,29 +1740,20 @@ async function runKimiUpdate(target, detected, run, kimiHome, {
     }
     const installUrl = `https://github.com/${target.pluginRepo}/releases/tag/${target.pluginTag}`;
     const removePlugin = before.source === 'legacy' ? target.plugin : '';
-    try {
-      await run(detected.expectCommand, ['-c', kimiExpectProgram({
-        ...(removePlugin ? { removePlugin } : {}),
-      })], {
-        timeout: Math.max(300_000, target.timeoutMs),
-        env: {
-          ...env,
-          RELEASE_SKILL_KIMI_COMMAND: detected.command,
-          RELEASE_SKILL_KIMI_INSTALL_URL: installUrl,
-          RELEASE_SKILL_KIMI_REMOVE_PLUGIN: removePlugin,
-          RELEASE_SKILL_KIMI_EXPECTED_REPO: `https://github.com/${target.pluginRepo}`,
-          RELEASE_SKILL_KIMI_EXPECTED_TAG: target.pluginTag,
-        },
-      });
-    } catch (error) {
-      if (error?.exitStatus === 80) {
-        return {
-          status: 'MANUAL_REQUIRED',
-          reason: 'Kimi requires folder trust; release-finish did not confirm the folder or continue installation',
-        };
-      }
-      throw error;
-    }
+    await run(detected.expectCommand, ['-c', kimiExpectProgram({
+      ...(removePlugin ? { removePlugin } : {}),
+    })], {
+      cwd: root,
+      timeout: Math.max(300_000, target.timeoutMs),
+      env: {
+        ...env,
+        RELEASE_SKILL_KIMI_COMMAND: detected.command,
+        RELEASE_SKILL_KIMI_INSTALL_URL: installUrl,
+        RELEASE_SKILL_KIMI_REMOVE_PLUGIN: removePlugin,
+        RELEASE_SKILL_KIMI_EXPECTED_REPO: `https://github.com/${target.pluginRepo}`,
+        RELEASE_SKILL_KIMI_EXPECTED_TAG: target.pluginTag,
+      },
+    });
   }, { prefix: 'release-skill-kimi-update-' });
   if (tuiOutcome) return tuiOutcome;
   const after = await observeKimiTarget(target, kimiHome, run);
@@ -1380,6 +1768,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));
@@ -1419,6 +1961,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');
@@ -1429,12 +1976,25 @@ async function updateLocalHostPluginsInternal({
   const selected = new Set(Array.isArray(selectedHosts) ? selectedHosts : []);
   const unknown = [...selected].filter((host) => !checklist.localHostUpdate.hosts.includes(host));
   if (unknown.length > 0) throw new Error(`selected hosts are not declared by the plan: ${unknown.join(', ')}`);
-  const targets = pluginTargets(plan).filter((item) => selected.has(item.host));
-  for (const target of targets) assertExecutableTarget(target);
+  const targets = checklist.localHostUpdate.targets.filter((item) => (
+    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);
+  }
 
   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({
@@ -1451,7 +2011,12 @@ async function updateLocalHostPluginsInternal({
           root,
           verifyInstalledPayload,
         })
-        : await runStructuredUpdate(target, detected, run, {
+        : target.host === 'qoder'
+          ? await runQoderUpdate(target, detected, run, {
+            root,
+            verifyInstalledPayload,
+          })
+          : await runStructuredUpdate(target, detected, run, {
           plan,
           root,
           verifyInstalledPayload,