@open-agent-toolkit/cli 0.2.62 → 0.2.64

package/dist/commands/tools/info/skill-views.js

@@ -0,0 +1,383 @@
+import { lstat, readFile } from 'node:fs/promises';
+import { isAbsolute, join } from 'node:path';
+import { getFrontmatterBlock, parseSkillFrontmatter, resolveSkillVersion, } from '../../shared/frontmatter.js';
+import { resolveScopeProviderContextOutcome } from '../../tools/shared/provider-context.js';
+import { diagnoseSkillViews } from '../../../drift/index.js';
+import { OAT_MARKER_PREFIX } from '../../../engine/markers.js';
+function canonicalSkillPath(skillName) {
+    return join('.agents', 'skills', skillName);
+}
+/**
+ * Existence probe that treats only a genuinely absent path as absent.
+ *
+ * A permission or I/O failure is not evidence of a projection gap: reporting
+ * one as `missing-additive` would tell the user to run a sync that cannot fix
+ * anything. Anything we failed to read is reported as present, which downgrades
+ * the classification to `untracked` and suppresses the repair suggestion.
+ */
+export async function probeProviderPath(path, stat = lstat) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (error) {
+        const code = typeof error === 'object' && error !== null && 'code' in error
+            ? error.code
+            : undefined;
+        return !(code === 'ENOENT' || code === 'ENOTDIR');
+    }
+}
+/**
+ * Reads the version of a projected skill copy, with the state of that reading.
+ *
+ * The only thing this does differently from the canonical reader is strip the
+ * OAT-managed provenance banner the engine prepends to a copied `SKILL.md`
+ * (`engine/markers.ts`), which puts the frontmatter past byte zero where
+ * `getFrontmatterBlock`'s start-anchored match will not look. Everything after
+ * that is `parseSkillFrontmatter` + `resolveSkillVersion` — the same functions
+ * `getSkillVersion` uses — so a view and its canonical source can never
+ * resolve by different precedence rules. A private parse here previously read
+ * the deprecated top-level `version` while the canonical side had already
+ * moved to `metadata.version`, which reported a byte-identical copy as stale.
+ *
+ * The state follows the resolver, never the parse in isolation: once the
+ * resolver returns a version, that version is what canonical resolution would
+ * report too, so an ignored sibling declaration that happens to be unusable
+ * must not downgrade it. `unusable` and `malformed` are reserved for readings
+ * that produced no version at all. A read failure yields no version rather
+ * than a guess, so a transient failure can never launder a conflicting
+ * declaration into a clean one.
+ */
+export async function readProjectedSkillVersion(skillDir) {
+    let content;
+    try {
+        content = await readFile(join(skillDir, 'SKILL.md'), 'utf8');
+    }
+    catch {
+        return { version: null, state: 'absent' };
+    }
+    const stripped = content.startsWith(OAT_MARKER_PREFIX)
+        ? content.slice(content.indexOf('\n') + 1)
+        : content;
+    const block = getFrontmatterBlock(stripped);
+    if (!block)
+        return { version: null, state: 'absent' };
+    const parsed = parseSkillFrontmatter(block);
+    if (parsed.malformed)
+        return { version: null, state: 'malformed' };
+    const resolved = resolveSkillVersion(parsed);
+    if (!resolved) {
+        return {
+            version: null,
+            state: parsed.unusableVersionDeclaration ? 'unusable' : 'absent',
+        };
+    }
+    if (resolved.conflict) {
+        return {
+            version: resolved.version,
+            state: 'conflict',
+            conflict: resolved.conflict,
+        };
+    }
+    return { version: resolved.version, state: 'resolved' };
+}
+/**
+ * Diagnoses one canonical skill against every provider view, for each concrete
+ * scope where the canonical skill exists.
+ *
+ * The scope loop is deliberately wider than `oat tools info`'s name
+ * resolution, which returns the first scope that has the skill: a project-scope
+ * copy resolving first does not make a user-scope projection gap disappear, and
+ * the repair for each scope is its own concrete `oat sync --scope`.
+ */
+export async function collectSkillViewDiagnoses(input) {
+    const canonicalRelative = canonicalSkillPath(input.skillName);
+    const diagnoses = [];
+    for (const scope of input.scopes) {
+        const scopeRoot = input.roots[scope];
+        if (!scopeRoot)
+            continue;
+        try {
+            const diagnosis = await diagnoseScope({
+                ...input,
+                scope,
+                scopeRoot,
+                canonicalRelative,
+            });
+            if (diagnosis)
+                diagnoses.push(diagnosis);
+        }
+        catch (error) {
+            // Every input this diagnostic reads can fail independently of the tool
+            // the user asked about: the sync config and the manifest both throw when
+            // present but invalid or unreadable, and the probes can fail on a
+            // permission error. None of that may remove the tool detail or change
+            // the exit code, so the section reports itself unavailable instead.
+            diagnoses.push({
+                skill: input.skillName,
+                scope,
+                result: 'unavailable',
+                reason: redactScopeRoot(error instanceof Error ? error.message : String(error), scope, scopeRoot),
+                views: [],
+            });
+        }
+    }
+    return diagnoses;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * An absolute path inside a quoted span, taken whole.
+ *
+ * A path may contain spaces, commas, and even a stray quote of the other kind,
+ * and every reachable producer of one of these messages quotes it
+ * (`lstat '/a/Private Client/x'`). Matching to the *matching* delimiter, rather
+ * than to the first character that looks like a separator, is what stops the
+ * bare pass below from redacting a prefix and forwarding the rest. The span must
+ * start with `/`, so an already-redacted `'<project>/…'` or `'~/…'` is left
+ * intact, and the match is lazy so two quoted spans in one message do not merge.
+ */
+const QUOTED_ABSOLUTE_PATH = /(['"`])(\/[^\n]*?)\1/g;
+/**
+ * An absolute path that is not quoted.
+ *
+ * The leading `/` may follow anything that is not a path character, which covers
+ * `=`, `:`, `[`, `<`, and a bare token boundary alike; requiring a specific
+ * delimiter is what let `path=/Users/…` through. Excluding `[A-Za-z0-9_~.>-]`
+ * before the slash is what keeps a relative `.oat/sync/…` and an
+ * already-redacted `<project>/…` or `~/…` intact.
+ *
+ * The path itself runs to whitespace or a quote and to nothing else. A comma, a
+ * bracket, and a brace are all legal in a filename, so treating one as a
+ * terminator would end the match inside a real path and forward its tail —
+ * `/outside/public,Private` would redact to `<path>,Private`. Swallowing a
+ * trailing bracket is the safe direction. A URL is redacted from its `//`
+ * onwards, which is over-redaction rather than a leak, and no producer of these
+ * messages emits one.
+ */
+const BARE_ABSOLUTE_PATH = /(^|[^A-Za-z0-9_~.>-])(\/[^\s'"`]*)/g;
+/**
+ * Makes a failure reason safe to print and to paste into a bug report.
+ *
+ * The scope root becomes its conventional placeholder, matching how the pack
+ * surfaces redact paths, but only where the root genuinely contains what
+ * follows — a `/` or the end of the string. Replacing it anywhere turned a
+ * sibling that merely shares the prefix (`/project-private/secret`, or
+ * `/project private/secret`) into `<project>-private/secret`, which both lies
+ * about the location and forwards the rest of a path that was never inside the
+ * scope root. A non-contained sibling falls through to the passes below and is
+ * replaced wholesale instead.
+ *
+ * Any absolute path still standing after that is by definition outside the
+ * scope root — a manifest `providerPath` that escapes it, for instance, which
+ * the detector resolves and names verbatim in an `ENOTDIR`/`ENOENT` message —
+ * so it is replaced wholesale rather than forwarded. Redaction is deliberately
+ * greedy here: over-redacting a reason costs a user nothing, and under-redacting
+ * one puts a username or a private directory name into a bug report.
+ */
+function redactScopeRoot(text, scope, scopeRoot) {
+    const placeholder = scope === 'project' ? '<project>' : '~';
+    return text
+        .replace(new RegExp(`${escapeRegExp(scopeRoot)}(?=/|$)`, 'g'), placeholder)
+        .replace(QUOTED_ABSOLUTE_PATH, '$1<path>$1')
+        .replace(BARE_ABSOLUTE_PATH, '$1<path>');
+}
+async function diagnoseScope(input) {
+    const { dependencies: deps, scope, scopeRoot, canonicalRelative } = input;
+    const canonicalDir = join(scopeRoot, canonicalRelative);
+    if (!(await deps.pathExists(canonicalDir)))
+        return null;
+    // A sync config that is present but unreadable is exactly the failure this
+    // diagnostic exists to explain, so it degrades to `unavailable` with a
+    // reason like every other unreadable input. Dropping the scope instead would
+    // print nothing at all, which reads as "no providers configured" — the
+    // opposite of the truth — to the one user most likely to be running this.
+    // An absent config is not that case: `loadSyncConfig` answers `ENOENT` with
+    // the defaults, so it resolves normally and the scope is diagnosed.
+    const contextOutcome = await resolveScopeProviderContextOutcome({
+        scope,
+        scopeRoot,
+        ...(input.providerContext ? { dependencies: input.providerContext } : {}),
+    });
+    if (contextOutcome.status === 'failed') {
+        throw contextOutcome.error instanceof Error
+            ? contextOutcome.error
+            : new Error(String(contextOutcome.error));
+    }
+    const providerScopeContext = contextOutcome.context;
+    const projections = deps.resolveExpectedProjections({
+        skillName: input.skillName,
+        scope,
+        registrations: providerScopeContext.registrations,
+    });
+    const manifest = await deps.loadManifest(join(scopeRoot, '.oat', 'sync', 'manifest.json'));
+    // Collection entries ride in this compatibility view; the per-entry
+    // manifest reader narrows them, so read the V2 shape back for `strategy`.
+    const entries = manifest.entries;
+    const observations = [];
+    for (const projection of projections) {
+        const manifestEntry = entries.find((entry) => entry.canonicalPath === canonicalRelative &&
+            entry.provider === projection.provider) ?? null;
+        // The probes below use the real path; the row may not. An escaping path is
+        // replaced with the same placeholder a reason gets, so the divergence is
+        // still reported honestly without naming a location outside the scope.
+        const renderableEntry = manifestEntry && escapesScope(manifestEntry.providerPath)
+            ? { ...manifestEntry, providerPath: '<path>' }
+            : manifestEntry;
+        // One provider's unreadable path is not evidence about the other four.
+        // `detectDrift` throws before `readProjectedVersion`'s own catch can
+        // classify, and letting that reach the scope-level catch took the whole
+        // section down with it. Only the failing row degrades now.
+        try {
+            observations.push(await observeProjection({
+                deps,
+                scopeRoot,
+                projection,
+                manifestEntry,
+                renderableEntry,
+            }));
+        }
+        catch (error) {
+            observations.push({
+                projection,
+                manifestEntry: renderableEntry,
+                drift: null,
+                viewPresent: false,
+                unavailableReason: redactScopeRoot(error instanceof Error ? error.message : String(error), scope, scopeRoot),
+            });
+        }
+    }
+    return diagnoseSkillViews({
+        skillName: input.skillName,
+        scope,
+        canonicalPresent: true,
+        canonicalVersion: scope === input.resolvedScope
+            ? input.resolvedVersion
+            : await deps.getSkillVersion(canonicalDir),
+        providerScopeContext,
+        observations,
+    });
+}
+/**
+ * Whether a manifest `providerPath` names something outside its own scope.
+ *
+ * Manifest paths are scope-relative by convention, so anything absolute or
+ * reaching back through `..` describes a location the scope root placeholder
+ * cannot stand in for. Such a path is never rendered verbatim: a row that named
+ * it would disclose a location outside the tree the user asked about, which is
+ * exactly what the reason redaction exists to prevent.
+ */
+function escapesScope(providerPath) {
+    return isAbsolute(providerPath) || providerPath.split(/[\\/]/).includes('..');
+}
+/** Reads one provider's reality for one expected projection. */
+async function observeProjection(input) {
+    const { deps, scopeRoot, projection, manifestEntry } = input;
+    const viewPresent = await deps.pathExists(join(scopeRoot, projection.providerPath));
+    // `detectDrift` requires a manifest entry, so a never-synced projection
+    // is classified from the expected path alone and never probes drift.
+    const drift = manifestEntry
+        ? await deps.detectDrift(manifestEntry, scopeRoot)
+        : null;
+    // `detectDrift` resolves the manifest entry's own `providerPath`, and the
+    // manifest is keyed by `(canonicalPath, provider)` with no path check, so
+    // the two can name different files. Everything about a tracked row is then
+    // read from the tracked path, because that is the path the drift verdict
+    // already describes; mixing the two would report one file's version beside
+    // another file's state. The extra probe only runs when they actually
+    // diverge, so the ordinary row is unchanged.
+    const trackedPath = manifestEntry?.providerPath;
+    const pathDiverges = trackedPath !== undefined && trackedPath !== projection.providerPath;
+    const trackedPresent = pathDiverges
+        ? await deps.pathExists(join(scopeRoot, trackedPath))
+        : viewPresent;
+    // A tracked path that escapes the scope is not read for a version. Its
+    // `SKILL.md` is a file outside the tree the user asked about, so reporting
+    // its version would both disclose content from outside the scope and compare
+    // the canonical skill against something that is not a view of it.
+    const comparable = manifestEntry?.strategy === 'copy' &&
+        !projection.nativeRead &&
+        trackedPresent &&
+        !(trackedPath !== undefined && escapesScope(trackedPath));
+    return {
+        projection,
+        manifestEntry: input.renderableEntry,
+        drift,
+        viewPresent,
+        ...(comparable
+            ? {
+                projectedVersion: await deps.readProjectedVersion(join(scopeRoot, trackedPath ?? projection.providerPath)),
+            }
+            : {}),
+    };
+}
+function qualifier(view) {
+    if (view.nativeRead)
+        return ' (native read)';
+    if (view.strategy === 'symlink')
+        return ' (symlink)';
+    if (view.strategy === 'copy')
+        return ' (copy)';
+    if (view.strategy === 'collection')
+        return ' (collection alias)';
+    return '';
+}
+const ACTIONABLE = new Set(['missing-additive', 'removed', 'modified']);
+/**
+ * Classes for which nothing is projected at all.
+ *
+ * These rows carry no projection qualifier and no path: `copilot: inactive
+ * (native read)  .agents/skills/x` named a file the provider was never going to
+ * read and described a strategy that was never going to run.
+ */
+const NO_PROJECTION = new Set(['inactive', 'unsupported', 'excluded']);
+/** Renders the human-readable provider-view block. Pure. */
+export function formatSkillViewLines(diagnoses) {
+    const lines = [];
+    for (const diagnosis of diagnoses) {
+        if (diagnosis.result === 'unavailable') {
+            lines.push(`  Provider views (${diagnosis.scope}): unavailable`);
+            if (diagnosis.reason)
+                lines.push(`    ${diagnosis.reason}`);
+            continue;
+        }
+        if (diagnosis.result !== 'diagnosed' || diagnosis.views.length === 0) {
+            continue;
+        }
+        lines.push(`  Provider views (${diagnosis.scope}):`);
+        const width = Math.max(...diagnosis.views.map(({ provider }) => provider.length));
+        for (const view of diagnosis.views) {
+            const label = `${view.provider}:`.padEnd(width + 1);
+            const projected = !NO_PROJECTION.has(view.viewClass);
+            const path = projected && view.providerPath ? `  ${view.providerPath}` : '';
+            lines.push(`    ${label} ${view.viewClass}${projected ? qualifier(view) : ''}${path}`);
+            // A withheld or ambiguous version comparison is exactly the case a user
+            // cannot infer from the class word alone, so it is shown even when the
+            // class itself is not actionable.
+            if (ACTIONABLE.has(view.viewClass) ||
+                view.viewClass === 'untracked' ||
+                // `unverified` is the class a per-view read failure degrades to, and
+                // its detail carries the redacted reason. Withholding it would hide
+                // exactly what the scope-level `unavailable` used to print.
+                view.viewClass === 'unverified' ||
+                // A row naming a path the adapter does not expect is unreadable
+                // without the sentence that says why, whatever its class.
+                view.expectedProviderPath !== undefined ||
+                (view.versionEvidence !== undefined &&
+                    view.versionEvidence !== 'resolved' &&
+                    view.versionEvidence !== 'absent')) {
+                lines.push(`      ${view.detail}`);
+            }
+            if (view.versionComparable) {
+                lines.push(`      versions: canonical ${view.canonicalVersion ?? '-'}, view ${view.viewVersion ?? '-'}`);
+            }
+        }
+        // One suggestion per affected scope, never one per provider and never
+        // `--scope all`: the narrowest safe repair is the scope that has the gap.
+        const suggestion = diagnosis.views.find(({ suggestion: value }) => value !== null)?.suggestion;
+        if (suggestion)
+            lines.push(`    Repair: ${suggestion}`);
+    }
+    return lines;
+}

package/dist/commands/tools/install/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/install/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,qBAAqB,EAE3B,MAAM,sBAAsB,CAAC;AAO9B,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,kCAAkC,CAAC;AAE1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwBzC,wBAAgB,yBAAyB,CACvC,gBAAgB,GAAE,oBAA8C,EAChE,aAAa,GAAE,OAAO,CAAC,qBAAqB,CAAM,EAClD,iBAAiB,CAAC,EAAE,MAAM,OAAO,GAChC,OAAO,CAyDT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/install/index.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,qBAAqB,EAE3B,MAAM,sBAAsB,CAAC;AAO9B,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,kCAAkC,CAAC;AAG1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,wBAAgB,yBAAyB,CACvC,gBAAgB,GAAE,oBAAgD,EAClE,aAAa,GAAE,OAAO,CAAC,qBAAqB,CAAM,EAClD,iBAAiB,CAAC,EAAE,MAAM,OAAO,GAChC,OAAO,CAyDT"}

package/dist/commands/tools/install/index.js

@@ -1,41 +1,19 @@
-import { execFile } from 'node:child_process';
 import { buildCommandContext } from '../../../app/command-context.js';
 import { consumeInitToolsRunMetadata, createInitToolsCommand, wasInstallSyncHandled, } from '../../init/tools/index.js';
 import { withProjectGuidanceOptions } from '../../init/tools/project-guidance.js';
 import { withScopeOption } from '../../shared/scope-option.js';
 import { readGlobalOptions, resolveConcreteScopes, } from '../../shared/shared.utils.js';
 import { autoSync, } from '../../tools/shared/auto-sync.js';
+import { inProcessSyncDependencies } from '../../tools/shared/in-process-sync.js';
 import { getInstalledCanonicalPaths as getInstallSyncCanonicalPaths } from '../../tools/shared/install-sync-context.js';
-const defaultSyncDependencies = {
-    runSync: async ({ scope, cwd, installedCanonicalPaths }) => {
-        const syncArgs = [
-            ...process.execArgv,
-            process.argv[1],
-            'sync',
-            '--scope',
-            scope,
-        ];
-        for (const canonicalPath of installedCanonicalPaths ?? []) {
-            syncArgs.push('--install-canonical', canonicalPath);
-        }
-        await new Promise((resolve, reject) => {
-            execFile(process.execPath, syncArgs, { cwd }, (error) => {
-                if (error)
-                    reject(error);
-                else
-                    resolve();
-            });
-        });
-    },
-};
-export function createToolsInstallCommand(syncDependencies = defaultSyncDependencies, initOverrides = {}, createBaseCommand) {
+export function createToolsInstallCommand(syncDependencies = inProcessSyncDependencies, initOverrides = {}, createBaseCommand) {
     let syncEnabled = true;
     const buildContext = initOverrides.buildCommandContext ?? buildCommandContext;
     const effectiveOverrides = {
         ...initOverrides,
         syncAfterInstall: async (scopes, context, installedCanonicalPaths) => syncEnabled
             ? autoSync(scopes, context.cwd, context.home, context.logger, syncDependencies, { installedCanonicalPaths })
-            : { synced: false, scopes: [], error: null },
+            : { synced: false, scopes: [], error: null, evidence: [] },
     };
     const cmd = createBaseCommand === undefined
         ? createInitToolsCommand(effectiveOverrides)

package/dist/commands/tools/list/list-tools.d.ts

@@ -1,6 +1,7 @@
 import type { CommandContext } from '../../../app/command-context.js';
 import { type PackEvidenceBlockV1 } from '../../tools/shared/format-pack-inventory.js';
 import { type InventoryPackInput, type PackInventory } from '../../tools/shared/pack-inventory.js';
+import { type ProviderContextDependencies } from '../../tools/shared/provider-context.js';
 import type { ScanToolsOptions } from '../../tools/shared/scan-tools.js';
 import type { ToolInfo } from '../../tools/shared/types.js';
 export interface ListToolsDependencies {
@@ -8,6 +9,7 @@ export interface ListToolsDependencies {
     resolveScopeRoot: (scope: 'project' | 'user', cwd: string, home: string) => Promise<string>;
     resolveAssetsRoot: () => Promise<string>;
     inventoryPack?: (input: InventoryPackInput) => Promise<PackInventory>;
+    providerContext?: ProviderContextDependencies;
 }
 export interface ListToolsResult {
     tools: ToolInfo[];

package/dist/commands/tools/list/list-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-tools.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/list/list-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAML,KAAK,mBAAmB,EACzB,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,aAAa,EACnB,MAAM,uCAAuC,CAAC;AAE/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAE7D,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,gBAAgB,EAAE,CAChB,KAAK,EAAE,SAAS,GAAG,MAAM,EACzB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;CACvE;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,YAAY,EAAE,mBAAmB,CAAC;CACnC;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,qBAAqB,GAClC,OAAO,CAAC,eAAe,CAAC,CAkI1B"}
+{"version":3,"file":"list-tools.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/list/list-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAML,KAAK,mBAAmB,EACzB,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,aAAa,EACnB,MAAM,uCAAuC,CAAC;AAG/C,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAE7D,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,gBAAgB,EAAE,CAChB,KAAK,EAAE,SAAS,GAAG,MAAM,EACzB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,MAAM,CAAC,CAAC;IACrB,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;IACtE,eAAe,CAAC,EAAE,2BAA2B,CAAC;CAC/C;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,YAAY,EAAE,mBAAmB,CAAC;CACnC;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,qBAAqB,GAClC,OAAO,CAAC,eAAe,CAAC,CA2J1B"}

package/dist/commands/tools/list/list-tools.js

@@ -2,6 +2,8 @@ import { resolveConcreteScopes } from '../../shared/shared.utils.js';
 import { formatPackEvidenceDetails, formatPackInventoryDetails, packEvidenceBlock, projectRenderablePackEvidence, unavailablePackEvidence, } from '../../tools/shared/format-pack-inventory.js';
 import { inventoryPack, } from '../../tools/shared/pack-inventory.js';
 import { PACK_MANIFEST } from '../../tools/shared/pack-manifest.js';
+import { applyUserAgentCoverage } from '../../tools/shared/pack-provider-evidence.js';
+import { resolvePackProviderSurface, } from '../../tools/shared/provider-context.js';
 export async function runListTools(context, dependencies) {
     const { logger } = context;
     const scopes = resolveConcreteScopes(context.scope);
@@ -23,15 +25,32 @@ export async function runListTools(context, dependencies) {
         userRoot: roots.user,
     };
     const inspectPack = dependencies.inventoryPack ?? inventoryPack;
+    // `list` reports the same packs as `status` and `doctor`, so it resolves the
+    // same config-aware provider surface. Without it, `list` reported user
+    // agents as unmaterialized that an active Codex or Cursor adapter supplies.
+    const providerSurface = await resolvePackProviderSurface({
+        scopeRoots: roots,
+        ...(dependencies.providerContext
+            ? { dependencies: dependencies.providerContext }
+            : {}),
+    });
     const inspected = await Promise.all(PACK_MANIFEST.map(({ name }) => inspectPack({
         pack: name,
         assetsRoot,
         projectRoot: roots.project,
         userRoot: roots.user,
-    }).then((canonical) => ({
-        canonical,
-        evidence: projectRenderablePackEvidence(canonical, packRoots),
-    }), (error) => ({
+        ...(roots.user
+            ? {
+                userManagedRoleMaterialization: providerSurface.userAgentCoverage !== 'none',
+            }
+            : {}),
+    }).then((raw) => {
+        const canonical = applyUserAgentCoverage(raw, providerSurface.userAgentCoverage);
+        return {
+            canonical,
+            evidence: projectRenderablePackEvidence(canonical, packRoots, providerSurface.contexts),
+        };
+    }, (error) => ({
         canonical: null,
         evidence: unavailablePackEvidence({
             pack: name,

package/dist/commands/tools/remove/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/remove/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,kCAAkC,CAAC;AAW1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAEL,KAAK,uBAAuB,EAM7B,MAAM,gBAAgB,CAAC;AAqExB,wBAAgB,wBAAwB,CACtC,YAAY,GAAE,uBAA6C,EAC3D,gBAAgB,GAAE,oBAA8C,GAC/D,OAAO,CAkOT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/remove/index.ts"],"names":[],"mappings":"AASA,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,kCAAkC,CAAC;AAkB1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAEL,KAAK,uBAAuB,EAM7B,MAAM,gBAAgB,CAAC;AAkDxB,wBAAgB,wBAAwB,CACtC,YAAY,GAAE,uBAA6C,EAC3D,gBAAgB,GAAE,oBAA8C,GAC/D,OAAO,CAmPT"}

package/dist/commands/tools/remove/index.js

@@ -1,11 +1,15 @@
-import { execFile } from 'node:child_process';
 import { lstat, rm } from 'node:fs/promises';
 import { relative } from 'node:path';
 import { buildCommandContext } from '../../../app/command-context.js';
 import { withScopeOption } from '../../shared/scope-option.js';
 import { readGlobalOptions, resolveConcreteScopes, } from '../../shared/shared.utils.js';
 import { autoSync, } from '../../tools/shared/auto-sync.js';
+import { inProcessSyncDependencies } from '../../tools/shared/in-process-sync.js';
 import { inventoryScopedPack } from '../../tools/shared/pack-inventory.js';
+import { providerSyncOutcomeFromAutoSync, } from '../../tools/shared/pack-lifecycle-outcome.js';
+import { withLifecycleProviderEvidence } from '../../tools/shared/pack-provider-evidence.js';
+import { resolveProviderScopeContexts } from '../../tools/shared/provider-context.js';
+import { applySyncEvidence } from '../../tools/shared/provider-reachability.js';
 import { scanTools } from '../../tools/shared/scan-tools.js';
 import { hasScopedPackOwnershipEvidence, writeScopedPackIntent, } from '../../tools/shared/scoped-pack-intent.js';
 import { resolveAssetsRoot } from '../../../fs/assets.js';
@@ -45,28 +49,7 @@ const defaultDependencies = {
     inventoryScopedPack,
     writeScopedPackIntent,
 };
-const defaultSyncDependencies = {
-    runSync: async ({ scope, cwd, removedCanonicalPaths }) => {
-        const args = [
-            ...process.execArgv,
-            process.argv[1],
-            'sync',
-            '--scope',
-            scope,
-        ];
-        for (const canonicalPath of removedCanonicalPaths ?? []) {
-            args.push('--remove-canonical', canonicalPath);
-        }
-        await new Promise((resolve, reject) => {
-            execFile(process.execPath, args, { cwd }, (error) => {
-                if (error)
-                    reject(error);
-                else
-                    resolve();
-            });
-        });
-    },
-};
+const defaultSyncDependencies = inProcessSyncDependencies;
 const VALID_PACKS = [
     'core',
     'ideas',
@@ -164,7 +147,12 @@ export function createToolsRemoveCommand(dependencies = defaultDependencies, syn
                             }));
                         }
                     }
-                    result.lifecycle = removalLifecycleOutcomes(selectedPacks(target), scopes, result.packOutcomes, false, finalInventories);
+                    result.lifecycle = removalLifecycleOutcomes(selectedPacks(target), scopes, result.packOutcomes, false, finalInventories, await resolveProviderScopeContexts({
+                        scopeRoots: Object.fromEntries(await Promise.all(scopes.map(async (scope) => [
+                            scope,
+                            await dependencies.resolveScopeRoot(scope, context.cwd, context.home),
+                        ]))),
+                    }));
                 }
             }
             catch (error) {
@@ -249,27 +237,32 @@ function finalizeRemovalLifecycle(lifecycle, syncResults) {
         return lifecycle;
     return lifecycle.map((outcome) => {
         const relevant = syncResults.filter(({ scopes }) => scopes.some((scope) => outcome.selection.targetScopes.includes(scope)));
-        if (relevant.length === 0 || relevant.every(({ synced }) => synced)) {
-            return relevant.length === 0
-                ? outcome
-                : {
-                    ...outcome,
-                    sync: {
-                        scopes: [...new Set(relevant.flatMap(({ scopes }) => scopes))],
-                        status: 'complete',
-                        providers: [],
-                    },
-                };
+        const merged = {
+            synced: relevant.every(({ synced }) => synced),
+            scopes: [...new Set(relevant.flatMap(({ scopes }) => scopes))],
+            error: relevant.find((result) => result.error)?.error ?? null,
+            evidence: relevant.flatMap(({ evidence }) => evidence),
+        };
+        const providers = applySyncEvidence(outcome.sync.providers, {
+            syncRan: merged.evidence.some(({ ran }) => ran),
+            syncOperationResults: merged.evidence.flatMap(({ operationResults }) => operationResults),
+            extensionResults: merged.evidence.flatMap(({ extensionResults }) => extensionResults),
+        });
+        if (relevant.length === 0)
+            return outcome;
+        // The status comes from the shared severity-matrix rule rather than from
+        // `synced` alone: a sync that returned successfully can still carry an
+        // observed provider materialization failure, which is a `partial`.
+        const sync = providerSyncOutcomeFromAutoSync(merged, providers);
+        const finalEvidence = withLifecycleProviderEvidence(outcome.finalEvidence, providers);
+        if (sync.status === 'complete') {
+            return { ...outcome, sync, finalEvidence };
         }
-        const error = relevant.find((result) => result.error)?.error;
+        const error = merged.error ?? undefined;
         return {
             ...outcome,
-            sync: {
-                scopes: [...new Set(relevant.flatMap(({ scopes }) => scopes))],
-                status: 'failed',
-                providers: [],
-                ...(error ? { error } : {}),
-            },
+            sync,
+            finalEvidence,
             status: 'partial',
             recovery: [
                 ...outcome.recovery,

package/dist/commands/tools/remove/remove-tools.d.ts

@@ -1,8 +1,9 @@
 import { type InventoryScopedPackInput, type ScopedPackInventory } from '../../tools/shared/pack-inventory.js';
 import { type PackLifecycleRequest, type PackLifecycleResult } from '../../tools/shared/pack-lifecycle.js';
-import type { PackLifecycleOutcome } from '../../tools/shared/pack-lifecycle-outcome.js';
+import { type PackLifecycleOutcome } from '../../tools/shared/pack-lifecycle-outcome.js';
 import type { ScanToolsOptions } from '../../tools/shared/scan-tools.js';
 import type { PackName, ToolInfo } from '../../tools/shared/types.js';
+import type { ProviderScopeContext } from '../../../providers/shared/registry.js';
 import type { ConcreteScope } from '../../../shared/types.js';
 export type RemoveTarget = {
     kind: 'name';
@@ -72,7 +73,7 @@ export declare function selectedPacks(target: Exclude<RemoveTarget, {
     kind: 'name';
 }>): PackName[];
 export declare function removeTools(target: RemoveTarget, scopes: ConcreteScope[], cwd: string, home: string, dryRun: boolean, deps: RemoveToolsDependencies): Promise<RemoveResult>;
-export declare function removalLifecycleOutcomes(packs: readonly PackName[], scopes: readonly ConcreteScope[], outcomes: readonly PackRemovalOutcome[], dryRun: boolean, finalInventories: readonly ScopedPackInventory[]): PackLifecycleOutcome[];
+export declare function removalLifecycleOutcomes(packs: readonly PackName[], scopes: readonly ConcreteScope[], outcomes: readonly PackRemovalOutcome[], dryRun: boolean, finalInventories: readonly ScopedPackInventory[], providerContexts?: readonly ProviderScopeContext[]): PackLifecycleOutcome[];
 export declare function failedRemovalLifecycleOutcomes(target: Exclude<RemoveTarget, {
     kind: 'name';
 }>, scopes: readonly ConcreteScope[], error: unknown): PackLifecycleOutcome[];