@iseoane/agent-depot 0.6.9 → 0.6.10

package/dist/src/project-target.js

@@ -0,0 +1,58 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { assertNoSymlinkPath, SymlinkPathError } from "./path-safety.js";
+import { HOST_PROJECT_DIRECTORIES } from "./project-manifest.js";
+import { CliUsageError } from "./usage-error.js";
+/** `.agents` is the canonical Skill location the Hosts share, so it also marks a project that already uses Skills. */
+const PROJECT_DIRECTORIES = [".agents", ...Object.values(HOST_PROJECT_DIRECTORIES)];
+/** The warnings are advisory, so an entry that cannot be read counts as absent. */
+async function exists(candidate) {
+    return stat(candidate).then(() => true, () => false);
+}
+/**
+ * Nearest ancestor-or-self holding a `.git` entry. A file marks a linked
+ * worktree or submodule, so any `.git` entry counts. Walking the filesystem
+ * avoids spawning `git` and cannot reach the network.
+ */
+async function findGitTopLevel(start) {
+    for (let current = start;; current = path.dirname(current)) {
+        if (await exists(path.join(current, ".git")))
+            return current;
+        if (path.dirname(current) === current)
+            return undefined;
+    }
+}
+/**
+ * The lines every project-scope preview starts with: the project root the
+ * Skills are installed into, then non-blocking warnings about a root that is
+ * probably not the intended one. A brand-new project is legitimate, so nothing
+ * here refuses.
+ */
+export async function describeProjectTarget(projectRoot, manifestPath) {
+    const lines = [`Project: ${projectRoot}`];
+    const gitTopLevel = await findGitTopLevel(projectRoot);
+    if (gitTopLevel !== undefined && path.relative(gitTopLevel, projectRoot) !== "") {
+        lines.push(`  WARNING: this directory is inside the Git repository at ${gitTopLevel} but is not its top level; Skills will be installed here, not at the repository root`);
+    }
+    const markers = [manifestPath, ...PROJECT_DIRECTORIES.map((directory) => path.join(projectRoot, directory))];
+    if (!(await Promise.all(markers.map(exists))).some(Boolean)) {
+        lines.push(`  WARNING: this directory has no project manifest (${path.basename(manifestPath)}) and none of ${PROJECT_DIRECTORIES.join(", ")}; confirm it is the intended project directory`);
+    }
+    return lines;
+}
+/** Resolves a `--project` value against the working directory; it must be an existing directory without symbolic links. */
+export async function resolveProjectRootOption(value) {
+    const root = path.resolve(value);
+    const information = await stat(root).catch((error) => {
+        if (typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+            throw new CliUsageError(`--project ${JSON.stringify(value)} does not exist`);
+        }
+        throw error;
+    });
+    if (!information.isDirectory())
+        throw new CliUsageError(`--project ${JSON.stringify(value)} is not a directory`);
+    await assertNoSymlinkPath(root, `--project ${JSON.stringify(value)}`).catch((error) => {
+        throw error instanceof SymlinkPathError ? new CliUsageError(error.message) : error;
+    });
+    return root;
+}

package/dist/src/skill-discovery.js

@@ -13,6 +13,21 @@ export const EXCLUDED_LIFECYCLE_SEGMENTS = Object.freeze([
     "retired",
 ]);
 const excludedLifecycleSegments = new Set(EXCLUDED_LIFECYCLE_SEGMENTS);
+/**
+ * Directories where other coding agents keep generated copies of a Source's
+ * Skills. Agent Depot manages Claude, Codex, Pi and OpenCode only, so a Skill
+ * found below one of these is a mirror of the real one, never a candidate.
+ * `.claude`, `.agents`, `.codex`, `.pi` and `.opencode` are deliberately absent.
+ */
+const UNMANAGED_HOST_MIRROR_SEGMENTS = Object.freeze([
+    ".cursor", "cursor-plugin", ".windsurf", ".gemini", ".github", ".kiro", ".trae", ".trae-cn", ".devin", ".dsh",
+    ".hermes", ".veto", ".cline", ".roo", ".continue", ".augment", ".goose", ".amazonq", ".junie", ".kilocode",
+    ".qwen", ".agent", ".factory", ".crush", ".openhands", ".codebuddy", ".qoder", ".zed",
+]);
+/** Test and fixture trees hold sample Skills; only ancestors count, so a Skill directory may be named `test`. */
+const TEST_TREE_SEGMENTS = Object.freeze(["tests", "test", "__tests__", "fixtures", "__fixtures__"]);
+const unmanagedMirrorSegments = new Set(UNMANAGED_HOST_MIRROR_SEGMENTS);
+const testTreeSegments = new Set(TEST_TREE_SEGMENTS);
 /**
  * The package-owned root used for built-in skills. A missing root is an empty
  * built-in Source, which lets packages ship no built-in skills yet.
@@ -121,6 +136,7 @@ export function skillTreeBaseline(files) {
 export async function discoverSkillsFromSources(sources, contentAccess) {
     const candidates = [];
     for (const source of sources) {
+        const found = [];
         const files = [...await contentAccess.readSnapshot(source)].sort((left, right) => left.path.localeCompare(right.path));
         for (const file of files) {
             const normalizedPath = normalizeSourcePath(file.path);
@@ -129,23 +145,87 @@ export async function discoverSkillsFromSources(sources, contentAccess) {
             }
             const directoryPath = path.posix.dirname(normalizedPath);
             const segments = directoryPath === "." ? [] : directoryPath.split("/");
-            if (segments.some((segment) => excludedLifecycleSegments.has(segment))) {
+            if (segments.some((segment) => excludedLifecycleSegments.has(segment) || unmanagedMirrorSegments.has(segment))
+                || segments.slice(0, -1).some((segment) => testTreeSegments.has(segment))) {
                 continue;
             }
             const metadata = parseSkillFrontmatter(file.content);
             if (!metadata) {
                 continue;
             }
-            candidates.push({
-                sourceId: source.id,
-                path: directoryPath,
-                name: metadata.name,
-                description: metadata.description,
+            found.push({
+                candidate: { sourceId: source.id, path: directoryPath, name: metadata.name, description: metadata.description },
+                digest: createHash("sha256").update(file.content, "utf8").digest("hex"),
             });
         }
+        candidates.push(...await collapseIdenticalSkills(source, found, files, contentAccess));
     }
     return Object.freeze(candidates);
 }
+/**
+ * One candidate per Skill name and whole-directory digest within a Source,
+ * because a repository often repeats the same Skill under several directories.
+ * Only candidates already sharing a name and SKILL.md digest are compared by
+ * their full tree. The canonical copy is the one outside dot-directories, then
+ * the shallowest, then the first by path, so the choice never depends on
+ * snapshot order. Same-named Skills with different content all stay. Survivors
+ * keep their path order.
+ */
+async function collapseIdenticalSkills(source, found, snapshot, contentAccess) {
+    const sameManifest = new Map();
+    for (const { candidate, digest } of found) {
+        const key = `${candidate.name}|${digest}`;
+        sameManifest.set(key, (sameManifest.get(key) ?? 0) + 1);
+    }
+    const best = new Map();
+    for (const { candidate, digest } of found) {
+        const manifestKey = `${candidate.name}|${digest}`;
+        const key = sameManifest.get(manifestKey) > 1
+            ? `${manifestKey}|${await skillDirectoryDigest(source, candidate.path, snapshot, contentAccess)}`
+            : manifestKey;
+        const current = best.get(key);
+        if (current === undefined || compareCanonical(candidate.path, current.path) < 0) {
+            best.set(key, candidate);
+        }
+    }
+    const survivors = new Set(best.values());
+    return found.filter(({ candidate }) => survivors.has(candidate)).map(({ candidate }) => candidate);
+}
+/**
+ * Digest of every file of a Skill directory, by relative path and bytes. Reads
+ * the whole tree from the Source when the access supports it, otherwise uses the
+ * snapshot files. A tree that cannot be read digests to its own path, so it is
+ * never collapsed into another.
+ */
+async function skillDirectoryDigest(source, directory, snapshot, contentAccess) {
+    const prefix = `${directory}/`;
+    try {
+        const files = contentAccess.readSkillTree
+            ? [...await contentAccess.readSkillTree(source, directory)]
+            : snapshot.filter((file) => file.path.startsWith(prefix)).map((file) => ({
+                path: file.path,
+                content: Buffer.from(file.content, "utf8"),
+                executable: false,
+            }));
+        return skillTreeBaseline(files.map((file) => ({ ...file, path: file.path.startsWith(prefix) ? file.path.slice(prefix.length) : file.path }))).digest;
+    }
+    catch {
+        return `unreadable:${directory}`;
+    }
+}
+function compareCanonical(left, right) {
+    const rank = (candidate) => {
+        const segments = candidate.split("/");
+        return [segments.some((segment) => segment.startsWith(".")) ? 1 : 0, segments.length];
+    };
+    const [leftHidden, leftDepth] = rank(left);
+    const [rightHidden, rightDepth] = rank(right);
+    if (leftHidden !== rightHidden)
+        return leftHidden - rightHidden;
+    if (leftDepth !== rightDepth)
+        return leftDepth - rightDepth;
+    return left < right ? -1 : left > right ? 1 : 0;
+}
 /** Collects scalar frontmatter values up to the closing delimiter; undefined when malformed or unclosed. */
 function readFrontmatterValues(lines) {
     const values = new Map();

package/dist/src/skill-install.js

@@ -2,8 +2,9 @@ import path from "node:path";
 import { assertSkillNotAppOwned } from "./app-owned-skills.js";
 import { assertSkillNotPackageOwned, loadPackageOwnedSkillFilter, } from "./package-owned-skills.js";
 import { pathsOverlap } from "./path-safety.js";
+import { describeProjectTarget } from "./project-target.js";
 import { inspectProjectSkillInstallation, installProjectSkillTransaction, validateProjectSkillInstallationPreview, } from "./project-installation.js";
-import { AGENT_DEPOT_PACKAGE_VERSION, parseProjectManifest, } from "./project-manifest.js";
+import { AGENT_DEPOT_PACKAGE_VERSION, defaultProjectManifestPath, parseProjectManifest, } from "./project-manifest.js";
 import { createSourceContentAccess } from "./skill-discovery.js";
 import { relativeProjectPath, selectionWithInstallation } from "./skill-update.js";
 import { executeSourceInstallationMethod, parseSourceInstallationMethod, resolveProjectSource, SourceNotFoundError, } from "./sources.js";
@@ -12,7 +13,7 @@ import { CliUsageError } from "./usage-error.js";
  * Shared install flow for one Skill selection (project or user-global):
  * resolve, inspect, preview, then execute. Used by the CLI and the TUI.
  */
-const INSTALL_USAGE = "Usage: agent-depot install --scope <project|user-global> --source <id> --skill <path> --host <host>... --version <latest|version> [--ref <git-ref>] [--method <json>] --portable-v1 [--overwrite --yes] [--confirm-additional-host]";
+const INSTALL_USAGE = "Usage: agent-depot install --scope <project|user-global> --source <id> --skill <path> --host <host>... --version <latest|version> [--ref <git-ref>] [--method <json>] --portable-v1 [--overwrite --yes] [--confirm-additional-host] [--project <path>]";
 export async function selectInstallSource(options, operations) {
     const source = await findSource(operations, options.sourceId);
     const projectSource = projectSourceFromSource(source, options.ref, options.version);
@@ -314,12 +315,17 @@ export async function planSingleInstall(request, context) {
     }
     const { resolvedSource, resolved, installationInspection } = await resolveInstallInspection(selection, source, projectSource, context.root, request, context.operations, context.environment, context.sourceAccess);
     await assertInstallNotAppOwned(request, context, installationInspection);
-    await assertInstallNotPackageOwned(selection, resolvedSource, context);
-    return { request, context, selection, source, resolvedSource, resolved, inspection: installationInspection };
+    await assertInstallNotPackageOwned(request, selection, resolvedSource, context);
+    const projectTarget = request.scope === "project"
+        ? await describeProjectTarget(context.root, context.manifestPath ?? defaultProjectManifestPath(context.root))
+        : [];
+    return { request, context, selection, source, resolvedSource, resolved, inspection: installationInspection, projectTarget };
 }
 /** Prints the preview the user confirms before {@link executeSingleInstall}. */
 export function outputSingleInstallPreview(plan, output) {
-    const { request, context, selection, source, resolved, inspection } = plan;
+    const { request, context, selection, source, resolved, inspection, projectTarget } = plan;
+    for (const line of projectTarget)
+        output(line);
     outputInstallPreview(selection, source, context.root, output, resolved.files, resolved.method, request.scope, inspection, request.overwrite, request.confirmed);
 }
 /**
@@ -329,7 +335,7 @@ export function outputSingleInstallPreview(plan, output) {
 export async function executeSingleInstall(plan, persist, output) {
     const { request, context, selection, resolvedSource, resolved, inspection } = plan;
     await assertInstallNotAppOwned(request, context, inspection);
-    await assertInstallNotPackageOwned(selection, resolvedSource, context);
+    await assertInstallNotPackageOwned(request, selection, resolvedSource, context);
     const protectedPaths = assertNoManagedInstallationOverlap(context.existing, selection, inspection, context.root, request.overwrite);
     rejectInstallationCollision(inspection, request.overwrite);
     const transaction = await installOne(selection, resolvedSource, context.sourceAccess, context.root, context.environment, resolved.method, request.portableV1, resolved.files, resolved.resolvedVersion, request.confirmAdditionalHostExposure, request.overwrite, inspection, protectedPaths);
@@ -375,8 +381,14 @@ async function assertInstallNotAppOwned(request, context, inspection) {
         await assertSkillNotAppOwned(path.basename(location.path), { ...context.environment, homeDirectory: context.root });
     }
 }
-/** Reloads bundle ownership from the selected Source and refuses its own Skill paths. */
-async function assertInstallNotPackageOwned(selection, source, context) {
+/**
+ * Reloads bundle ownership from the selected Source and refuses its own Skill paths.
+ * Package state lives under the user's home, so a project install has nothing to
+ * check and must not read or lock state derived from the project root.
+ */
+async function assertInstallNotPackageOwned(request, selection, source, context) {
+    if (request.scope !== "user-global")
+        return;
     const owned = await loadPackageOwnedSkillFilter({
         sources: [source],
         homeDirectory: context.root,

package/dist/src/tui/app-actions.js

@@ -5,7 +5,10 @@ import { errorText, runBatch } from "./batch.js";
 import { hostChecklistKey, movePreviewCursor } from "./mode-keys.js";
 import { BorderPanel, HostChecklist, PreviewConfirm, Working } from "./panel-parts.js";
 import { previewViewport } from "./preview-window.js";
+import { theme } from "./theme.js";
 import { operationStart } from "./working-model.js";
+/** Finished items shown under a running batch; older ones are counted. */
+const MAX_DONE_LINES = 3;
 export const APP_KINDS = ["app-busy", "app-approve", "app-hosts", "app-confirm", "app-manual"];
 /** Narrows the view's mode without asserting a partial mode is an App mode. */
 export function isAppMode(mode) {
@@ -61,15 +64,21 @@ function appPreviewLines(mode) {
     ];
 }
 /** The busy mode of an App step; `previous` is the busy mode this step continues, so the clock keeps running. */
-function appBusy(label, previous) {
-    return { kind: "app-busy", label, startedAt: operationStart(previous) };
+function appBusy(label, previous, done) {
+    return { kind: "app-busy", label, startedAt: operationStart(previous), ...(done?.length ? { done } : {}) };
+}
+/** `Running App step: name (2/5)…`; the position is left out for a batch of one. */
+function stepLabel(verb, entry, finished, total) {
+    return `${verb} App step: ${appName(entry)}${total > 1 ? ` (${finished + 1}/${total})` : ""}…`;
 }
 async function prepareNext(context, requests, results = [], failures = 0, previous) {
     const { manage, apps } = context;
-    const running = appBusy("Preparing App step…", previous);
-    manage.setMode(running);
     // Independent planning failures never stop the remaining marked Apps.
     const [request, ...remaining] = requests;
+    const running = appBusy(request ? stepLabel("Preparing", request.entry, results.length, results.length + requests.length) : "Finishing App steps…", previous, 
+    // Once the batch is over its results are the Result panel, not a busy line.
+    request ? results : undefined);
+    manage.setMode(running);
     if (!request) {
         await manage.finish({ kind: failures > 0 ? "error" : "ok", text: results.join("\n") });
         return;
@@ -124,7 +133,7 @@ export async function startAppAction(context, entries, input) {
 }
 async function execute(context, mode) {
     const { manage, apps } = context;
-    const running = appBusy("Running App step…");
+    const running = appBusy(stepLabel("Running", mode.plan.entry, mode.results.length, mode.results.length + 1 + mode.remaining.length), undefined, mode.results);
     manage.setMode(running);
     let manualRequired = false;
     const [outcome] = await runBatch([mode.plan], async (plan) => {
@@ -201,8 +210,10 @@ export function handleAppKey(context, mode, input, key) {
 /** Renders App prompts using the existing checklist and preview-confirm panels. */
 export function AppPanel({ mode }) {
     const { rows, columns } = useWindowSize();
-    if (mode.kind === "app-busy")
-        return _jsx(BorderPanel, { title: "App lifecycle", children: _jsx(Working, { label: mode.label, since: mode.startedAt }) });
+    if (mode.kind === "app-busy") {
+        const done = mode.done ?? [];
+        return (_jsxs(BorderPanel, { title: "App lifecycle", children: [_jsx(Working, { label: mode.label, since: mode.startedAt }), done.length > MAX_DONE_LINES ? _jsxs(Text, { color: theme.muted, children: [done.length - MAX_DONE_LINES, " earlier finished"] }) : null, done.slice(-MAX_DONE_LINES).map((line, index) => _jsx(Text, { color: theme.muted, children: line }, index))] }));
+    }
     if (mode.kind === "app-hosts") {
         return (_jsxs(BorderPanel, { title: "App Host steps", children: [_jsx(Text, { children: "Checked = setup. Unchecked = teardown. Wiring is not tracked." }), _jsxs(Text, { children: ["Space/1-", mode.choices.length, " toggle \u00B7 j/k move \u00B7 Enter continue \u00B7 Esc cancel"] }), _jsx(HostChecklist, { choices: mode.choices, cursor: mode.cursor, selected: mode.selected })] }));
     }

package/dist/src/tui/app.js

@@ -10,6 +10,7 @@ import { ProfileView } from "./profile-view.js";
 import { SourcesView, sourceRowHints } from "./sources-view.js";
 import { theme } from "./theme.js";
 import { UpdatesView } from "./updates-view.js";
+import { createViewRetention, invalidateRetention } from "./view-retention.js";
 /** Sources derives its own hints from the selected row, so it is excluded here. */
 function hintsOf(view, catalogFocusedOnSource) {
     switch (view) {
@@ -33,14 +34,28 @@ export function App({ operations, environment, onExit }) {
     const [capturing, setCapturing] = useState(false);
     // Updated synchronously by the views so keys in the same burst never see a stale capturing state.
     const capturingRef = useRef(false);
+    const [view, setView] = useState("sources");
+    // Catalog and Installations unmount on a tab change; this keeps what they loaded, for display only.
+    const [retention] = useState(createViewRetention);
+    // Sources, Updates and Profile may change what the retained data describes. Any mode they capture
+    // keys for (add, refresh, approve, confirm, import) can, so leaving after one drops the retention.
+    const viewRef = useRef(view);
+    const touched = useRef(false);
     const onCapturingChange = useCallback((value) => {
         capturingRef.current = value;
+        if (value && viewRef.current !== "catalog" && viewRef.current !== "installations")
+            touched.current = true;
         setCapturing(value);
     }, []);
-    const [view, setView] = useState("sources");
     const [catalogSourceId, setCatalogSourceId] = useState();
     const [sourcesHints, setSourcesHints] = useState(sourceRowHints(undefined));
-    const showView = (next) => setView(next);
+    const showView = (next) => {
+        if (touched.current)
+            invalidateRetention(retention);
+        touched.current = false;
+        viewRef.current = next;
+        setView(next);
+    };
     useKeys((input, key) => {
         if (capturingRef.current)
             return;
@@ -66,8 +81,8 @@ export function App({ operations, environment, onExit }) {
     });
     return (_jsxs(Box, { flexDirection: "column", height: rows, children: [_jsx(Header, { view: view, columns: columns }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: view === "sources" ? (_jsx(SourcesView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange, onHintsChange: setSourcesHints, onOpenCatalog: (source) => {
                         setCatalogSourceId(source.id);
-                        setView("catalog");
-                    } })) : view === "installations" ? (_jsx(InstallationsView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange })) : view === "profile" ? (_jsx(ProfileView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange })) : view === "updates" ? (_jsx(UpdatesView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange })) : (_jsx(CatalogView, { operations: operations, sourceId: catalogSourceId, environment: environment, onCapturingChange: onCapturingChange })) }), _jsx(Text, { color: theme.muted, children: capturing
+                        showView("catalog");
+                    } })) : view === "installations" ? (_jsx(InstallationsView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange, retention: retention })) : view === "profile" ? (_jsx(ProfileView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange })) : view === "updates" ? (_jsx(UpdatesView, { operations: operations, environment: environment, onCapturingChange: onCapturingChange })) : (_jsx(CatalogView, { operations: operations, sourceId: catalogSourceId, environment: environment, onCapturingChange: onCapturingChange, retention: retention })) }), _jsx(Text, { color: theme.muted, children: capturing
                     ? columns < 64 ? "Enter submit · Esc cancel" : "Enter submit · Esc cancel · y/n confirm · space toggle"
                     : view === "sources" ? sourcesHints : hintsOf(view, catalogSourceId !== undefined) })] }));
 }

package/dist/src/tui/batch.js

@@ -3,9 +3,10 @@ export const errorText = (error) => (error instanceof Error ? error.message : St
  * Applies the items one after another. A failure is reported for that item and
  * the rest still run, so the outcomes always cover every item in order.
  */
-export async function runBatch(items, run, describeFailure) {
+export async function runBatch(items, run, describeFailure, onStart) {
     const outcomes = [];
     for (const item of items) {
+        onStart?.(item, outcomes.length + 1, items.length, outcomes);
         try {
             outcomes.push({ item, ok: true, line: await run(item) });
         }

package/dist/src/tui/bulk-actions.js

@@ -78,8 +78,16 @@ function resultOf(outcomes, skipped) {
         applied: outcomes.filter((outcome) => outcome.ok).map((outcome) => outcome.item.id),
     };
 }
+/** `Removing name (2/5)…` for each item as it starts. */
+function startOf(verb, progress) {
+    if (!progress)
+        return undefined;
+    return (item, position, total, finished) => {
+        progress(`${verb} ${item.label} (${position}/${total})…`, finished.map(outcome => outcome.line));
+    };
+}
 /** Execute step: each item is rechecked and applied on its own against the records the previous items were expected to leave. */
-export async function runBulkUninstall(plan, operations, env) {
+export async function runBulkUninstall(plan, operations, env, progress) {
     let expected = plan.installations;
     const outcomes = await runBatch(plan.items, async (item) => {
         await assertNoDrift(operations, expected);
@@ -95,7 +103,7 @@ export async function runBulkUninstall(plan, operations, env) {
         return item.prepared.plan.inspections.every((inspection) => inspection.recordOnly)
             ? `Forgot missing installation record for ${item.label}; no files were removed`
             : `Removed ${item.label}`;
-    }, (item, error) => (item.kind === "unmanaged" ? errorText(error) : `Failed ${item.label}: ${errorText(error)}`));
+    }, (item, error) => (item.kind === "unmanaged" ? errorText(error) : `Failed ${item.label}: ${errorText(error)}`), startOf("Removing", progress));
     return resultOf(outcomes, plan.skipped);
 }
 /** Managed user-global leaves that can gain hosts, and the leaves that cannot with their reasons. */
@@ -146,7 +154,7 @@ export async function prepareBulkHostAddition(context, targets, alreadySkipped,
     return { items, skipped, installations };
 }
 /** Execute step: the single exposure confirmation covers every item; each one is rechecked on its own. */
-export async function runBulkHostAddition(plan, operations, env) {
+export async function runBulkHostAddition(plan, operations, env, progress) {
     let expected = plan.installations;
     const outcomes = await runBatch(plan.items, async (item) => {
         await assertNoDrift(operations, expected);
@@ -155,7 +163,7 @@ export async function runBulkHostAddition(plan, operations, env) {
         const { selection, updated } = item.prepared.plan;
         expected = expected.map((record) => (sameRecord(record, selection) ? updated : record));
         return line;
-    }, (item, error) => `Failed ${item.label}: ${errorText(error)}`);
+    }, (item, error) => `Failed ${item.label}: ${errorText(error)}`, startOf("Changing hosts of", progress));
     return resultOf(outcomes, plan.skipped);
 }
 function cancel(context, text) {
@@ -202,10 +210,15 @@ function prepareHosts(context, mode) {
     return preparePlan(context, `Preparing host change of ${count(mode.targets.length, "item")}…`, () => prepareBulkHostAddition(context, mode.targets, mode.skipped, mode.selected), (plan) => ({ kind: "confirm-bulk-hosts", plan }));
 }
 async function apply(context, label, action) {
-    context.setMode(busy(label));
+    const started = busy(label);
+    context.setMode(started);
     let result;
     try {
-        result = await action();
+        // Each item names itself, but the clock of the whole batch keeps running.
+        result = await action((itemLabel, done) => {
+            if (context.isMounted())
+                context.setMode({ ...busy(itemLabel, started), done });
+        });
     }
     catch (error) {
         result = { message: { kind: "error", text: errorText(error) }, applied: [] };
@@ -229,7 +242,7 @@ export function handleBulkKey(context, mode, input, key) {
         }
         case "confirm-bulk-uninstall":
             answerYesNo(input, key, () => {
-                void apply(context, `Removing ${count(current.plan.items.length, "item")}…`, () => runBulkUninstall(current.plan, operations, env));
+                void apply(context, `Removing ${count(current.plan.items.length, "item")}…`, (progress) => runBulkUninstall(current.plan, operations, env, progress));
             }, () => cancel(context, "Uninstall cancelled"));
             return true;
         case "confirm-bulk-hosts":
@@ -237,7 +250,7 @@ export function handleBulkKey(context, mode, input, key) {
             return true;
         case "confirm-bulk-exposure":
             answerYesNo(input, key, () => {
-                void apply(context, `Changing hosts of ${count(current.plan.items.length, "item")}…`, () => runBulkHostAddition(current.plan, operations, env));
+                void apply(context, `Changing hosts of ${count(current.plan.items.length, "item")}…`, (progress) => runBulkHostAddition(current.plan, operations, env, progress));
             }, () => cancel(context, "Add hosts cancelled"));
             return true;
         default:

package/dist/src/tui/catalog-installs.js

@@ -83,17 +83,18 @@ export async function prepareInstall(operations, environment, skill, choice) {
             root: path.resolve(environment.projectRoot ?? process.cwd()),
             existing: (await manifestStore.load()).skills,
             recordedIn: manifestStore.path,
+            manifestPath: manifestStore.path,
         });
     }
     const lines = [];
     outputSingleInstallPreview(plan, (line) => lines.push(line));
     // The TUI confirms interactively, so the CLI's --yes wording does not apply.
-    const preview = lines.filter((line) => !line.startsWith("  confirmation:"));
+    const preview = lines.filter((line) => !plan.projectTarget.includes(line) && !line.startsWith("  confirmation:"));
     const additionalHostExposure = needsAdditionalHostExposure(plan.inspection, choice.hosts);
     if (additionalHostExposure) {
         preview.push("  ADDITIONAL HOST EXPOSURE: an identical Skill already exists; installing adds the missing Host location (equivalent to --confirm-additional-host) and needs a separate confirmation");
     }
-    return { plan, manifestStore, preview, runsExternalCommand: plan.resolved.method !== undefined, additionalHostExposure };
+    return { plan, manifestStore, projectTarget: plan.projectTarget, preview, runsExternalCommand: plan.resolved.method !== undefined, additionalHostExposure };
 }
 /** Execute step: installs and persists the record; returns the result lines. */
 export async function runInstall(prepared, operations, confirmAdditionalHostExposure = false) {

package/dist/src/tui/catalog-panel.js

@@ -19,7 +19,7 @@ export function CatalogRowLine({ row, selected, marked, installed }) {
     const isGroup = data.kind === "source" || data.kind === "group";
     const ownedBy = data.kind === "skill" ? data.ownedBy : undefined;
     return (_jsxs(Text, { ...rowStyle(selected), color: isGroup ? theme.group : undefined, wrap: "truncate-end", children: [selected ? "> " : "  ", "  ".repeat(row.depth), data.kind === "skill" ? marked ? "[x] " : "[ ] " : "", data.kind === "skill" && ownedBy !== undefined
-                ? _jsxs(_Fragment, { children: [data.skill.name, _jsxs(Text, { color: theme.marker, children: ["  ", "[", packageOwnerBadge(ownedBy), "]"] }), "  ", truncateDescription(data.skill.description)] })
+                ? _jsxs(_Fragment, { children: [data.skill.name, _jsxs(Text, { color: theme.marker, children: ["  ", "[", packageOwnerBadge(ownedBy), "]"] }), "  ", truncateDescription(data.skill.description), data.variant === true ? `  (${data.skill.path})` : ""] })
                 : data.kind === "app" ? `App ${data.row.entry.recipe?.name ?? data.row.entry.file}` : describeRow(row), data.kind === "app" ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.legend, children: "  " }), _jsx(Text, { color: data.row.inspection.status === "not installed" ? theme.warning : theme.value, children: data.row.inspection.status })] })) : null, data.kind === "skill" && hasUnmanagedCopy(data.skill, installed)
                 ? _jsxs(Text, { color: theme.marker, children: ["  ", UNMANAGED_MARKER] })
                 : null] }));
@@ -47,7 +47,8 @@ export function ActionPanel({ mode }) {
         case "confirm-install": {
             const ready = mode.items.filter((item) => item.prepared !== undefined);
             const single = mode.items.length === 1;
-            return (_jsxs(BorderPanel, { title: `Skill install preview · ${ready.length} ready`, children: [mode.items.map(({ skill, prepared, error }) => prepared === undefined ? (_jsxs(Text, { color: theme.error, children: ["Cannot install ", skill.name, ": ", error] }, skillKey(skill))) : (_jsxs(Box, { flexDirection: "column", children: [single ? null : _jsx(Text, { color: theme.group, children: skill.name }), _jsx(PreviewLines, { lines: prepared.preview })] }, skillKey(skill)))), ready.some((item) => item.prepared?.runsExternalCommand) ? _jsx(Text, { color: theme.warning, children: "This install runs an external command (see above)." }) : null, _jsxs(DecisionPrompt, { children: ["Install ", describeSkills(ready.map((item) => item.skill)), "?"] })] }));
+            const projectTarget = ready[0]?.prepared?.projectTarget ?? [];
+            return (_jsxs(BorderPanel, { title: `Skill install preview · ${ready.length} ready`, children: [projectTarget.length === 0 ? null : _jsx(PreviewLines, { lines: projectTarget }), mode.items.map(({ skill, prepared, error }) => prepared === undefined ? (_jsxs(Text, { color: theme.error, children: ["Cannot install ", skill.name, ": ", error] }, skillKey(skill))) : (_jsxs(Box, { flexDirection: "column", children: [single ? null : _jsx(Text, { color: theme.group, children: skill.name }), _jsx(PreviewLines, { lines: prepared.preview })] }, skillKey(skill)))), ready.some((item) => item.prepared?.runsExternalCommand) ? _jsx(Text, { color: theme.warning, children: "This install runs an external command (see above)." }) : null, _jsxs(DecisionPrompt, { children: ["Install ", describeSkills(ready.map((item) => item.skill)), "?"] })] }));
         }
         case "confirm-exposure": {
             const names = mode.items.filter((item) => item.prepared?.additionalHostExposure).map((item) => item.skill.name);

package/dist/src/tui/catalog-state.js

@@ -6,15 +6,22 @@ import { loadInstalledSkills, NO_INSTALLED } from "./catalog-installs.js";
 import { sourceLabel } from "./catalog-tree.js";
 import { packageOperationsOf } from "./environment.js";
 /** Discovers the Skills of one Source, or of all of them, and again whenever those inputs or `reloadKey` change. */
-export function useCatalogSkills(operations, sourceId, all, env, reloadKey = 0) {
-    const [state, setState] = useState({ status: "loading" });
+export function useCatalogSkills(operations, sourceId, all, env, reloadKey = 0, retention) {
+    const key = `${sourceId ?? ""}|${all}`;
+    /** The last result of this scope, shown while it is discovered again. */
+    const retained = () => {
+        const kept = retention?.catalogKey === key ? retention.catalogSkills : undefined;
+        return kept ? { ...kept, stale: true } : { status: "loading" };
+    };
+    const [state, setState] = useState(retained);
     useEffect(() => {
         let cancelled = false;
+        const generation = retention?.generation;
         if (!operations.discoverSkills) {
             setState({ status: "error", message: "Discovery is not supported by the configured operations" });
             return;
         }
-        setState({ status: "loading" });
+        setState(retained());
         void (async () => {
             try {
                 const sources = await operations.listSources();
@@ -50,6 +57,9 @@ export function useCatalogSkills(operations, sourceId, all, env, reloadKey = 0)
                     try {
                         const projectSource = projectSourceOf(source);
                         for (const descriptor of await packages.discover([id])) {
+                            // A Package Agent Depot cannot install is not a choice; its warning stays in `package inspect`.
+                            if (!descriptor.installable)
+                                continue;
                             bundles.push({ sourceId: id, selection: packageSelectionFor(descriptor, projectSource), descriptor });
                             discovered.push({ source: projectSource, descriptor });
                         }
@@ -73,8 +83,14 @@ export function useCatalogSkills(operations, sourceId, all, env, reloadKey = 0)
                     const detail = error instanceof Error ? error.message : String(error);
                     warnings.push(`Package ownership unavailable: ${detail}`);
                 }
+                const ready = { status: "ready", skills, bundles, activeBundles, warnings, sources };
+                // A result that began before an invalidation may predate the change, so it is not kept.
+                if (!cancelled && retention && retention.generation === generation) {
+                    retention.catalogKey = key;
+                    retention.catalogSkills = ready;
+                }
                 if (!cancelled)
-                    setState({ status: "ready", skills, bundles, activeBundles, warnings, sources });
+                    setState(ready);
             }
             catch (error) {
                 if (!cancelled)
@@ -87,49 +103,59 @@ export function useCatalogSkills(operations, sourceId, all, env, reloadKey = 0)
     }, [operations, sourceId, all, env, reloadKey]);
     return state;
 }
-export function useCatalogApps(apps) {
-    const [state, setState] = useState({ status: "loading" });
+export function useCatalogApps(apps, retention) {
+    const [state, setState] = useState(() => retention?.catalogApps ? { ...retention.catalogApps, stale: true } : { status: "loading" });
     const generation = useRef(0);
-    const reload = useCallback(async () => {
+    /** `keepShown` reloads behind the rows already on screen instead of replacing them with a loading state. */
+    const load = useCallback(async (keepShown) => {
         const current = ++generation.current;
-        setState({ status: "loading" });
+        const retained = retention?.generation;
+        if (!keepShown)
+            setState({ status: "loading" });
         try {
             const rows = await Promise.all((await apps.load()).filter(entry => entry.applicable).map(async (entry) => ({
                 entry,
                 inspection: await apps.inspect(entry),
             })));
-            if (generation.current === current)
-                setState({
-                    status: "ready",
-                    rows: rows.filter(row => row.inspection.status === "not installed"),
-                });
+            if (generation.current === current) {
+                const ready = { status: "ready", rows: rows.filter(row => row.inspection.status === "not installed") };
+                if (retention && retention.generation === retained)
+                    retention.catalogApps = ready;
+                setState(ready);
+            }
         }
         catch (error) {
             if (generation.current === current)
                 setState({ status: "ready", rows: [], error: error instanceof Error ? error.message : String(error) });
         }
-    }, [apps]);
+    }, [apps, retention]);
+    const reload = useCallback(() => load(false), [load]);
     useEffect(() => {
-        void reload();
+        void load(retention?.catalogApps !== undefined);
         return () => { generation.current += 1; };
-    }, [reload]);
+    }, [load, retention]);
     return { state, reload };
 }
 /** The Skills already installed, loaded on mount and on demand. */
-export function useInstalledSkills(operations, env, mounted) {
-    const [installed, setInstalled] = useState(NO_INSTALLED);
-    const [installedReady, setInstalledReady] = useState(false);
+export function useInstalledSkills(operations, env, mounted, retention) {
+    const [installed, setInstalled] = useState(retention?.installed ?? NO_INSTALLED);
+    const [installedReady, setInstalledReady] = useState(retention?.installed !== undefined);
+    const [installedStale, setInstalledStale] = useState(retention?.installed !== undefined);
     const reloadInstalled = useCallback(async () => {
+        const generation = retention?.generation;
         const loaded = await loadInstalledSkills(operations, env);
+        if (retention && retention.generation === generation)
+            retention.installed = loaded;
         if (!mounted.current)
             return;
         setInstalled(loaded);
         setInstalledReady(true);
-    }, [operations, env, mounted]);
+        setInstalledStale(false);
+    }, [operations, env, mounted, retention]);
     useEffect(() => {
         void reloadInstalled();
     }, [reloadInstalled]);
-    return { installed, installedReady, reloadInstalled };
+    return { installed, installedReady, installedStale, reloadInstalled };
 }
 /**
  * The filter box. Its state is mirrored in refs, updated first, so the shell