@open-agent-toolkit/cli 0.2.51 → 0.2.53

package/dist/commands/status/index.js

@@ -7,26 +7,24 @@ import { applyNativeSkillDisposition, getNativeSkillProviderDetails, isNativeSki
 import { withScopeOption } from '../shared/scope-option.js';
 import { confirmAction, selectManyWithAbort, selectWithAbort, } from '../shared/shared.prompts.js';
 import { readGlobalOptions, resolveConcreteScopes, } from '../shared/shared.utils.js';
+import { packEvidenceBlock, projectRenderablePackEvidence, unavailablePackEvidence, } from '../tools/shared/format-pack-inventory.js';
 import { attributeSharedOwnerDiagnostics, hasScopedPackPlacementEvidence, inventoryPack, } from '../tools/shared/pack-inventory.js';
 import { PACK_NAMES } from '../tools/shared/pack-manifest.js';
 import { formatPackPath, formatPackPaths, updatePackRecovery, } from '../tools/shared/pack-paths.js';
 import { DEFAULT_SYNC_CONFIG, loadSyncConfig, } from '../../config/index.js';
 import { resolveUserSyncConfig } from '../../config/user-sync-config.js';
 import { detectDrift, detectStrays, filterKnownStrays, } from '../../drift/index.js';
-import { HOOK_DRIFT_WARNING, HOOK_STRAY_INFO, scanBundledManagedAgents, scanCanonical, } from '../../engine/index.js';
+import { HOOK_DRIFT_WARNING, HOOK_STRAY_INFO, mergeUserScopeMaterializationEntries, scanBundledManagedAgents, scanCanonical, } from '../../engine/index.js';
 import { resolveAssetsRoot } from '../../fs/assets.js';
 import { normalizeToPosixPath, resolveProjectRoot, resolveScopeRoot, } from '../../fs/paths.js';
 import { loadManifest, saveManifest } from '../../manifest/manager.js';
-import { claudeAdapter } from '../../providers/claude/index.js';
-import { codexAdapter } from '../../providers/codex/index.js';
 import { applyCodexProjectExtensionPlan, computeCodexProjectExtensionPlan, } from '../../providers/codex/codec/sync-extension.js';
-import { copilotAdapter } from '../../providers/copilot/index.js';
-import { cursorAdapter } from '../../providers/cursor/index.js';
 import { applyCursorProjectExtensionPlan, computeCursorProjectExtensionPlan, } from '../../providers/cursor/codec/sync-extension.js';
-import { geminiAdapter } from '../../providers/gemini/index.js';
-import { getConfigAwareAdapters, getSyncMappings, } from '../../providers/shared/index.js';
+import { getConfigAwareAdapters, getProviderRegistrations, getSyncMappings, resolveProviderScopeContext, } from '../../providers/shared/index.js';
 import { getAdoptionSources } from '../../providers/shared/adapter.utils.js';
-import { SCOPE_CONTENT_TYPES, } from '../../shared/types.js';
+import { userAgentMaterializationCoverage, } from '../../providers/shared/registry.js';
+import { adviseProviderRefresh, } from '../../providers/shared/restart-adviser.js';
+import {} from '../../shared/types.js';
 import { formatStatusTable } from '../../ui/output.js';
 import { Command } from 'commander';
 const DEFAULT_REMEDIATION = 'Run "oat init" to adopt stray entries.';
@@ -61,8 +59,49 @@ function unavailablePackReport(error, roots, unavailableScopes) {
         states: [],
         unavailableScopes,
         pjm: null,
+        evidence: packEvidenceBlock(PACK_NAMES.map((pack) => unavailablePackEvidence({
+            pack,
+            scopes: Object.keys(roots).map((key) => key === 'projectRoot' ? 'project' : 'user'),
+            reason: detail,
+            roots,
+        }))),
     };
 }
+function collectProviderRefreshAdvice(collections) {
+    return collections.flatMap((collection) => {
+        const providerContext = collection.providerContext;
+        if (!providerContext)
+            return [];
+        const active = new Set(providerContext.activeProviders);
+        return providerContext.registrations.flatMap((registration) => {
+            if (!active.has(registration.adapter.name))
+                return [];
+            return registration.capabilities
+                .filter(({ scope, support }) => scope === collection.scope && support === 'supported')
+                .map((capability) => ({
+                scope: collection.scope,
+                provider: registration.adapter.name,
+                contentKind: capability.contentKind,
+                visibility: adviseProviderRefresh({
+                    policy: capability.catalogRefresh,
+                    materialization: 'unknown',
+                    observation: {
+                        state: 'not-reported',
+                        reference: 'oat status inspects managed files but does not query the active provider catalog',
+                    },
+                }),
+            }));
+        });
+    });
+}
+function formatProviderRefreshAdvice(advice) {
+    if (advice.length === 0)
+        return null;
+    return [
+        'Provider catalog visibility:',
+        ...advice.map(({ scope, provider, contentKind, visibility }) => `  [${scope}] ${provider}/${contentKind}: ${visibility.state} (${visibility.policy.state})`),
+    ].join('\n');
+}
 const DEFAULT_DEPENDENCIES = {
     buildCommandContext,
     async resolveScopeRoot(scope, context) {
@@ -80,15 +119,10 @@ const DEFAULT_DEPENDENCIES = {
     scanCanonical,
     scanBundledManagedAgents,
     getAdapters() {
-        return [
-            claudeAdapter,
-            cursorAdapter,
-            codexAdapter,
-            copilotAdapter,
-            geminiAdapter,
-        ];
+        return getProviderRegistrations().map(({ adapter }) => adapter);
     },
     getConfigAwareAdapters,
+    resolveProviderScopeContext,
     getSyncMappings,
     getAdoptionSources,
     detectDrift,
@@ -120,9 +154,6 @@ function canonicalInsideMapping(canonicalPath, mappingCanonicalDir) {
     return (normalizedCanonicalPath === normalizedCanonicalDir ||
         normalizedCanonicalPath.startsWith(`${normalizedCanonicalDir}/`));
 }
-function contentTypeAllowed(contentType, scope) {
-    return SCOPE_CONTENT_TYPES[scope].includes(contentType);
-}
 function summarizeReports(reports) {
     const summary = {
         total: reports.length,
@@ -243,7 +274,7 @@ function shouldReportPjmAdoption(adoption, states) {
     const pjm = states.find(({ pack }) => pack === 'project-management');
     return (pjm?.scopes ?? []).some(({ scope }) => scope === 'project');
 }
-async function collectPackReport(scopeRoots, unavailableScopes, userManagedRoleMaterialization, dependencies) {
+async function collectPackReport(scopeRoots, unavailableScopes, userAgentCoverage, dependencies) {
     const roots = {
         ...(scopeRoots.has('project')
             ? { projectRoot: scopeRoots.get('project') }
@@ -256,6 +287,7 @@ async function collectPackReport(scopeRoots, unavailableScopes, userManagedRoleM
             states: [],
             unavailableScopes,
             pjm: null,
+            evidence: packEvidenceBlock([]),
         };
     }
     let inventories;
@@ -266,9 +298,23 @@ async function collectPackReport(scopeRoots, unavailableScopes, userManagedRoleM
             assetsRoot,
             ...roots,
             ...(scopeRoots.has('user')
-                ? { userManagedRoleMaterialization }
+                ? {
+                    userManagedRoleMaterialization: userAgentCoverage !== 'none',
+                }
                 : {}),
         }))));
+        if (userAgentCoverage === 'all') {
+            inventories = inventories.map((inventory) => ({
+                ...inventory,
+                scopes: inventory.scopes.map((scoped) => scoped.scope === 'user'
+                    ? {
+                        ...scoped,
+                        diagnostics: scoped.diagnostics.filter(({ code }) => code !== 'user-agent-unmaterialized'),
+                    }
+                    : scoped),
+                diagnostics: inventory.diagnostics.filter(({ code }) => code !== 'user-agent-unmaterialized'),
+            }));
+        }
     }
     catch (error) {
         return unavailablePackReport(error, roots, unavailableScopes);
@@ -276,6 +322,7 @@ async function collectPackReport(scopeRoots, unavailableScopes, userManagedRoleM
     const states = inventories
         .map((inventory) => toStatusPackState(inventory, roots))
         .filter((state) => state !== null);
+    const evidence = packEvidenceBlock(inventories.map((canonical) => projectRenderablePackEvidence(canonical, roots)));
     const projectRoot = scopeRoots.get('project');
     if (!projectRoot) {
         return {
@@ -283,6 +330,7 @@ async function collectPackReport(scopeRoots, unavailableScopes, userManagedRoleM
             states,
             unavailableScopes,
             pjm: null,
+            evidence,
         };
     }
     const adoption = await dependencies.resolvePjmAdoption({
@@ -301,6 +349,7 @@ async function collectPackReport(scopeRoots, unavailableScopes, userManagedRoleM
             repoRoot: formatPackPath(adoption.repoRoot, roots),
             recovery: adoption.recovery,
         },
+        evidence,
     };
 }
 function describePackScope(state) {
@@ -375,29 +424,79 @@ async function collectScopeReports(scope, context, dependencies) {
     const manifestPath = join(scopeRoot, '.oat', 'sync', 'manifest.json');
     const syncConfigPath = join(scopeRoot, '.oat', 'sync', 'config.json');
     const userConfigDir = join(context.home, '.oat');
-    const [manifest, canonicalEntries, syncConfig, userSyncConfig] = await Promise.all([
+    const [manifest, syncConfig, userSyncConfig] = await Promise.all([
         dependencies.loadManifest(manifestPath),
-        dependencies.scanCanonical(scopeRoot, scope),
         dependencies.loadSyncConfig(syncConfigPath),
         dependencies.resolveUserSyncConfig(userConfigDir),
     ]);
-    const adapters = dependencies.getAdapters();
-    const { activeAdapters } = await dependencies.getConfigAwareAdapters(adapters, scopeRoot, scope === 'user' ? userSyncConfig : syncConfig);
+    const effectiveConfig = scope === 'user' ? userSyncConfig : syncConfig;
+    const providerContext = dependencies.resolveProviderScopeContext
+        ? await dependencies.resolveProviderScopeContext({
+            scope,
+            scopeRoot,
+            config: effectiveConfig,
+        })
+        : null;
+    const adapters = providerContext
+        ? providerContext.registrations.map(({ adapter }) => adapter)
+        : dependencies.getAdapters();
+    const activeAdapters = providerContext
+        ? adapters.filter(({ name }) => providerContext.activeProviders.includes(name))
+        : await dependencies
+            .getConfigAwareAdapters(adapters, scopeRoot, effectiveConfig)
+            .then((resolution) => resolution.activeAdapters);
+    const activeAdapterNames = activeAdapters.map(({ name }) => name);
+    const knownRegistrations = getProviderRegistrations().filter(({ adapter }) => activeAdapterNames.includes(adapter.name));
+    const coverageRegistrations = providerContext?.registrations ?? knownRegistrations;
+    const mappingScanTargets = activeAdapters
+        .flatMap((adapter) => dependencies.getSyncMappings(adapter, scope))
+        .map(({ contentType, canonicalDir }) => ({ contentType, canonicalDir }));
+    const capabilityScanTargets = coverageRegistrations
+        .filter(({ adapter }) => activeAdapterNames.includes(adapter.name))
+        .flatMap(({ capabilities }) => capabilities
+        .filter((capability) => capability.scope === scope &&
+        capability.support === 'supported' &&
+        capability.contentKind !== 'directory')
+        .map((capability) => ({
+        contentType: capability.contentKind,
+        canonicalDir: `.agents/${capability.contentKind}s`,
+    })));
+    const scanTargets = [...mappingScanTargets, ...capabilityScanTargets].filter((target, index, targets) => targets.findIndex((candidate) => candidate.contentType === target.contentType &&
+        candidate.canonicalDir === target.canonicalDir) === index);
+    const canonicalEntries = await dependencies.scanCanonical(scopeRoot, scope, scanTargets);
+    let agentCoverage = userAgentMaterializationCoverage({
+        registrations: coverageRegistrations,
+        activeProviders: activeAdapterNames,
+    });
+    if (scope === 'user' && agentCoverage !== 'all') {
+        const activeAgentMappings = activeAdapters.flatMap((adapter) => dependencies
+            .getSyncMappings(adapter, scope)
+            .filter(({ contentType }) => contentType === 'agent'));
+        if (activeAgentMappings.some(({ nativeRead }) => !nativeRead)) {
+            agentCoverage = 'all';
+        }
+        else if (activeAgentMappings.length > 0 && agentCoverage === 'none') {
+            agentCoverage = 'bundled';
+        }
+    }
     const reports = [];
     const strayCandidates = [];
     const trackedCanonicalByProvider = new Set(manifest.entries.map((entry) => `${entry.provider}|${normalizeToPosixPath(entry.canonicalPath)}`));
     const activeProviderNames = new Set(activeAdapters.map((adapter) => adapter.name));
+    const activeExtensionProviders = new Set(providerContext
+        ? providerContext.registrations
+            .filter(({ adapter }) => activeProviderNames.has(adapter.name))
+            .flatMap(({ extensions }) => extensions.map(({ provider }) => provider))
+        : [...activeProviderNames]);
     const extensionCanonicalEntries = scope === 'user' &&
-        (activeProviderNames.has('codex') || activeProviderNames.has('cursor'))
-        ? [
-            ...canonicalEntries,
-            ...(await dependencies.scanBundledManagedAgents()),
-        ]
+        (activeExtensionProviders.has('codex') ||
+            activeExtensionProviders.has('cursor'))
+        ? mergeUserScopeMaterializationEntries(canonicalEntries, await dependencies.scanBundledManagedAgents())
         : canonicalEntries;
-    const codexExtensionPlan = activeProviderNames.has('codex')
+    const codexExtensionPlan = activeExtensionProviders.has('codex')
         ? await dependencies.computeCodexProjectExtensionPlan(scopeRoot, extensionCanonicalEntries, undefined, { userConfigDir })
         : undefined;
-    const cursorExtensionPlan = activeProviderNames.has('cursor')
+    const cursorExtensionPlan = activeExtensionProviders.has('cursor')
         ? await dependencies.computeCursorProjectExtensionPlan(scopeRoot, extensionCanonicalEntries, undefined, { userConfigDir })
         : undefined;
     const materializationPlans = [
@@ -429,9 +528,6 @@ async function collectScopeReports(scope, context, dependencies) {
             if (!mappingContentTypes.has(entry.contentType)) {
                 continue;
             }
-            if (!contentTypeAllowed(entry.contentType, scope)) {
-                continue;
-            }
             const matchedMapping = mappings.find((mapping) => mapping.contentType === entry.contentType &&
                 entryInsideMapping(entry.providerPath, mapping.providerDir));
             if (!matchedMapping) {
@@ -549,7 +645,9 @@ async function collectScopeReports(scope, context, dependencies) {
         manifest,
         reports: filtered.reports,
         strayCandidates: filtered.candidates,
-        activeAdapterNames: activeAdapters.map((adapter) => adapter.name),
+        activeAdapterNames,
+        userAgentMaterializationCoverage: scope === 'user' ? agentCoverage : 'none',
+        providerContext,
     };
 }
 async function runStatusCommand(context, dependencies, options = {}) {
@@ -577,6 +675,7 @@ async function runStatusCommand(context, dependencies, options = {}) {
         scopeRoots.set(scope, scopeReportCollection.scopeRoot);
     }
     const summary = summarizeReports(reports);
+    const providerRefreshAdvice = collectProviderRefreshAdvice(scopeCollections);
     const hasIssues = summary.total > 0 && summary.inSync !== summary.total;
     if (options.hook) {
         if (summary.drifted > 0 || summary.missing > 0) {
@@ -592,14 +691,19 @@ async function runStatusCommand(context, dependencies, options = {}) {
         }
         return;
     }
-    const packReport = await collectPackReport(scopeRoots, unavailableScopes, scopeCollections.some(({ scope, activeAdapterNames }) => scope === 'user' &&
-        activeAdapterNames.some((name) => name === 'codex' || name === 'cursor')), dependencies);
+    const packReport = await collectPackReport(scopeRoots, unavailableScopes, scopeCollections.some((collection) => collection.userAgentMaterializationCoverage === 'all')
+        ? 'all'
+        : scopeCollections.some((collection) => collection.userAgentMaterializationCoverage === 'bundled')
+            ? 'bundled'
+            : 'none', dependencies);
     if (context.json) {
         const payload = {
             scope: context.scope,
             reports,
             summary,
             packs: packReport,
+            packEvidence: packReport.evidence,
+            providerRefreshAdvice,
         };
         if (!context.interactive && summary.stray > 0) {
             payload.remediation = DEFAULT_REMEDIATION;
@@ -612,6 +716,9 @@ async function runStatusCommand(context, dependencies, options = {}) {
         if (packSummary) {
             context.logger.info(packSummary);
         }
+        const providerSummary = formatProviderRefreshAdvice(providerRefreshAdvice);
+        if (providerSummary)
+            context.logger.info(providerSummary);
     }
     if (summary.stray > 0) {
         if (context.interactive) {
@@ -758,6 +865,11 @@ export function createStatusCommand(overrides = {}) {
         ...DEFAULT_DEPENDENCIES,
         ...overrides,
     };
+    if (overrides.resolveProviderScopeContext === undefined &&
+        (overrides.getAdapters !== undefined ||
+            overrides.getConfigAwareAdapters !== undefined)) {
+        dependencies.resolveProviderScopeContext = undefined;
+    }
     return withScopeOption(new Command('status'))
         .description('Report provider sync and drift status')
         .option('--hook', 'Emit a minimal pre-commit message: warn on managed drift, info on strays')

package/dist/commands/sync/apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AAyEtB,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,IAAI,CAAC,CAgHf"}
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../src/commands/sync/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAiB3D,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EAExB,MAAM,cAAc,CAAC;AA2TtB,wBAAsB,YAAY,CAChC,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,aAAa,EAAE,EAC3B,YAAY,EAAE,uBAAuB,GACpC,OAAO,CAAC,IAAI,CAAC,CA4Kf"}

package/dist/commands/sync/apply.js

@@ -1,24 +1,161 @@
-import { countPlannedOperations } from './sync.utils.js';
-function countSkippedEntries(scopePlans) {
+import { getProviderRegistrations, } from '../../providers/shared/registry.js';
+import { adviseProviderRefresh, } from '../../providers/shared/restart-adviser.js';
+import { buildCollectionLifecycle, countPlannedOperations, formatCollectionLifecycle, toSyncOutputPlan, } from './sync.utils.js';
+function extensionResultContentKind(registrations, result) {
+    const registration = registrations.find(({ adapter }) => adapter.name === result.provider);
+    const candidates = registration?.capabilities.filter(({ scope, support, projectionModes }) => scope === result.scope &&
+        support === 'supported' &&
+        projectionModes.includes('materialization-extension'));
+    // Extension operation identities do not carry a canonical asset kind.
+    // Attribute only when provider capability evidence gives one unambiguous
+    // content kind; otherwise leave the exact result unattributed.
+    return candidates?.length === 1 ? candidates[0].contentKind : undefined;
+}
+function buildProviderRefreshAdvice(input) {
+    const registrations = getProviderRegistrations();
+    const changed = [
+        ...input.operationResults
+            .filter(({ status }) => status === 'changed')
+            .map(({ scope, provider, contentKind }) => ({
+            scope,
+            provider,
+            contentKind,
+        })),
+        ...input.extensionResults
+            .filter(({ status }) => status === 'changed')
+            .flatMap((result) => {
+            const contentKind = extensionResultContentKind(registrations, result);
+            return contentKind === undefined
+                ? []
+                : [{ scope: result.scope, provider: result.provider, contentKind }];
+        }),
+    ];
+    const seen = new Set();
+    return changed.flatMap(({ scope, provider, contentKind }) => {
+        const key = `${scope}:${provider}:${contentKind}`;
+        if (seen.has(key))
+            return [];
+        seen.add(key);
+        const policy = registrations
+            .find(({ adapter }) => adapter.name === provider)
+            ?.capabilities.find((capability) => capability.scope === scope && capability.contentKind === contentKind)?.catalogRefresh ?? {
+            state: 'unknown',
+            reason: 'Provider or capability is not registered',
+        };
+        return [
+            {
+                scope,
+                provider,
+                contentKind,
+                materialization: 'changed',
+                visibility: adviseProviderRefresh({
+                    policy,
+                    materialization: 'changed',
+                }),
+            },
+        ];
+    });
+}
+function formatProviderRefreshAdvice(advice) {
+    return advice
+        .map(({ scope, provider, contentKind, visibility }) => {
+        const recovery = visibility.recovery[0]?.message;
+        return `Provider visibility [${scope}] ${provider}/${contentKind}: ${visibility.state} — ${recovery ?? visibility.reason}`;
+    })
+        .join('\n');
+}
+function countSkippedExtensionEntries(scopePlans) {
     return scopePlans.reduce((total, scopePlan) => {
         const extensionSkipped = scopePlan.materializationExtensions.reduce((count, extension) => count +
             extension.operations.filter((operation) => operation.action === 'skip')
                 .length, 0);
-        return (total +
-            scopePlan.plan.entries.filter((entry) => entry.operation === 'skip')
-                .length +
-            extensionSkipped);
+        return total + extensionSkipped;
     }, 0);
 }
-function buildSummary(scopePlans, applied, failed) {
+function buildSummary(scopePlans, coreApplied, coreFailed, coreSkipped, extensionApplied, extensionFailed) {
     return {
         plannedOperations: countPlannedOperations(scopePlans),
-        applied,
-        failed,
-        skipped: countSkippedEntries(scopePlans),
+        applied: coreApplied + extensionApplied,
+        failed: coreFailed + extensionFailed,
+        skipped: coreSkipped + countSkippedExtensionEntries(scopePlans),
     };
 }
-function formatAppliedOutput(scopePlans, dependencies) {
+function normalizeOperationResults(plan, result) {
+    if (result.operations) {
+        return result.operations;
+    }
+    const plannedOperations = [...plan.entries, ...plan.removals];
+    return plannedOperations.map((operation) => {
+        return {
+            scope: plan.scope,
+            provider: operation.provider,
+            contentKind: operation.canonical.type,
+            asset: operation.canonical.name,
+            action: operation.operation,
+            status: operation.operation === 'skip' ? 'current' : 'unknown',
+        };
+    });
+}
+function materializationOperationIdentity(operation) {
+    return JSON.stringify([
+        operation.provider,
+        operation.target,
+        operation.path,
+        operation.action,
+        operation.entryName ?? null,
+    ]);
+}
+function syncOperationIdentity(operation) {
+    return JSON.stringify([
+        operation.scope,
+        operation.provider,
+        operation.contentKind,
+        operation.asset,
+        operation.action,
+    ]);
+}
+function coreHumanStatus(status) {
+    switch (status) {
+        case 'changed':
+        case 'current':
+        case 'failed':
+        case 'missing':
+        case 'unknown':
+            return status;
+        default:
+            return 'unknown';
+    }
+}
+function formatCoreResults(plan, evidence, dependencies) {
+    const operations = [...plan.entries, ...plan.removals];
+    if (operations.length === 0) {
+        if ((plan.collections?.length ?? 0) > 0) {
+            return 'Core results\nNo per-entry operations.';
+        }
+        return dependencies.formatSyncPlan(plan, true);
+    }
+    const resultsByIdentity = new Map((evidence?.operationResults ?? []).map((result) => [
+        syncOperationIdentity(result),
+        result,
+    ]));
+    const lines = operations.map((operation) => {
+        const result = resultsByIdentity.get(syncOperationIdentity({
+            scope: plan.scope,
+            provider: operation.provider,
+            contentKind: operation.canonical.type,
+            asset: operation.canonical.name,
+            action: operation.operation,
+        }));
+        const status = coreHumanStatus(result?.status);
+        const failure = result?.failure ? ` — ${result.failure}` : '';
+        return `- ${plan.scope}:${operation.provider}:${operation.canonical.type}:${operation.operation} ${operation.canonical.name}\n  reason: ${operation.reason}\n  result: ${status}${failure}`;
+    });
+    const aggregate = evidence?.aggregateOnly
+        ? `\nCore aggregate result: applied ${evidence.aggregate.applied}, failed ${evidence.aggregate.failed}, skipped ${evidence.aggregate.skipped}; non-skip named outcomes remain unknown.`
+        : '';
+    return `Core results${aggregate}\n${lines.join('\n')}`;
+}
+function formatAppliedOutput(scopePlans, coreApplyEvidence, dependencies) {
     if (scopePlans.length === 0) {
         return dependencies.formatSyncPlan({
             scope: 'project',
@@ -28,28 +165,53 @@ function formatAppliedOutput(scopePlans, dependencies) {
     }
     return scopePlans
         .map((scopePlan) => {
-        const syncOutput = dependencies.formatSyncPlan(scopePlan.plan, true);
+        const syncOutput = formatCoreResults(scopePlan.plan, coreApplyEvidence.find((evidence) => evidence.plan === scopePlan.plan), dependencies);
+        const collectionOutput = formatCollectionLifecycle(buildCollectionLifecycle(scopePlan, coreApplyEvidence.find((evidence) => evidence.plan === scopePlan.plan)
+            ?.collectionResults));
         if (scopePlan.materializationExtensions.length === 0) {
-            return `Scope: ${scopePlan.scope}\n${syncOutput}`;
+            return [`Scope: ${scopePlan.scope}\n${syncOutput}`, collectionOutput]
+                .filter(Boolean)
+                .join('\n\n');
         }
         const extensionSections = scopePlan.materializationExtensions.map((extension) => {
+            const resultsByIdentity = new Map((extension.operationResults ?? []).map((result) => [
+                materializationOperationIdentity(result),
+                result,
+            ]));
             const lines = extension.operations.map((operation) => {
                 const entry = operation.entryName
                     ? ` (${operation.entryName})`
                     : '';
-                return `- ${operation.provider}:${operation.target}:${operation.action} ${operation.path}${entry} (${operation.reason})`;
+                const result = resultsByIdentity.get(materializationOperationIdentity(operation));
+                const status = result?.status ?? 'unknown';
+                const failure = result?.failure ? ` — ${result.failure}` : '';
+                return `- ${operation.provider}:${operation.target}:${operation.action} ${operation.path}${entry}\n  reason: ${operation.reason}\n  result: ${status}${failure}`;
             });
-            return `${extension.provider} extension (applied)\n${lines.join('\n')}`;
+            return `${extension.provider} extension results\n${lines.join('\n')}`;
         });
-        return `Scope: ${scopePlan.scope}\n${syncOutput}\n\n${extensionSections.join('\n\n')}`;
+        return [
+            `Scope: ${scopePlan.scope}\n${syncOutput}`,
+            collectionOutput,
+            extensionSections.join('\n\n'),
+        ]
+            .filter(Boolean)
+            .join('\n\n');
     })
         .join('\n\n');
 }
 export async function runSyncApply(context, scopePlans, dependencies) {
-    let applied = 0;
-    let failed = 0;
+    let extensionApplied = 0;
+    let extensionFailed = 0;
+    let coreApplied = 0;
+    let coreFailed = 0;
+    let coreSkipped = 0;
+    const operationResults = [];
+    const coreApplyEvidence = [];
+    const extensionOperationResults = [];
     for (const scopePlan of scopePlans) {
-        const hasSyncEntries = scopePlan.plan.entries.length > 0 || scopePlan.plan.removals.length > 0;
+        const hasSyncEntries = scopePlan.plan.entries.length > 0 ||
+            scopePlan.plan.removals.length > 0 ||
+            (scopePlan.plan.collections?.length ?? 0) > 0;
         const hasExtensionPlannedOperations = scopePlan.materializationExtensionPlans.some((plan) => plan.operations.some((operation) => operation.action !== 'skip'));
         // Derived from the same diagnostic that produced the pre-mutation advisory
         // (`detectVersionSkew` in ./index), so the restamp and the warning cannot
@@ -63,8 +225,18 @@ export async function runSyncApply(context, scopePlans, dependencies) {
         }
         if (hasSyncEntries || shouldRefreshManifestVersion) {
             const result = await dependencies.executeSyncPlan(scopePlan.plan, scopePlan.manifest, scopePlan.manifestPath);
-            applied += result.applied;
-            failed += result.failed;
+            coreApplied += result.applied;
+            coreFailed += result.failed;
+            coreSkipped += result.skipped;
+            const normalizedResults = normalizeOperationResults(scopePlan.plan, result);
+            operationResults.push(...normalizedResults);
+            coreApplyEvidence.push({
+                plan: scopePlan.plan,
+                operationResults: normalizedResults,
+                aggregateOnly: result.operations === undefined,
+                aggregate: result,
+                collectionResults: result.collectionResults ?? [],
+            });
         }
         for (const plan of scopePlan.materializationExtensionPlans) {
             if (!plan.operations.some((operation) => operation.action !== 'skip')) {
@@ -77,15 +249,22 @@ export async function runSyncApply(context, scopePlans, dependencies) {
                 throw new Error(`Materialization extension ${plan.provider} disappeared before apply.`);
             }
             const result = await dependencies.applyMaterializationExtensionPlan(extension, scopePlan.scopeRoot, plan);
-            applied += result.applied;
-            failed += result.failed;
+            extensionApplied += result.applied;
+            extensionFailed += result.failed;
+            extensionOperationResults.push(...(result.operations ?? []).map((operation) => ({
+                ...operation,
+                scope: scopePlan.scope,
+            })));
             const summary = scopePlan.materializationExtensions.find((candidate) => candidate.provider === plan.provider);
             if (summary) {
-                Object.assign(summary, result);
+                summary.applied = result.applied;
+                summary.failed = result.failed;
+                summary.skipped = result.skipped;
+                summary.operationResults = result.operations;
             }
         }
     }
-    const summary = buildSummary(scopePlans, applied, failed);
+    const summary = buildSummary(scopePlans, coreApplied, coreFailed, coreSkipped, extensionApplied, extensionFailed);
     const providerMismatches = scopePlans
         .map((scopePlan) => scopePlan.providerMismatches)
         .filter((mismatch) => mismatch !== undefined);
@@ -109,29 +288,41 @@ export async function runSyncApply(context, scopePlans, dependencies) {
         failed: extension.failed,
         skipped: extension.skipped,
     }));
+    const providerRefreshAdvice = buildProviderRefreshAdvice({
+        operationResults,
+        extensionResults: extensionOperationResults,
+    });
+    const collectionOperations = scopePlans.flatMap((scopePlan) => buildCollectionLifecycle(scopePlan, coreApplyEvidence.find((evidence) => evidence.plan === scopePlan.plan)
+        ?.collectionResults));
     if (context.json) {
         context.logger.json({
             scope: context.scope,
             dryRun: false,
-            plans: scopePlans.map((scopePlan) => scopePlan.plan),
+            plans: scopePlans.map(toSyncOutputPlan),
+            collectionOperations,
             summary,
             providerMismatches,
             versionSkew,
             materializationExtensions,
+            operationResults,
             codexExtensions,
+            providerRefreshAdvice,
         });
     }
     else {
-        context.logger.info(formatAppliedOutput(scopePlans, dependencies));
+        context.logger.info(formatAppliedOutput(scopePlans, coreApplyEvidence, dependencies));
         if (summary.plannedOperations === 0) {
             context.logger.info('\nNo changes required.');
         }
-        else if (failed > 0) {
+        else if (summary.failed > 0) {
             context.logger.warn('\nSync completed with partial failures.');
         }
         else {
             context.logger.success('\nSync applied successfully.');
         }
+        if (providerRefreshAdvice.length > 0) {
+            context.logger.info(`\n${formatProviderRefreshAdvice(providerRefreshAdvice)}`);
+        }
     }
-    process.exitCode = failed > 0 ? 1 : 0;
+    process.exitCode = summary.failed > 0 ? 1 : 0;
 }