release-skill 0.9.17 → 0.9.19

package/src/commands/ship.mjs

@@ -220,6 +220,7 @@ const ACTION_TARGET_FIELDS = Object.freeze({
   'codex-marketplace-install': Object.freeze(['consumer', 'plugin', 'marketplace', 'repo', 'ref', 'version', 'entrySkill']),
   'kimi-marketplace-install': Object.freeze(['consumer', 'plugin', 'repo', 'ref', 'version', 'entrySkill']),
   'codebuddy-marketplace-install': Object.freeze(['consumer', 'plugin', 'repo', 'ref', 'version', 'entrySkill']),
+  'qoder-marketplace-install': Object.freeze(['consumer', 'plugin', 'marketplace', 'repo', 'ref', 'version', 'entrySkill']),
   'set-default-branch': Object.freeze(['repo', 'oldBranch', 'newBranch', 'expectedNewBranchCommit']),
 });
 
@@ -705,6 +706,7 @@ export async function advanceShip(options = {}, injected = {}) {
         adapterRegistry: options.adapterRegistry,
         root,
         verificationGatesAuthorized: state.verificationGatesAuthorized === true,
+        cursorHostRuntime: options.cursorHostRuntime,
       });
       state = {
         ...state,
@@ -837,6 +839,7 @@ export async function advanceShip(options = {}, injected = {}) {
     try {
       postRelease = derivePostReleaseChecklist(finalPlan, {
         root,
+        planPath: state.planPath,
         statePath,
         unitIds: state.selectedUnitIds,
         runPath: localFinishRunPath,

package/src/commands/verify.mjs

@@ -72,6 +72,7 @@ import {
   isFoundationPluginVerificationEligible,
   verifyFrozenPluginWithFoundation,
 } from '../core/foundation-plugin-verification.mjs';
+import { verifyFrozenCursorSkillWithFoundation } from '../core/foundation-host-verification.mjs';
 import { resolveUnitScopedPath } from '../snapshot/public-path.mjs';
 import { canonicalJson } from '../core/digest.mjs';
 import {
@@ -130,6 +131,53 @@ export const VERIFICATION_RESOLVED_TYPES = Object.freeze({
   NOT_REQUIRED_UNCHANGED: 'NOT_REQUIRED_UNCHANGED',
 });
 
+/** Verify actionless Cursor distributions through their frozen host contract. */
+export async function verifyCursorHostDistributions({
+  plan,
+  root,
+  cursorHostRuntime,
+  runHostVerificationFn,
+  clock = defaultClock,
+  evidence,
+} = {}) {
+  const checks = [];
+  for (const unit of plan?.units ?? []) {
+    const cursorDistribution = (unit.distributions ?? []).find(
+      (distribution) => distribution.type === 'cursor-plugin',
+    );
+    if (!cursorDistribution) continue;
+    const result = await verifyFrozenCursorSkillWithFoundation({
+      plan,
+      unitId: unit.id,
+      root,
+      cursorHostRuntime,
+      ...(runHostVerificationFn ? { runHostVerificationFn } : {}),
+      clock,
+    });
+    checks.push({
+      actionId: `cursor-host-verification-${unit.id}`,
+      actionType: 'cursor-host-verification',
+      unitId: unit.id,
+      distributionType: cursorDistribution.type,
+      status: VERIFICATION_RESOLVED_TYPES.PASSED_AUTOMATIC,
+      observation: result,
+    });
+    await evidence?.append({
+      phase: 'verify-host',
+      unitId: unit.id,
+      distributionType: cursorDistribution.type,
+      status: VERIFICATION_RESOLVED_TYPES.PASSED_AUTOMATIC,
+      hostId: result.hostId,
+      driverId: result.driverId,
+      requestDigest: result.requestDigest,
+      payloadDigest: result.payloadDigest,
+      entrySkill: result.entrySkill,
+      observation: result,
+    });
+  }
+  return checks;
+}
+
 /** Re-read every frozen subject tarball before consuming the public receipt. */
 export async function verifyPublicSourceAuthorityReceiptOffline({ plan, root }) {
   const descriptor = plan.publicSourceAuthorityReceipt;
@@ -179,6 +227,7 @@ const ADAPTER_ACTION_TYPE_MAP = {
   'codex-marketplace-install': 'codex-marketplace-install',
   'kimi-marketplace-install': 'kimi-marketplace-install',
   'codebuddy-marketplace-install': 'codebuddy-marketplace-install',
+  'qoder-marketplace-install': 'qoder-marketplace-install',
 };
 
 // ---------------------------------------------------------------------------
@@ -349,6 +398,7 @@ async function collectMissingManualAttestations({
   const manual = actions.filter((action) => (
     action.type === 'kimi-marketplace-install'
     || action.type === 'codebuddy-marketplace-install'
+    || action.type === 'qoder-marketplace-install'
   ));
   if (manual.length === 0) return [];
 
@@ -1097,6 +1147,8 @@ export async function verifyRelease(options) {
     execFn,
     configPath: configPathOpt,
     runPluginVerificationFn,
+    runHostVerificationFn,
+    cursorHostRuntime,
     observeFirstReleaseMarketplaceHeadFn,
     fetchFirstReleaseMarketplaceIndexFn,
   } = options ?? {};
@@ -1576,6 +1628,20 @@ export async function verifyRelease(options) {
     const manualFollowUps = [];
     const foundationPluginVerificationReceipts = [];
 
+    // Cursor has no marketplace action or publish checkpoint. Verify each
+    // declared Cursor distribution directly from its frozen unit contract,
+    // using explicit runtime roots that never enter the release run record.
+    // Plans without Cursor distributions do not enter
+    // this branch and retain their existing action-only behavior.
+    adapterChecks.push(...await verifyCursorHostDistributions({
+      plan,
+      root,
+      cursorHostRuntime,
+      runHostVerificationFn,
+      clock: clockFn,
+      evidence,
+    }));
+
     // Every action is identity-bound and adapters receive read-only or
     // per-action isolated consumer paths. Run independent checks concurrently;
     // the evidence writer serializes append operations and result arrays are
@@ -1710,6 +1776,7 @@ export async function verifyRelease(options) {
           'codex-marketplace-install': 'codex-plugin',
           'kimi-marketplace-install': 'kimi-plugin',
           'codebuddy-marketplace-install': 'codebuddy-plugin',
+          'qoder-marketplace-install': 'qoder-plugin',
         };
         const dist = unit?.distributions?.find((d) => d.type === typeToDist[action.type]);
 
@@ -1896,6 +1963,8 @@ export async function verifyRelease(options) {
             ? 'codex-plugin'
             : action.type === 'codebuddy-marketplace-install'
               ? 'codebuddy-plugin'
+              : action.type === 'qoder-marketplace-install'
+                ? 'qoder-plugin'
               : 'kimi-plugin';
         const installPath = verifyResult.observation?.installPath;
         consumerGateResults.push(...await runConsumerVerificationGates({
@@ -1919,6 +1988,10 @@ export async function verifyRelease(options) {
                 ? {
                     HOME: resolve(runDir, 'consumers', `codebuddy-${action.parameters.plugin}`),
                   }
+                : action.type === 'qoder-marketplace-install'
+                  ? {
+                      HOME: resolve(runDir, 'consumers', `qoder-${action.parameters.plugin}`),
+                    }
                 : {
                     HOME: resolve(runDir, 'consumers', `kimi-${action.parameters.plugin}`),
                   },

package/src/core/checkpoints.mjs

@@ -34,6 +34,7 @@ export const CHECKPOINT_ORDER = [
   'codex-marketplace-install',
   'kimi-marketplace-install',
   'codebuddy-marketplace-install',
+  'qoder-marketplace-install',
 ];
 
 /**
@@ -54,6 +55,7 @@ export const ADAPTER_ACTION_TYPE_MAP = {
   'codex-marketplace-install': 'codex-marketplace-install',
   'kimi-marketplace-install': 'kimi-marketplace-install',
   'codebuddy-marketplace-install': 'codebuddy-marketplace-install',
+  'qoder-marketplace-install': 'qoder-marketplace-install',
 };
 
 /**
@@ -68,7 +70,7 @@ export const ADAPTER_ACTION_TYPE_MAP = {
  *   placed in Tier 1 only for conservative scheduling.
  * - Tier 2 `github-release` depends on Tier 1 `create-tag` (release `--verify-tag`).
  *
- * Marketplace actions (claude/codex/kimi/codebuddy-marketplace-install) are
+ * Marketplace actions (claude/codex/kimi/codebuddy/qoder-marketplace-install) are
  * included in the tier table for ADAPTER_ACTION_TYPE_MAP lookup but are
  * filtered out before tier grouping in both publish and reconcile. They are
  * recorded as DEFERRED with CONSUMER_VERIFICATION_DEFERRED reason and never
@@ -82,7 +84,7 @@ export const TIER_TABLE = [
   ['push-commit', 'push-snapshot'],                                              // Tier 0
   ['set-default-branch', 'create-tag', 'npm-publish'],                          // Tier 1
   ['github-release', 'claude-marketplace-install', 'codex-marketplace-install'], // Tier 2
-  ['kimi-marketplace-install', 'codebuddy-marketplace-install'],                // Tier 3
+  ['kimi-marketplace-install', 'codebuddy-marketplace-install', 'qoder-marketplace-install'], // Tier 3
 ];
 
 /** Fast reverse lookup: action type -> tier index (-1 when unknown). */
@@ -170,6 +172,7 @@ export const MARKETPLACE_ACTION_TYPES = new Set([
   'codex-marketplace-install',
   'kimi-marketplace-install',
   'codebuddy-marketplace-install',
+  'qoder-marketplace-install',
 ]);
 
 /**

package/src/core/config.mjs

@@ -401,7 +401,7 @@ export async function loadProjectConfig({ root, configPath } = {}) {
     for (const unit of config.releaseUnits) {
       if (!unit?.distributions) continue;
       for (const dist of unit.distributions) {
-        if (dist.type === 'npm') continue;
+        if (dist.type === 'npm' || dist.type === 'cursor-plugin') continue;
         if (dist.marketplaceSourceType === undefined || dist.marketplaceSourceType === null) {
           dist.marketplaceSourceType = dist.marketplaceRepo ? 'standalone-index' : 'bundled-family';
         }

package/src/core/foundation-host-verification.mjs

@@ -0,0 +1,168 @@
+/**
+ * Release-domain mapping for one frozen Cursor Skill. Foundation owns request
+ * preparation, installation, process supervision and bound stream reads.
+ */
+import { basename, join, isAbsolute } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+import { prepareHostVerification, runHostVerification } from 'skill-family-engineering-kit';
+import { canonicalJson } from 'skill-family-contracts';
+import { createTemporaryWorkspace } from 'skill-family-harness-node';
+
+import { verifyFrozenSnapshot } from '../snapshot/frozen.mjs';
+import { canonicalPublicPath, publicPathCollisionKey } from '../snapshot/public-path.mjs';
+import { CONSUMER_VERIFICATION_DEFERRED, POST_PUBLISH_VERIFY_FAILED, ReleaseError } from './errors.mjs';
+
+function fail(message, details = {}) {
+  return new ReleaseError(POST_PUBLISH_VERIFY_FAILED, message, details);
+}
+
+/** Release-owned scenario policy, shared by freezing and consuming the contract. */
+export function assertCursorHostScenario(scenario) {
+  const keys = ['workloadDocument', 'fixtureFiles', 'protectedWorkspaceFiles', 'platformManifest', 'effectivePrompt', 'expectedResult'];
+  if (!scenario || typeof scenario !== 'object' || Array.isArray(scenario)
+    || Object.keys(scenario).length !== keys.length || keys.some((key) => !Object.hasOwn(scenario, key))) {
+    throw fail('Cursor host verification requires the complete frozen scenario');
+  }
+  for (const key of ['workloadDocument', 'effectivePrompt', 'expectedResult']) {
+    if (typeof scenario[key] !== 'string' || !scenario[key].isWellFormed()
+      || (key !== 'expectedResult' && scenario[key].length === 0)
+      || (key === 'effectivePrompt' && scenario[key].includes('\0'))) {
+      throw fail('Cursor scenario requires valid UTF-8 text', { field: key });
+    }
+  }
+  if (!scenario.platformManifest || typeof scenario.platformManifest !== 'object' || Array.isArray(scenario.platformManifest)) {
+    throw fail('Cursor scenario platformManifest must be a JSON object');
+  }
+  canonicalJson(scenario.platformManifest);
+  for (const field of ['fixtureFiles', 'protectedWorkspaceFiles']) {
+    const files = scenario[field];
+    if (!Array.isArray(files) || files.length === 0) throw fail('Cursor scenario files must be non-empty', { field });
+    const paths = [];
+    for (const file of files) {
+      if (!file || Object.keys(file).length !== 2 || typeof file.content !== 'string' || !file.content.isWellFormed()) {
+        throw fail('Cursor scenario file requires path and UTF-8 content', { field });
+      }
+      let path;
+      try { path = canonicalPublicPath(file.path).path; } catch { throw fail('Cursor scenario file path is unsafe', { field }); }
+      const key = publicPathCollisionKey(path);
+      if (path !== file.path || key.split('/').includes('.cursor')
+        || paths.some((other) => other === key || other.startsWith(key + '/') || key.startsWith(other + '/'))) {
+        throw fail('Cursor scenario files conflict or target a Cursor control path', { field });
+      }
+      paths.push(key);
+    }
+  }
+}
+
+/** Consume only frozen domain facts and this invocation's explicit private roots. */
+export async function verifyFrozenCursorSkillWithFoundation({
+  plan, unitId, root, cursorHostRuntime,
+  runHostVerificationFn = runHostVerification,
+  clock = () => new Date().toISOString(),
+} = {}) {
+  const unit = (plan?.units ?? []).find((candidate) => candidate.id === unitId);
+  const distribution = unit?.distributions?.find((candidate) => candidate.type === 'cursor-plugin');
+  const contract = distribution?.hostVerificationContract;
+  if (!unit?.frozenSnapshot?.path || !unit.frozenSnapshot.commit || !unit.frozenSnapshot.manifestDigest) {
+    throw fail('Cursor host verification requires a frozen unit snapshot', { unitId });
+  }
+  if (contract?.contractVersion !== 1 || contract.hostId !== 'cursor'
+    || contract.entrySkill !== distribution.entrySkill
+    || contract.payloadDigest !== unit.frozenSnapshot.manifestDigest
+    || contract.manifestRelativePath !== 'skills/' + contract.entrySkill + '/SKILL.md') {
+    throw fail('Cursor host verification contract does not bind the frozen payload and entry Skill', { unitId });
+  }
+  assertCursorHostScenario(contract.scenario);
+  if (!cursorHostRuntime || Object.keys(cursorHostRuntime).length !== 2
+    || !['executableRoot', 'existingUserStateRoot'].every((key) =>
+      typeof cursorHostRuntime[key] === 'string' && isAbsolute(cursorHostRuntime[key]))) {
+    throw fail('Cursor host verification requires explicit absolute executableRoot and existingUserStateRoot', { unitId });
+  }
+  const frozen = await verifyFrozenSnapshot({ root, snapshotPath: unit.frozenSnapshot.path, expectedDigest: contract.payloadDigest });
+  const prefix = 'skills/' + contract.entrySkill + '/';
+  const members = frozen.entries.filter((entry) => entry.type === 'file' && entry.path.startsWith(prefix))
+    .map((entry) => entry.path.slice(prefix.length));
+  if (!members.includes('SKILL.md')) throw fail('Cursor frozen entry Skill is missing SKILL.md', { unitId });
+  const scenario = contract.scenario;
+  const owned = await createTemporaryWorkspace({ prefix: 'release-skill-cursor-' });
+  let retain = false;
+  let prepared;
+  let result;
+  try {
+    const repositoryRoot = await owned.resolve('repository');
+    const workspaceRoot = join(repositoryRoot, 'workspace');
+    const sessionRoot = await owned.resolve('session');
+    await mkdir(workspaceRoot, { recursive: true, mode: 0o700 });
+    await mkdir(sessionRoot, { mode: 0o700 });
+    for (const file of scenario.protectedWorkspaceFiles) {
+      await owned.writeFile('repository/workspace/' + file.path, file.content, { mode: 0o600 });
+    }
+    prepared = await prepareHostVerification({
+      hostId: 'cursor',
+      verificationSetId: plan.digest + ':' + unitId + ':cursor',
+      candidate: {
+        ref: unit.frozenSnapshot.commit,
+        manifest: canonicalJson({
+          contractVersion: contract.contractVersion, unitId, candidateRef: unit.frozenSnapshot.commit,
+          payloadDigest: contract.payloadDigest, entrySkill: contract.entrySkill,
+          manifestRelativePath: contract.manifestRelativePath,
+        }),
+      },
+      skill: { root: join(frozen.snapshotDir, 'skills', contract.entrySkill), entrySkill: contract.entrySkill, members },
+      workloadDocument: scenario.workloadDocument,
+      fixtureFiles: scenario.fixtureFiles,
+      workspace: { repositoryRoot, root: workspaceRoot, protectedMembers: scenario.protectedWorkspaceFiles.map((file) => file.path) },
+      platformManifest: canonicalJson(scenario.platformManifest),
+      effectivePrompt: scenario.effectivePrompt,
+      executable: { root: cursorHostRuntime.executableRoot, relPath: 'cursor-agent' },
+      existingUserStateRoot: cursorHostRuntime.existingUserStateRoot,
+      sessionRoot,
+      timeoutPolicy: {
+        schemaVersion: 1, kind: 'skill-family.timeout-policy',
+        maxSeconds: (distribution.timeoutMs ?? 300000) / 1000, killGraceSeconds: 1,
+      },
+    });
+    // An unexpected exception after dispatch cannot establish process termination.
+    retain = true;
+    result = await runHostVerificationFn(prepared);
+    retain = !['observed', 'failed', 'rejected'].includes(result?.status);
+    if (retain) {
+      throw new ReleaseError(CONSUMER_VERIFICATION_DEFERRED,
+        'Cursor invocation is indeterminate; inspect the retained private scene before retrying with fresh runtime inputs', {
+          unitId,
+          requirements: [{ unitId, hostId: 'cursor', action: 'inspect-retained-cursor-scene', sceneId: basename(owned.root) }],
+        });
+    }
+    const stdout = result.streams ? await prepared.readInvocationStream(result, 'stdout') : null;
+    if (result.status !== 'observed') {
+      throw fail('Foundation Cursor invocation did not reach an observed result', { unitId, status: result.status, reason: result.reason });
+    }
+    if (!stdout) throw fail('Cursor invocation has no bound stdout evidence', { unitId });
+    let answer;
+    try { answer = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(stdout)); } catch {
+      throw fail('Cursor invocation did not return valid UTF-8 success JSON', { unitId });
+    }
+    if (answer?.type !== 'result' || answer.subtype !== 'success' || answer.is_error !== false
+      || typeof answer.result !== 'string' || answer.result !== scenario.expectedResult) {
+      throw fail('Cursor result does not match the frozen expected result', { unitId });
+    }
+    return {
+      planDigest: plan.digest, unitId, distributionType: 'cursor-plugin',
+      candidateRef: unit.frozenSnapshot.commit, payloadDigest: contract.payloadDigest,
+      manifestRelativePath: contract.manifestRelativePath, entrySkill: contract.entrySkill,
+      hostId: result.host.hostId, driverId: result.host.driverId, foundationStatus: result.status,
+      requestDigest: result.requestDigest, runtimeIdentities: result.runtimeIdentities,
+      execution: result.execution, snapshots: result.snapshots, streams: result.streams, observedAt: clock(),
+    };
+  } catch (error) {
+    if (error instanceof ReleaseError) throw error;
+    if (retain) {
+      throw new ReleaseError(CONSUMER_VERIFICATION_DEFERRED, 'Cursor invocation outcome is unknown; inspect the retained private scene', {
+        unitId, requirements: [{ unitId, hostId: 'cursor', action: 'inspect-retained-cursor-scene', sceneId: basename(owned.root) }],
+      });
+    }
+    throw fail('Foundation Cursor host verification failed closed', { unitId, foundationCode: error?.code ?? null });
+  } finally {
+    if (!retain) await owned.dispose();
+  }
+}

package/src/core/plan.mjs

@@ -413,7 +413,9 @@ function buildExpectedAdapterMap() {
     'create-tag': 'git-github',
     'github-release': 'github',
     'npm-publish': 'npm',
-    ...Object.fromEntries(PLATFORMS.map((p) => [p.actionType, p.adapter])),
+    ...Object.fromEntries(PLATFORMS
+      .filter((platform) => platform.actionType !== null)
+      .map((platform) => [platform.actionType, platform.adapter])),
     'set-default-branch': 'git-github',
   };
 }
@@ -857,6 +859,22 @@ export function validatePlanActionCompleteness(plan, options = {}) {
     for (const platform of PLATFORMS) {
       const dist = distributions.find((d) => d.type === platform.distributionType);
       if (!dist) continue;
+      if (platform.actionType === null) {
+        if (!dist.entrySkill) {
+          failures.push(`unit "${unitId}": ${platform.distributionType} distribution requires entrySkill`);
+        }
+        const contract = dist.hostVerificationContract;
+        if (
+          !contract
+          || contract.hostId !== platform.id
+          || contract.entrySkill !== dist.entrySkill
+          || contract.manifestRelativePath !== `skills/${dist.entrySkill}/SKILL.md`
+          || contract.payloadDigest !== frozen?.manifestDigest
+        ) {
+          failures.push(`unit "${unitId}": ${platform.distributionType} distribution host verification contract does not match the frozen payload`);
+        }
+        continue;
+      }
       const plugin = dist.plugin;
       const marketplace = dist.marketplace;
       const entrySkill = dist.entrySkill;

package/src/core/postpublish.mjs

@@ -30,6 +30,7 @@ import {
   resolvePresetRequiresApproval,
 } from './presets.mjs';
 import { checkGitRemoteUrl, describeGitRemoteUrlFailure } from './git-url-policy.mjs';
+import { classifyPathInput } from 'skill-family-harness-node';
 
 /** Secret-ish environment variable denylist (R3 credential hygiene). */
 export const ENV_ALLOWLIST_DENYLIST = /TOKEN|SECRET|PASSWORD|PASSPHRASE|API_KEY|CREDENTIAL/i;
@@ -42,7 +43,7 @@ const SAFE_ID_RE = /^[a-z0-9][a-z0-9._-]*$/;
 
 /** Branch pattern (leading alphanumeric blocks option-like names). */
 const BRANCH_RE = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
-const LOCAL_HOSTS = new Set(['claude', 'codex', 'kimi', 'codebuddy', 'workbuddy', 'qoder']);
+const LOCAL_HOSTS = new Set(['claude', 'codex', 'kimi', 'codebuddy', 'workbuddy', 'qoder', 'cursor']);
 const HUB_HOST_RE = /^[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?$/u;
 const HUB_REF_RE = /^refs\/heads\/[A-Za-z0-9][A-Za-z0-9._-]*(?:\/[A-Za-z0-9][A-Za-z0-9._-]*)*$/u;
 
@@ -500,6 +501,13 @@ export function validatePostPublishDeclaration(postPublish, options = {}) {
       if (hosts.has(host)) fail(`${unitLabel}localHostUpdate.hosts contains duplicate host "${host}"`);
       hosts.add(host);
     }
+    if (hosts.has('cursor')) {
+      if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/u.test(localHostUpdate.plugin)) fail(`${unitLabel}Cursor plugin name must match the Cursor naming convention`);
+      const cursor = localHostUpdate.cursor;
+      if (!cursor || typeof cursor !== 'object' || Array.isArray(cursor)) fail(`${unitLabel}localHostUpdate.cursor is required`);
+      if (!classifyPathInput(cursor.sourcePath).ok) fail(`${unitLabel}localHostUpdate.cursor.sourcePath must be a safe relative path`);
+      if (cursor.dependencyInstall !== undefined && cursor.dependencyInstall !== 'npm-ci-ignore-scripts') fail(`${unitLabel}localHostUpdate.cursor.dependencyInstall is unsupported`);
+    } else if (localHostUpdate.cursor !== undefined) fail(`${unitLabel}localHostUpdate.cursor requires cursor in hosts`);
     const hub = localHostUpdate.hub;
     if (!hub || typeof hub !== 'object' || Array.isArray(hub)) {
       fail(`${unitLabel}localHostUpdate.hub must be a non-null object`);

package/src/core/run-retention.mjs

@@ -67,7 +67,7 @@ function postVerificationComplete(run) {
 function publicationComplete(run) {
   return run.checkpoints.every((cp) => COMPLETED_CHECKPOINTS.has(cp.status)
     || (['failed', 'deferred'].includes(cp.status)
-      && ['claude-marketplace-install', 'codex-marketplace-install', 'kimi-marketplace-install', 'codebuddy-marketplace-install'].includes(cp.actionType)));
+      && ['claude-marketplace-install', 'codex-marketplace-install', 'kimi-marketplace-install', 'codebuddy-marketplace-install', 'qoder-marketplace-install'].includes(cp.actionType)));
 }
 
 async function lineagePathsContained(run, runsRoot) {

package/src/core/surface-host-bindings.mjs

@@ -91,6 +91,7 @@ export function normalizeGenericSkillsRel(skillsRaw) {
 const SKILLS_NORMALIZERS = {
   claude: normalizeGenericSkillsRel,
   codex: normalizeGenericSkillsRel,
+  qoder: normalizeGenericSkillsRel,
   kimi: normalizeKimiSkillsRel,
   codebuddy: normalizeCodeBuddySkillsRel,
 };

package/src/core/verification-gates.mjs

@@ -57,7 +57,7 @@ function validateGate(gate) {
   if (!gate.scope || typeof gate.scope.unit !== 'string') {
     throw gateError(gate, 'must declare scope.unit');
   }
-  if (gate.phase === 'consumer-verify' && !['npm', 'claude-plugin', 'codex-plugin', 'kimi-plugin', 'codebuddy-plugin'].includes(gate.scope.distribution)) {
+  if (gate.phase === 'consumer-verify' && !['npm', 'claude-plugin', 'codex-plugin', 'kimi-plugin', 'codebuddy-plugin', 'qoder-plugin'].includes(gate.scope.distribution)) {
     throw gateError(gate, 'consumer-verify must declare a supported scope.distribution');
   }
   if (!Array.isArray(gate.command) || gate.command.length === 0 || gate.command.some((value) => typeof value !== 'string')) {