@1aboveio/skills 0.12.1 → 0.13.0

package/runtime/skills/distribution/scripts/bundles.mjs

@@ -1,12 +1,19 @@
 #!/usr/bin/env node
 
 import { spawnSync } from 'node:child_process';
-import { readFileSync, statSync } from 'node:fs';
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { emitKeypressEvents } from 'node:readline';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { isMainModule } from '../../engineering/engineering-runtime/scripts/main-module.mjs';
+// The digest authority for the update skip is the ONE existing predicate pair: contentDigest with
+// the published-content scope for first-party members, exact-tree for external ones — the same
+// semantics release coherence validates installed trees with. The coordinator never re-derives or
+// widens that scope; it only asks "does what is installed already digest to what this run would
+// install?" and skips the native add when the answer is yes.
+import { contentDigest, firstPartySource } from '../../engineering/engineering-runtime/scripts/workflow-coherence.mjs';
 
 // The coordinator is one command rendered into two transports: the private checkout and the
 // unpacked @1aboveio/skills package. Both defaults below are anchored on this file's own location,
@@ -29,6 +36,162 @@ const COMMAND_TRANSPORTS = ['local', 'https'];
 export const SUPPORT_GROUPS = new Set(['harness-runtime']);
 const ACTIONS = new Set(['install', 'update']);
 
+// Selection memory (ADR 0002/0004 amendment, epic #1124): the remembered user-facing group
+// set lives in XDG state so a no-argument `update` can replay it instead of reopening the picker.
+// The file records only user-facing successes (#1129): it is written when at least one user-facing
+// member's native add succeeded or was already digest-equal unchanged, with acceptedMembers
+// holding exactly those succeeded and unchanged members; failed and declined members are omitted,
+// a selected group left with no recordable member is omitted from the written set rather than
+// remembered with an empty acceptance (a failed run never advances its group ids into remembered
+// groups), and a run where nothing recordable succeeded leaves the prior file byte-for-byte
+// untouched. It is never a source of filesystem inference: missing or corrupt memory is a clear
+// error, not a reason to guess groups from disk.
+export const SELECTION_SCHEMA_VERSION = 1;
+
+export function selectionStatePath(env = process.env) {
+  const stateHome = env.XDG_STATE_HOME || join(env.HOME || homedir(), '.local', 'state');
+  return join(stateHome, '1aboveio-skills', 'selection.json');
+}
+
+function selectionError(path, detail) {
+  return new Error(`Remembered selection at ${path} ${detail}`);
+}
+
+export function loadSelectionState(env = process.env) {
+  const path = selectionStatePath(env);
+  let raw;
+  try {
+    raw = readFileSync(path, 'utf8');
+  } catch {
+    throw selectionError(path, 'does not exist. Run install or update with --group <id> or --all once to record a selection');
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw selectionError(path, `is not valid JSON: ${error.message}`);
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw selectionError(path, 'is invalid: expected an object');
+  }
+  if (parsed.schemaVersion !== SELECTION_SCHEMA_VERSION) {
+    throw selectionError(path, `has unsupported schemaVersion ${JSON.stringify(parsed.schemaVersion)} (expected ${SELECTION_SCHEMA_VERSION})`);
+  }
+  if (!Array.isArray(parsed.groups)) {
+    throw selectionError(path, 'is invalid: groups must be an array');
+  }
+  for (const group of parsed.groups) {
+    const valid = group
+      && typeof group === 'object'
+      && typeof group.id === 'string'
+      && group.id.length > 0
+      && Array.isArray(group.acceptedMembers)
+      && group.acceptedMembers.every((member) => typeof member === 'string');
+    if (!valid) {
+      throw selectionError(path, 'is invalid: every group needs an id and an acceptedMembers string array');
+    }
+  }
+  return { path, state: parsed };
+}
+
+function writeSelectionState(state, env = process.env) {
+  const path = selectionStatePath(env);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
+  return path;
+}
+
+// The group ids a remembered selection resolves to against the CURRENT catalog. Remembered ids
+// that are no longer selectable (renamed, removed, or a support group that must never be
+// user-selected) are dropped with a warning; memory never resurrects them and never falls back to
+// filesystem inference. Nothing left is an error, not an empty plan.
+function rememberedGroupIds(state, catalog, stderr) {
+  const known = new Set(catalog.map((bundle) => bundle.id));
+  const kept = [];
+  const dropped = [];
+  for (const group of state.groups) {
+    if (!known.has(group.id) || SUPPORT_GROUPS.has(group.id)) {
+      if (!dropped.includes(group.id)) dropped.push(group.id);
+      continue;
+    }
+    if (!kept.includes(group.id)) kept.push(group.id);
+  }
+  if (dropped.length > 0) {
+    stderr.write(`Ignoring unknown remembered bundle(s): ${dropped.join(', ')}\n`);
+  }
+  if (kept.length === 0) {
+    throw new Error('No known bundles remain in the remembered selection. Run update with --group <id> or --all to record a new selection');
+  }
+  return kept;
+}
+
+// The replacement memory for one run: the user-facing groups this run selected that have at least
+// one recordable member, each with acceptedMembers holding the user-facing members that were
+// successfully added or already digest-equal this run. Declined and failed members are omitted;
+// support-only members are never remembered; a group whose user-facing members all failed or were
+// declined is dropped entirely, so the next no-arg update never replays a group this run did not
+// actually deliver. The transport label is observational only — both render targets share this
+// file.
+export function selectionForRun(action, groupIds, { renderTarget, now = new Date(), succeededMembers, omitMembers, ...transport } = {}) {
+  const omitted = new Set(omitMembers ?? []);
+  const recipes = readRecipes(resolveBundleTransport(transport).recipesPath);
+  const groups = new Map(recipes.groups.map((group) => [group.id, group]));
+  const succeeded = succeededMembers ? new Set(succeededMembers) : undefined;
+  return {
+    schemaVersion: SELECTION_SCHEMA_VERSION,
+    updatedAt: now.toISOString(),
+    transport: { renderTarget },
+    groups: groupIds
+      .map((groupId) => {
+        const group = groups.get(groupId);
+        if (!group) throw new Error(`Unknown bundle: ${groupId}`);
+        const acceptedMembers = [...new Set(group[action].steps.flatMap((step) => step.members))]
+          .filter((member) => !SUPPORT_GROUPS.has(member))
+          .filter((member) => !omitted.has(member))
+          .filter((member) => !succeeded || succeeded.has(member));
+        return { id: groupId, acceptedMembers };
+      })
+      // Zero user-facing accepted members means zero delivered acceptance for that group:
+      // remembering the id would let a later no-arg update treat it as consented with no record.
+      .filter((group) => group.acceptedMembers.length > 0),
+  };
+}
+
+// Newly declared members (issue #1128): per selected group, the CURRENT user-facing recipe members
+// the remembered acceptedMembers does not know yet. A group with no prior acceptance contributes
+// nothing — a first-time selection is itself the consent (#1126 semantics). Support members
+// (harness-runtime) are silent dependencies and are never presented as a new user capability, so
+// they are filtered out even though acceptedMembers never lists them.
+export function newMemberCandidates(action, groupIds, priorState, transport = {}) {
+  if (!priorState) return [];
+  const recipes = readRecipes(resolveBundleTransport(transport).recipesPath);
+  const groups = new Map(recipes.groups.map((group) => [group.id, group]));
+  const acceptedByGroup = new Map(priorState.groups.map((group) => [group.id, new Set(group.acceptedMembers)]));
+  const candidates = [];
+  for (const groupId of groupIds) {
+    const accepted = acceptedByGroup.get(groupId);
+    if (!accepted) continue;
+    const group = groups.get(groupId);
+    if (!group) continue;
+    const members = [...new Set(group[action].steps.flatMap((step) => step.members))]
+      .filter((member) => !SUPPORT_GROUPS.has(member));
+    for (const member of members) {
+      if (!accepted.has(member)) candidates.push({ groupId, groupName: group.displayName, member });
+    }
+  }
+  return candidates;
+}
+
+// Prior acceptance for the new-member consent delta on explicit selections (picker, --group,
+// --all). ABSENT memory is tolerated — a first-time selection needs no delta — but CORRUPT memory
+// fails closed with the same clear error as the no-arg replay: guessing acceptance from a file we
+// cannot read could silently install a member the user never consented to.
+function loadPriorSelection(env) {
+  const path = selectionStatePath(env);
+  if (!statSync(path, { throwIfNoEntry: false })?.isFile()) return null;
+  return loadSelectionState(env).state;
+}
+
 export const selectorTerminalControl = Object.freeze({
   enter: '\x1b[?1049h\x1b[?25l',
   redraw: '\x1b[2J\x1b[H',
@@ -42,6 +205,23 @@ export function resolveBundleTransport({ recipesPath, localRoot } = {}) {
   };
 }
 
+// The render target recorded in selection memory is declared by the recipes DOCUMENT, never
+// inferred from the recipes path: inside the packaged @1aboveio/skills CLI the entrypoint injects
+// the package's own staged recipes, which IS this file's default path, so a path comparison would
+// mislabel every public-npm run as a private checkout. The value is validated against the known
+// targets so a foreign or hand-written recipes file fails closed instead of recording a made-up
+// channel.
+const RENDER_TARGETS = new Set(['private-checkout', 'public-npm']);
+
+function declaredRenderTarget(transport) {
+  const { recipesPath } = resolveBundleTransport(transport);
+  const recipes = readRecipes(recipesPath);
+  if (!RENDER_TARGETS.has(recipes.renderTarget)) {
+    throw new Error(`Bundle recipes at ${recipesPath} declare an unknown renderTarget: ${JSON.stringify(recipes.renderTarget)}`);
+  }
+  return recipes.renderTarget;
+}
+
 function readRecipes(recipesPath) {
   let contents;
   try {
@@ -65,7 +245,11 @@ export function bundleCatalog(transport = {}) {
     .map((group) => ({
       id: group.id,
       displayName: group.displayName,
-      members: group.install.steps.flatMap((step) => step.members),
+      // User-facing members only: the picker's count and Includes line are user-facing surfaces,
+      // and a support dependency (harness-runtime) is never presented as part of what a group
+      // offers — it installs silently with the group that needs it.
+      members: group.install.steps.flatMap((step) => step.members)
+        .filter((member) => !SUPPORT_GROUPS.has(member)),
     }));
 }
 
@@ -85,15 +269,24 @@ function localFirstPartyCommand(command, localRoot, groupId) {
   return command.replace(NATIVE_ADD_SOURCE, (_match, prefix) => `${prefix}${shellArgument(localRoot)}`);
 }
 
-// Native `skills add` prompts once per invocation for the installation method. Selecting several
-// bundles used to emit one add per group, so interactive installs asked the same question N times.
-// Coalesce by sourceId: one native add per upstream, with the union of --skill names, in the order
-// sources first appear across the selection. Identical full commands still collapse as before.
+// The coordinator executes one native add PER SKILL (#1129) rather than coalescing a whole source
+// into one invocation. A coalesced add can only attribute a failure to the entire source; per-skill
+// adds let the run record exactly which skill failed, continue with the remaining skills, and keep
+// only the succeeded skills in selection memory. Recipe step/member order is preserved
+// (dependency-first), and a member shared by several selected groups (harness-runtime) is still
+// planned exactly once, at its first occurrence. Native `skills add` prompts once per invocation
+// for the installation method, so per-skill execution relies on the native CLI's own non-interactive
+// handling; what the coordinator must guarantee is attribution, ordering and deduplication.
 const SKILL_TAIL = /^(.*? --skill )(.+?)( && .*)?$/;
 
+// The generated step binds its runtime suffix (` && npm ci ...`) to the whole coalesced command.
+// Per skill it belongs to the runtime member's own add, so the dependency install runs only after
+// engineering-runtime itself was actually added — never after a sibling, never when it was skipped.
+const RUNTIME_MEMBER = 'engineering-runtime';
+
 function skillsFromCommand(command) {
   const match = SKILL_TAIL.exec(command);
-  if (!match) throw new Error(`Native add has no --skill list to coalesce: ${command}`);
+  if (!match) throw new Error(`Native add has no --skill list to split: ${command}`);
   return match[2].trim().split(/\s+/).filter(Boolean);
 }
 
@@ -110,19 +303,12 @@ function withYesFlag(command) {
   return `${match[1]}${match[2]} --yes${match[3] || ''}`;
 }
 
-function mergeSkillLists(existing, incoming) {
-  const seen = new Set(existing);
-  const merged = [...existing];
-  for (const skill of incoming) {
-    if (seen.has(skill)) continue;
-    seen.add(skill);
-    merged.push(skill);
-  }
-  return merged;
-}
-
-export function planBundleCommands(action, groupIds, { yes = false, ...transport } = {}) {
+export function planBundleCommands(action, groupIds, { yes = false, skipMembers, omitMembers, ...transport } = {}) {
   if (!ACTIONS.has(action)) throw new Error(`Unsupported bundle action: ${action}`);
+  // Members the user declined this run (#1128) are filtered out of every native --skill list.
+  // Support dependencies (harness-runtime) are never omittable: they are silent install
+  // dependencies, not user capabilities, so consent never applies to them.
+  const omit = new Set(omitMembers ?? []);
   const { recipesPath, localRoot } = resolveBundleTransport(transport);
   const recipes = readRecipes(recipesPath);
   assertLocalRoot(localRoot);
@@ -133,11 +319,11 @@ export function planBundleCommands(action, groupIds, { yes = false, ...transport
     if (!requested.includes(groupId)) requested.push(groupId);
   }
 
-  // Always coalesce from the selected groups (not recipes.all). A public package may expose only a
-  // subset of groups while still shipping a full recipes.all from the private catalog; using that
-  // all-plan would install skills that are not in the selection / not in the package.
-  const bySource = new Map();
-  const sourceOrder = [];
+  // Plan from the selected groups (not recipes.all). A public package may expose only a subset of
+  // groups while still shipping a full recipes.all from the private catalog; using that all-plan
+  // would install skills that are not in the selection / not in the package.
+  const planned = [];
+  const plannedByMember = new Map();
 
   for (const groupId of requested) {
     const group = groups.get(groupId);
@@ -149,66 +335,188 @@ export function planBundleCommands(action, groupIds, { yes = false, ...transport
       const command = step.sourceId === 'first-party'
         ? localFirstPartyCommand(generated.command, localRoot, groupId)
         : generated.command;
-      const skills = skillsFromCommand(command);
+      // An explicit member subset (the digest skip) removes members from the native add but never
+      // reorders the rest: the remaining skills keep recipe order, support dependency first.
+      // Declined new members (#1128) are also filtered out, but consent never applies to support
+      // dependencies (harness-runtime): they are silent install dependencies, not capabilities.
+      const skills = skillsFromCommand(command)
+        .filter((skill) => !skipMembers?.has(skill))
+        .filter((skill) => SUPPORT_GROUPS.has(skill) || !omit.has(skill));
       const suffix = SKILL_TAIL.exec(command)?.[3] || '';
-      const existing = bySource.get(step.sourceId);
-      if (!existing) {
-        sourceOrder.push(step.sourceId);
-        bySource.set(step.sourceId, {
+      const bare = suffix ? command.slice(0, command.length - suffix.length) : command;
+      for (const skill of skills) {
+        const existing = plannedByMember.get(skill);
+        if (existing) {
+          if (!existing.groupIds.includes(groupId)) existing.groupIds.push(groupId);
+          continue;
+        }
+        let skillCommand = withSkills(bare, [skill]);
+        if (suffix && skill === RUNTIME_MEMBER) skillCommand = `${skillCommand}${suffix}`;
+        if (yes) skillCommand = withYesFlag(skillCommand);
+        const entry = {
+          member: skill,
           groupIds: [groupId],
-          groupNames: [group.displayName],
+          groupId,
+          groupName: group.displayName,
           sourceId: step.sourceId,
-          template: command,
-          skills: [...skills],
-          suffix,
+          command: skillCommand,
           cwd: localRoot,
           failureMessage: step.onFailure.message,
-        });
-        continue;
+        };
+        plannedByMember.set(skill, entry);
+        planned.push(entry);
       }
-      existing.groupIds.push(groupId);
-      if (!existing.groupNames.includes(group.displayName)) existing.groupNames.push(group.displayName);
-      existing.skills = mergeSkillLists(existing.skills, skills);
-      if (!existing.suffix && suffix) existing.suffix = suffix;
     }
   }
 
-  return sourceOrder.map((sourceId) => {
-    const planned = bySource.get(sourceId);
-    let command = withSkills(planned.template, planned.skills);
-    if (planned.suffix && !command.includes(' && ')) command = `${command}${planned.suffix}`;
-    if (yes) command = withYesFlag(command);
-    return {
-      groupId: planned.groupIds.length === 1 ? planned.groupIds[0] : planned.groupIds.join('+'),
-      groupName: planned.groupNames.length === 1 ? planned.groupNames[0] : planned.groupNames.join(' + '),
-      sourceId: planned.sourceId,
-      command,
-      cwd: planned.cwd,
-      failureMessage: planned.failureMessage,
-    };
-  });
+  return planned;
 }
 
+// Continue-on-failure (#1129): every planned per-skill add is attempted in dependency order; a
+// failed skill is recorded (its recipe failure message goes to stderr) and the run proceeds to the
+// remaining skills. Nothing here stops early — the caller summarizes the buckets and decides the
+// exit status, and selection persistence sees exactly which members succeeded.
 export function runBundleCommands(commands, {
   execute = (command, cwd) => spawnSync('/bin/bash', ['-lc', command], { cwd, stdio: 'inherit' }),
   stdout = process.stdout,
   stderr = process.stderr,
 } = {}) {
+  const succeeded = [];
+  const failed = [];
   for (const planned of commands) {
-    stdout.write(`\nInstalling ${planned.groupName} (${planned.sourceId})...\n`);
+    stdout.write(`\nInstalling ${planned.member} (${planned.sourceId})...\n`);
     const result = execute(planned.command, planned.cwd);
-    if (result.status !== 0) {
-      stderr.write(`${planned.failureMessage}\n`);
-      return Number.isInteger(result.status) ? result.status : 1;
+    if (result.status === 0) {
+      succeeded.push(planned);
+      continue;
+    }
+    stderr.write(`${planned.failureMessage}\n`);
+    failed.push({ planned, status: Number.isInteger(result.status) ? result.status : 1 });
+  }
+  return { succeeded, failed };
+}
+
+// The four run buckets, printed after every non-dry run. `unchanged` (digest-identical skip, #1127)
+// and `declined` (new-member consent, #1128) render from empty lists until those units land — the
+// summary contract is stable from here on, so both buckets are always shown.
+function printRunSummary(stdout, { succeeded, failed, unchanged = [], declined = [] }) {
+  // The summary is a user-facing surface: support dependencies (harness-runtime) are planned and
+  // executed like any member, but they are dependency plumbing and are never named in a bucket.
+  const visible = (name) => !SUPPORT_GROUPS.has(name);
+  const render = (names) => (names.length > 0 ? names.join(', ') : '(none)');
+  stdout.write('\nRun summary:\n');
+  stdout.write(`  succeeded: ${render(succeeded.map((planned) => planned.member).filter(visible))}\n`);
+  stdout.write(`  unchanged: ${render(unchanged.filter(visible))}\n`);
+  stdout.write(`  declined: ${render(declined.filter(visible))}\n`);
+  stdout.write(`  failed: ${render(failed.map((entry) => entry.planned.member).filter(visible))}\n`);
+}
+
+// --- Digest classification (epic #1124 / issue #1127) --------------------------------------------
+//
+// An `update` that re-adds a skill whose installed content already digests to what this invocation
+// would install buys nothing and costs the native overwrite prompt. So update classifies every
+// accepted member first and omits the digest-equal ones from the native add — skipping is the ONLY
+// way an unchanged member avoids the prompt, because the native CLI is the sole write authority and
+// the coordinator may not copy, link, or overwrite anything itself.
+//
+// The digest semantics are borrowed, never re-invented: first-party members digest their PUBLISHED
+// content (`published: true`) on both transports, external members digest the exact reviewed tree,
+// exactly as release coherence validates them. And a member with NO expected digest — Impeccable is
+// the one on tip — can never be `unchanged`: there is nothing to compare against, so an installed
+// one refreshes and an absent one is missing.
+
+// The pure verdict, separated from the filesystem so the whole table is testable in one place.
+export function classifyMember({ installed, expectedDigest, actualDigest }) {
+  if (!installed) return 'missing';
+  if (typeof expectedDigest !== 'string' || expectedDigest.length === 0) return 'refresh';
+  return actualDigest === expectedDigest ? 'unchanged' : 'refresh';
+}
+
+// What this run expects a member to digest to. First-party expectation is computed from THIS
+// invocation's local source root (the private checkout or the unpacked package — both stage the
+// published file set, so the published-scope digest is the same on either transport); an external
+// member's expectation is the reviewed tree digest the recipe carries, or null when it carries none.
+export function expectedMemberDigest(source, member, { localRoot }) {
+  if (firstPartySource(source)) {
+    return contentDigest(join(localRoot, member.path), { published: true });
+  }
+  return typeof member?.contentDigest === 'string' ? member.contentDigest : null;
+}
+
+// Classify one installed member directory against its expectation. `skillsRoot` is the canonical
+// installed store (`~/.agents/skills`); the member lives under it by installName.
+export function classifyInstalledMember(source, member, { localRoot, skillsRoot }) {
+  const directory = join(skillsRoot, member.installName);
+  const entry = { member: member.installName, sourceId: source?.id ?? null, directory };
+  if (!statSync(directory, { throwIfNoEntry: false })?.isDirectory()) {
+    return { ...entry, status: 'missing' };
+  }
+  const expectedDigest = expectedMemberDigest(source, member, { localRoot });
+  const actualDigest = contentDigest(directory, { published: firstPartySource(source) });
+  return {
+    ...entry,
+    status: classifyMember({ installed: true, expectedDigest, actualDigest }),
+    expectedDigest,
+    actualDigest,
+  };
+}
+
+// Every member the selected groups would install/update, classified in recipe step order and
+// deduplicated across groups (the shared support runtime classifies once). The buckets drive both
+// the planner's skip set and the dry-run/no-op rendering. A member the recipe names but its source
+// does not declare gets no expected digest — refresh-or-missing, never a silent skip.
+export function classifySelectedMembers(action, groupIds, { skillsRoot, ...transport } = {}) {
+  if (!ACTIONS.has(action)) throw new Error(`Unsupported bundle action: ${action}`);
+  const { recipesPath, localRoot } = resolveBundleTransport(transport);
+  const recipes = readRecipes(recipesPath);
+  assertLocalRoot(localRoot);
+  const sourcesById = new Map((recipes.sources ?? []).map((source) => [source.id, source]));
+  const groups = new Map(recipes.groups.map((group) => [group.id, group]));
+  const seen = new Set();
+  const buckets = { unchanged: [], refresh: [], missing: [] };
+  for (const groupId of groupIds) {
+    const group = groups.get(groupId);
+    if (!group || SUPPORT_GROUPS.has(groupId)) throw new Error(`Unknown bundle: ${groupId}`);
+    for (const step of group[action].steps) {
+      const source = sourcesById.get(step.sourceId);
+      const membersByName = new Map((source?.members ?? []).map((member) => [member.installName, member]));
+      for (const installName of step.members) {
+        if (seen.has(installName)) continue;
+        seen.add(installName);
+        const member = membersByName.get(installName) ?? { installName };
+        const entry = classifyInstalledMember(source, member, { localRoot, skillsRoot });
+        buckets[entry.status].push(entry);
+      }
     }
   }
-  return 0;
+  return buckets;
+}
+
+function printUpdateBuckets(stdout, buckets) {
+  // Bucket listings are user-facing: the support runtime classifies with everything else (it
+  // drives the planner's skip set) but is never named to the user.
+  const visible = (entry) => !SUPPORT_GROUPS.has(entry.member);
+  const unchanged = buckets.unchanged.filter(visible).map((entry) => entry.member);
+  const refresh = [
+    ...buckets.refresh.filter(visible).map((entry) => entry.member),
+    // Missing accepted members are refresh candidates (reinstall), not "new" — they belong to the
+    // would-refresh bucket, annotated so a dry run explains why an absent skill will be added.
+    ...buckets.missing.filter(visible).map((entry) => `${entry.member} (not installed)`),
+  ];
+  stdout.write(`Unchanged (installed content matches): ${unchanged.length > 0 ? unchanged.join(', ') : 'none'}\n`);
+  stdout.write(`Would refresh: ${refresh.length > 0 ? refresh.join(', ') : 'none'}\n`);
 }
 
 function usage() {
   return `Usage:
   node skills/distribution/scripts/bundles.mjs list [--recipes <path>]
   node skills/distribution/scripts/bundles.mjs <install|update> [--group <id> ... | --all] [--dry-run] [--yes] [--recipes <path>] [--local-root <path>]
+
+install without --group/--all opens the interactive picker; update without them replays the
+remembered selection (\${XDG_STATE_HOME:-~/.local/state}/1aboveio-skills/selection.json).
+When a remembered group's current recipe declares members you have not accepted yet, each new skill
+is offered individually and defaults to No; --yes accepts them all, --dry-run lists them without
+prompting.
 `;
 }
 
@@ -310,35 +618,187 @@ async function promptForGroups(catalog, { stdin = process.stdin, stdout = proces
   });
 }
 
-export async function runCli(args) {
+// A minimal line prompt on the injected streams — deliberately separate from the raw-mode group
+// picker: this is a sequence of independent yes/no questions, not a multi-select. EOF or an empty
+// line is the default answer (No), so a closed or ended stdin can never accept a new skill.
+function createLinePrompter({ stdin, stdout }) {
+  let buffer = '';
+  let ended = false;
+  const waiters = [];
+  const flush = () => {
+    while (waiters.length > 0) {
+      const newline = buffer.search(/\r?\n/);
+      if (newline !== -1) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline).replace(/^\r?\n/, '');
+        waiters.shift()(line.trim());
+      } else if (ended) {
+        const rest = buffer;
+        buffer = '';
+        waiters.shift()(rest.trim());
+      } else {
+        return;
+      }
+    }
+  };
+  stdin.on('data', (chunk) => { buffer += String(chunk); flush(); });
+  stdin.on('end', () => { ended = true; flush(); });
+  stdin.resume?.();
+  return {
+    ask(question) {
+      stdout.write(question);
+      return new Promise((answer) => { waiters.push(answer); flush(); });
+    },
+  };
+}
+
+// Offer each newly declared member individually and return the DECLINED member names (#1128). The
+// default is No: --yes accepts all without prompting; a non-interactive stdin declines all with a
+// note rather than guessing consent; interactively, anything but an explicit y/yes declines.
+async function consentNewMembers(candidates, { yes, stdin, stdout, stderr }) {
+  const declined = new Set();
+  if (yes) {
+    for (const candidate of candidates) {
+      stdout.write(`Accepting new skill "${candidate.member}" in ${candidate.groupName} (--yes)\n`);
+    }
+    return declined;
+  }
+  if (!stdin.isTTY) {
+    for (const candidate of candidates) {
+      stderr.write(`Declining new skill "${candidate.member}" in ${candidate.groupName}: no interactive terminal (default No; re-run with --yes to accept)\n`);
+      declined.add(candidate.member);
+    }
+    return declined;
+  }
+  const prompter = createLinePrompter({ stdin, stdout });
+  for (const candidate of candidates) {
+    const answer = await prompter.ask(`Add new skill "${candidate.member}" to ${candidate.groupName} (${candidate.groupId})? [y/N] `);
+    if (/^y(es)?$/i.test(answer)) {
+      stdout.write(`Adding ${candidate.member}\n`);
+    } else {
+      stdout.write(`Skipping ${candidate.member}\n`);
+      declined.add(candidate.member);
+    }
+  }
+  return declined;
+}
+
+// Dependencies are injectable so the coordinator seam can be tested black-box: a stubbed native
+// executor, controllable TTY streams, and a fixture XDG environment, without reaching process
+// globals. The default execute is the real shell out to the native Skills CLI — the sole
+// lifecycle write authority; the coordinator only selects, plans, invokes, and persists memory
+// AFTER those native commands settle.
+export async function runCli(args, {
+  execute,
+  stdin = process.stdin,
+  stdout = process.stdout,
+  stderr = process.stderr,
+  env = process.env,
+} = {}) {
   try {
     const parsed = parseArgs(args);
     const transport = { recipesPath: parsed.recipesPath, localRoot: parsed.localRoot };
     if (parsed.action === 'list') {
-      printCatalog(process.stdout, bundleCatalog(transport));
+      printCatalog(stdout, bundleCatalog(transport));
       return 0;
     }
     if (!ACTIONS.has(parsed.action)) {
-      process.stderr.write(usage());
+      stderr.write(usage());
       return 2;
     }
     const catalog = bundleCatalog(transport);
-    const groupIds = parsed.all
-      ? catalog.map((bundle) => bundle.id)
-      : parsed.groupIds.length > 0
-        ? parsed.groupIds
-        : await promptForGroups(catalog);
+    let groupIds;
+    let priorState = null;
+    if (parsed.all) {
+      groupIds = catalog.map((bundle) => bundle.id);
+      priorState = loadPriorSelection(env);
+    } else if (parsed.groupIds.length > 0) {
+      groupIds = parsed.groupIds;
+      priorState = loadPriorSelection(env);
+    } else if (parsed.action === 'update') {
+      // No-arg update replays the remembered selection. It never opens the picker and never
+      // infers groups from the filesystem: missing/corrupt/foreign memory is a hard error.
+      const { state } = loadSelectionState(env);
+      priorState = state;
+      groupIds = rememberedGroupIds(state, catalog, stderr);
+    } else {
+      groupIds = await promptForGroups(catalog, { stdin, stdout });
+      priorState = loadPriorSelection(env);
+    }
     if (groupIds.length === 0) throw new Error('Select at least one bundle');
-    const commands = planBundleCommands(parsed.action, groupIds, { ...transport, yes: parsed.yes });
+    // New-member consent (#1128): newly declared user-facing members of a group with prior
+    // acceptance are offered one at a time, defaulting to No. A dry run only LISTS the would-be
+    // candidates — it never prompts and never writes state.
+    const candidates = newMemberCandidates(parsed.action, groupIds, priorState, transport);
+    let declined = new Set();
+    if (candidates.length > 0 && parsed.dryRun) {
+      for (const candidate of candidates) {
+        stdout.write(`New skill "${candidate.member}" in ${candidate.groupName} (${candidate.groupId}) — would prompt for consent (default: No); --yes accepts all new skills\n`);
+      }
+    } else if (candidates.length > 0) {
+      declined = await consentNewMembers(candidates, { yes: parsed.yes, stdin, stdout, stderr });
+    }
+    // Digest skip (#1127): `update` classifies the accepted members against the installed tree and
+    // omits the digest-equal ones from the native add. `install` never skips — it is an explicit
+    // request to install, whose overwrite consent belongs to the native prompt. Declined new
+    // members (#1128) are excluded from classification: they never run, so they are not buckets.
+    let buckets;
+    let skipMembers;
+    if (parsed.action === 'update') {
+      const skillsRoot = join(env.HOME || homedir(), '.agents', 'skills');
+      buckets = classifySelectedMembers(parsed.action, groupIds, { ...transport, skillsRoot });
+      skipMembers = new Set(buckets.unchanged.map((entry) => entry.member));
+      if (declined.size > 0) {
+        for (const key of Object.keys(buckets)) {
+          buckets[key] = buckets[key].filter((entry) => !declined.has(entry.member));
+        }
+      }
+    }
+    const commands = planBundleCommands(parsed.action, groupIds, { ...transport, yes: parsed.yes, skipMembers, omitMembers: declined });
     if (parsed.dryRun) {
+      if (buckets) printUpdateBuckets(stdout, buckets);
       for (const planned of commands) {
-        process.stdout.write(`\n${planned.groupName} / ${planned.sourceId}\n${planned.command}\n`);
+        stdout.write(`\n${planned.groupName} / ${planned.sourceId} / ${planned.member}\n${planned.command}\n`);
       }
+      if (buckets && commands.length === 0) stdout.write('Nothing to do: every accepted skill is already up to date.\n');
       return 0;
     }
-    return runBundleCommands(commands);
+    if (commands.length === 0 && buckets) {
+      stdout.write('All accepted skills are already up to date; nothing to do.\n');
+    } else if (buckets?.unchanged.length > 0) {
+      const skipping = buckets.unchanged.map((entry) => entry.member).filter((member) => !SUPPORT_GROUPS.has(member));
+      if (skipping.length > 0) stdout.write(`Up to date, skipping: ${skipping.join(', ')}\n`);
+    }
+    const { succeeded, failed } = runBundleCommands(commands, { execute, stdout, stderr });
+    printRunSummary(stdout, {
+      succeeded,
+      failed,
+      unchanged: buckets?.unchanged.map((entry) => entry.member),
+      declined: [...declined],
+    });
+    // Mixed-success memory (#1129): retain only user-facing members that either succeeded at
+    // native add or were already digest-equal. A group with no recordable member is omitted from
+    // the written set, and a run with no recordable member at all leaves prior memory untouched;
+    // a decline never becomes remembered acceptance.
+    const succeededMembers = [
+      ...succeeded.map((planned) => planned.member),
+      ...(buckets?.unchanged.map((entry) => entry.member) ?? []),
+    ];
+    if (succeededMembers.length > 0) {
+      const renderTarget = declaredRenderTarget(transport);
+      const selection = selectionForRun(parsed.action, groupIds, {
+        ...transport,
+        renderTarget,
+        succeededMembers,
+        omitMembers: declined,
+      });
+      if (selection.groups.length > 0) {
+        writeSelectionState(selection, env);
+      }
+    }
+    return failed.length > 0 ? failed[0].status : 0;
   } catch (error) {
-    process.stderr.write(`${error.message}\n`);
+    stderr.write(`${error.message}\n`);
     return 2;
   }
 }