@open-agent-toolkit/cli 0.2.62 → 0.2.64

package/dist/commands/tools/shared/provider-reachability.js

@@ -0,0 +1,358 @@
+const CONTENT_KIND_ORDER = [
+    'skill',
+    'agent',
+    'rule',
+    'directory',
+];
+function projectionModeFor(capability) {
+    return (capability.projectionModes.find((mode) => mode !== 'unsupported') ?? null);
+}
+/**
+ * Maps a registered catalog-refresh policy onto visibility evidence.
+ *
+ * The switch is exhaustive with a `never` default rather than a fall-through:
+ * a policy state added later must fail to compile instead of silently
+ * becoming "needs a new session", which would be advice this repository never
+ * sourced.
+ */
+function visibilityFor(policy, provider) {
+    switch (policy.state) {
+        case 'unknown':
+            return { state: 'unknown', reason: policy.reason };
+        case 'live':
+            return {
+                state: 'live',
+                reason: `${provider} reads the projected content without a refresh`,
+            };
+        case 'manual-refresh':
+            return {
+                state: 'manual-refresh',
+                reason: `${provider} needs a catalog refresh before the change is visible`,
+            };
+        case 'restart-required':
+            return {
+                state: 'restart-required',
+                reason: `${provider} needs a new session before the change is visible`,
+            };
+        default: {
+            const unhandled = policy;
+            throw new Error(`Unhandled provider catalog refresh state: ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+function syncRecovery(scope) {
+    return {
+        code: 'run-sync',
+        command: `oat sync --scope ${scope}`,
+        message: `Run sync for ${scope} scope to materialize provider views.`,
+    };
+}
+function recoveryFor(input) {
+    if (input.activationState === 'inactive') {
+        return [
+            {
+                code: 'enable-provider',
+                message: `Enable ${input.provider} in the ${input.scope} sync config to project content to it.`,
+            },
+        ];
+    }
+    if (input.support !== 'supported')
+        return [];
+    if (input.materialization === 'failed') {
+        return [
+            {
+                code: 'retry-sync',
+                command: `oat sync --scope ${input.scope}`,
+                message: `Re-run sync for ${input.provider} and inspect the reported failure.`,
+            },
+        ];
+    }
+    if (input.materialization === 'missing')
+        return [syncRecovery(input.scope)];
+    if (!input.projected)
+        return [];
+    if (input.visibility === 'manual-refresh') {
+        return [
+            {
+                code: 'refresh-provider-catalog',
+                message: `Refresh the ${input.provider} catalog to see the updated content.`,
+            },
+        ];
+    }
+    if (input.visibility === 'restart-required') {
+        return [
+            {
+                code: 'restart-provider-session',
+                message: `Start a new ${input.provider} session to see the updated content.`,
+            },
+        ];
+    }
+    if (input.visibility === 'unknown') {
+        return [
+            {
+                code: 'verify-provider-visibility',
+                message: `Verify in ${input.provider} that the content is listed; no sourced refresh contract is registered.`,
+            },
+        ];
+    }
+    return [];
+}
+/**
+ * Projects one reachability row per active-or-registered provider and per
+ * content kind the pack places at this scope.
+ */
+export function projectProviderReachability(input) {
+    const { providerScopeContext: context } = input;
+    const scope = context.scope;
+    const active = new Set(context.activeProviders);
+    const kinds = CONTENT_KIND_ORDER.filter((kind) => (input.assets[kind]?.length ?? 0) > 0);
+    const evidence = [];
+    for (const registration of context.registrations) {
+        const provider = registration.adapter.name;
+        const activation = context.activation.find((candidate) => candidate.provider === provider);
+        const activationState = active.has(provider) ? 'active' : 'inactive';
+        const capabilities = input.capabilities ?? registration.capabilities;
+        for (const contentKind of kinds) {
+            const assets = input.assets[contentKind] ?? [];
+            const capability = capabilities.find((candidate) => candidate.scope === scope && candidate.contentKind === contentKind);
+            const support = capability?.support ?? 'unknown';
+            const projectionModes = capability?.projectionModes ?? [];
+            const capabilityReason = capability === undefined
+                ? `${provider} registers no ${scope} ${contentKind} capability`
+                : (capability.unsupportedReason ??
+                    `${provider} projects ${scope} ${contentKind} content via ${projectionModes.join(', ') || 'no mode'}`);
+            let materialization;
+            if (activationState === 'inactive' || support !== 'supported') {
+                materialization = {
+                    state: 'not-applicable',
+                    detail: activationState === 'inactive'
+                        ? `${provider} is inactive for ${scope} scope`
+                        : capabilityReason,
+                };
+            }
+            else if (input.mode === 'lifecycle' && input.syncRan === false) {
+                materialization = {
+                    state: 'not-applicable',
+                    detail: 'No sync ran for this operation',
+                };
+            }
+            else if (input.mode === 'lifecycle') {
+                materialization = observedMaterialization({
+                    provider,
+                    scope,
+                    contentKind,
+                    assets,
+                    syncOperationResults: input.syncOperationResults ?? [],
+                    extensionResults: input.extensionResults ?? [],
+                });
+            }
+            else {
+                const unmaterialized = input.unmaterializedAssets?.[contentKind] ?? [];
+                materialization =
+                    unmaterialized.length > 0
+                        ? {
+                            state: 'missing',
+                            detail: `${provider} has no ${scope} ${contentKind} materialization for ${unmaterialized.length} managed asset(s)`,
+                        }
+                        : {
+                            // A read-only surface observed no sync. The pack inventory can
+                            // report a positive absence, but its silence is not evidence
+                            // that the provider view exists: claiming `materialized` here
+                            // would assert reachability nothing established, which is
+                            // exactly what DR-260831 forbids. Silence stays a non-claim.
+                            state: 'not-applicable',
+                            detail: `No sync was observed for ${provider} ${scope} ${contentKind} content`,
+                        };
+            }
+            const policy = input.refreshPolicy?.({ provider, scope, contentKind }) ??
+                capability?.catalogRefresh ?? {
+                state: 'unknown',
+                reason: `No ${provider} ${scope} ${contentKind} refresh contract is registered`,
+            };
+            const reachable = activationState === 'active' && support === 'supported';
+            // Projection and materialization already collapse to `not-applicable`
+            // for a provider that is inactive or cannot carry this content kind.
+            // Visibility follows them: refresh or restart advice about a provider
+            // that is not even active reads as guidance the user should act on.
+            const visibility = reachable
+                ? visibilityFor(policy, provider)
+                : {
+                    state: 'not-applicable',
+                    reason: activationState === 'inactive'
+                        ? `${provider} is inactive for ${scope} scope, so it has no catalog visibility`
+                        : `${provider} does not project ${scope} ${contentKind} content, so it has no catalog visibility`,
+                };
+            const projected = materialization.state === 'materialized';
+            const projectionState = activationState === 'inactive' || support !== 'supported'
+                ? 'not-applicable'
+                : projected
+                    ? 'projected'
+                    : materialization.state === 'missing'
+                        ? 'absent'
+                        : 'not-applicable';
+            evidence.push({
+                provider,
+                scope,
+                contentKind,
+                assets: materialization.state === 'missing'
+                    ? (input.unmaterializedAssets?.[contentKind] ?? assets)
+                    : assets,
+                activation: {
+                    state: activationState,
+                    source: activation?.source ?? 'undetected-unset',
+                    reason: activation?.reason ??
+                        `${provider} has no recorded activation evidence`,
+                },
+                capability: {
+                    support,
+                    projectionModes,
+                    reason: capabilityReason,
+                },
+                projection: {
+                    state: projectionState,
+                    mode: projectionState === 'not-applicable' || capability === undefined
+                        ? null
+                        : projectionModeFor(capability),
+                },
+                materialization,
+                visibility,
+                recovery: recoveryFor({
+                    provider,
+                    scope,
+                    activationState,
+                    support,
+                    materialization: materialization.state,
+                    visibility: visibility.state,
+                    projected,
+                }),
+            });
+        }
+    }
+    return evidence;
+}
+/**
+ * Materialization state observed from a sync run's own operation results.
+ *
+ * A sync that ran and planned nothing for this provider and content kind is
+ * not evidence of a missing projection, so it stays a non-claim rather than
+ * becoming a warning that would flip a healthy pack evidence block to
+ * `partial`.
+ */
+/**
+ * Canonical identity of an asset path.
+ *
+ * Sync operation results identify an asset by its canonical entry name, while
+ * a pack inventory row carries the asset's filesystem path. Comparing the
+ * final path segment is what keeps one pack's operation from being attributed
+ * to a different pack that merely shares a content kind.
+ */
+function canonicalAssetName(path) {
+    return (path.split('/').pop() ?? path).replace(/\.[^.]+$/, '');
+}
+function operationBelongsToAssets(identity, assetNames) {
+    // An operation with no usable identity cannot be attributed to a specific
+    // pack, so it is deliberately not counted for any of them.
+    if (identity === undefined || identity === '')
+        return false;
+    return assetNames.has(canonicalAssetName(identity));
+}
+function observedMaterialization(input) {
+    const { provider, scope, contentKind } = input;
+    const assetNames = new Set(input.assets.map(canonicalAssetName));
+    const operations = [
+        ...input.syncOperationResults.filter((result) => result.provider === provider &&
+            result.scope === scope &&
+            result.contentKind === contentKind &&
+            operationBelongsToAssets(result.asset, assetNames)),
+        ...input.extensionResults.filter((result) => result.provider === provider &&
+            result.scope === scope &&
+            (result.contentKind === undefined ||
+                result.contentKind === contentKind) &&
+            // A `config` target is the provider's shared aggregate file, which is
+            // not any one pack's asset but which every managed role for this
+            // provider depends on. It is therefore attributed provider-wide
+            // rather than dropped; a `role` target must still match this row's
+            // own assets so one pack's failure cannot be reported against another.
+            (result.target === 'config' ||
+                operationBelongsToAssets(result.path, assetNames))),
+    ];
+    const failed = operations.filter((operation) => operation.status === 'failed');
+    if (failed.length > 0) {
+        return {
+            state: 'failed',
+            detail: `${provider} ${scope} ${contentKind} materialization failed: ${failed
+                .map((operation) => operation.failure)
+                .filter((failure) => Boolean(failure))
+                .join('; ') || 'no failure detail reported'}`,
+        };
+    }
+    // Status is classified explicitly rather than as "anything but failed":
+    // `missing`, `unsupported`, `planned`, and `unknown` are not evidence that
+    // the provider view now exists.
+    const succeeded = operations.filter((operation) => operation.status === 'changed' || operation.status === 'current');
+    if (succeeded.length > 0) {
+        return {
+            state: 'materialized',
+            detail: `${succeeded.length} ${provider} ${scope} ${contentKind} operation(s) succeeded`,
+        };
+    }
+    const missing = operations.filter((operation) => operation.status === 'missing');
+    if (missing.length > 0) {
+        return {
+            state: 'missing',
+            detail: `${provider} has no ${scope} ${contentKind} projection for ${missing.length} asset(s)`,
+        };
+    }
+    return {
+        state: 'not-applicable',
+        detail: `No ${provider} ${scope} ${contentKind} operation was required`,
+    };
+}
+/**
+ * Re-projects existing reachability rows with a sync run's observed results.
+ *
+ * Activation and capability were already derived from the registry before the
+ * sync ran and do not change; only projection, materialization, visibility,
+ * and recovery are refined. Inactive or unsupported rows are returned
+ * untouched.
+ */
+export function applySyncEvidence(providers, input) {
+    if (!input.syncRan)
+        return [...providers];
+    return providers.map((evidence) => {
+        if (evidence.activation.state === 'inactive' ||
+            evidence.capability.support !== 'supported') {
+            return evidence;
+        }
+        const materialization = observedMaterialization({
+            provider: evidence.provider,
+            scope: evidence.scope,
+            contentKind: evidence.contentKind,
+            assets: evidence.assets,
+            syncOperationResults: input.syncOperationResults ?? [],
+            extensionResults: input.extensionResults ?? [],
+        });
+        const projected = materialization.state === 'materialized';
+        return {
+            ...evidence,
+            projection: {
+                state: projected
+                    ? 'projected'
+                    : materialization.state === 'missing'
+                        ? 'absent'
+                        : 'not-applicable',
+                mode: evidence.projection.mode,
+            },
+            materialization,
+            recovery: recoveryFor({
+                provider: evidence.provider,
+                scope: evidence.scope,
+                activationState: evidence.activation.state,
+                support: evidence.capability.support,
+                materialization: materialization.state,
+                visibility: evidence.visibility.state,
+                projected,
+            }),
+        };
+    });
+}

package/dist/commands/tools/shared/sync-evidence.d.ts

@@ -0,0 +1,57 @@
+import type { ManagedContentKind, ProviderCatalogRefreshPolicy } from '../../../providers/shared/registry.js';
+import type { ConcreteScope } from '../../../shared/types.js';
+import type { ProviderExtensionOperationEvidence, ProviderSyncOperationEvidence } from './provider-reachability.js';
+/**
+ * Per-provider refresh advice as the sync run reports it.
+ *
+ * Structurally mirrors the `providerRefreshAdvice` entries in the sync JSON
+ * payload. The tools lifecycle consumes that payload; it never reshapes it.
+ */
+export interface SyncProviderRefreshAdvice {
+    scope: ConcreteScope;
+    provider: string;
+    contentKind: ManagedContentKind;
+    visibility?: {
+        state?: string;
+        reason?: string;
+        policy?: ProviderCatalogRefreshPolicy;
+    };
+}
+/** Normalized evidence from one sync run at one scope. */
+export interface SyncRunEvidence {
+    scope: ConcreteScope;
+    ran: boolean;
+    /**
+     * The run's aggregate failure count from `summary.failed`.
+     *
+     * Carried separately because a sync can fail without throwing and without
+     * emitting a per-operation `failed` result: a rejected collection counts as
+     * a failure but is not a planned operation.
+     */
+    failedOperations: number;
+    operationResults: readonly ProviderSyncOperationEvidence[];
+    extensionResults: readonly ProviderExtensionOperationEvidence[];
+    refreshAdvice: readonly SyncProviderRefreshAdvice[];
+}
+export declare function emptySyncRunEvidence(scope: ConcreteScope): SyncRunEvidence;
+/**
+ * Normalizes a captured sync JSON payload into reachability inputs.
+ *
+ * Defensive rather than trusting: the payload shape is owned by the sync
+ * command, so an absent or renamed field degrades to "no evidence" instead of
+ * throwing inside a lifecycle operation that already succeeded.
+ */
+export declare function normalizeSyncEvidence(scope: ConcreteScope, payload: unknown): SyncRunEvidence;
+/**
+ * Builds a refresh-policy lookup from observed sync advice.
+ *
+ * Returns `undefined` for a provider the run reported nothing about, so the
+ * mapper falls back to the registered registry policy rather than inventing
+ * one.
+ */
+export declare function refreshPolicyFromAdvice(advice: readonly SyncProviderRefreshAdvice[]): (input: {
+    provider: string;
+    scope: ConcreteScope;
+    contentKind: ManagedContentKind;
+}) => ProviderCatalogRefreshPolicy | undefined;
+//# sourceMappingURL=sync-evidence.d.ts.map

package/dist/commands/tools/shared/sync-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-evidence.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/shared/sync-evidence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,4BAA4B,EAC7B,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,KAAK,EACV,kCAAkC,EAClC,6BAA6B,EAC9B,MAAM,yBAAyB,CAAC;AAEjC;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,kBAAkB,CAAC;IAChC,UAAU,CAAC,EAAE;QACX,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,4BAA4B,CAAC;KACvC,CAAC;CACH;AAED,0DAA0D;AAC1D,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,aAAa,CAAC;IACrB,GAAG,EAAE,OAAO,CAAC;IACb;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,SAAS,6BAA6B,EAAE,CAAC;IAC3D,gBAAgB,EAAE,SAAS,kCAAkC,EAAE,CAAC;IAChE,aAAa,EAAE,SAAS,yBAAyB,EAAE,CAAC;CACrD;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,eAAe,CAS1E;AAgBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,OAAO,GACf,eAAe,CA0HjB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,yBAAyB,EAAE,GAC3C,CAAC,KAAK,EAAE;IACT,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,WAAW,EAAE,kBAAkB,CAAC;CACjC,KAAK,4BAA4B,GAAG,SAAS,CAQ7C"}

package/dist/commands/tools/shared/sync-evidence.js

@@ -0,0 +1,147 @@
+export function emptySyncRunEvidence(scope) {
+    return {
+        scope,
+        ran: false,
+        failedOperations: 0,
+        operationResults: [],
+        extensionResults: [],
+        refreshAdvice: [],
+    };
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * Normalizes a captured sync JSON payload into reachability inputs.
+ *
+ * Defensive rather than trusting: the payload shape is owned by the sync
+ * command, so an absent or renamed field degrades to "no evidence" instead of
+ * throwing inside a lifecycle operation that already succeeded.
+ */
+export function normalizeSyncEvidence(scope, payload) {
+    const record = asRecord(payload);
+    if (record === null)
+        return { ...emptySyncRunEvidence(scope), ran: true };
+    const summary = asRecord(record.summary);
+    const failedOperations = typeof summary?.failed === 'number' ? summary.failed : 0;
+    const operationResults = asArray(record.operationResults).flatMap((entry) => {
+        const operation = asRecord(entry);
+        const provider = asString(operation?.provider);
+        const status = asString(operation?.status);
+        // `contentKind` is required on the same footing as `provider` and
+        // `status`: defaulting it would let an operation of unknown kind be
+        // attributed to a skill row it never touched. An absent field is
+        // dropped rather than guessed.
+        const contentKind = asString(operation?.contentKind);
+        if (!operation ||
+            provider === undefined ||
+            status === undefined ||
+            contentKind === undefined) {
+            return [];
+        }
+        return [
+            {
+                provider,
+                scope: asString(operation.scope) ?? scope,
+                contentKind: contentKind,
+                asset: asString(operation.asset) ?? '',
+                status: status,
+                ...(asString(operation.failure) !== undefined
+                    ? { failure: asString(operation.failure) }
+                    : {}),
+            },
+        ];
+    });
+    const extensionResults = asArray(record.materializationExtensions).flatMap((entry) => {
+        const extension = asRecord(entry);
+        const provider = asString(extension?.provider);
+        if (!extension || provider === undefined)
+            return [];
+        return asArray(extension.operationResults ?? extension.operations).flatMap((candidate) => {
+            const operation = asRecord(candidate);
+            const status = asString(operation?.status);
+            if (!operation || status === undefined)
+                return [];
+            return [
+                {
+                    provider,
+                    scope: asString(extension.scope) ?? scope,
+                    // Extension operations carry no canonical content kind; the
+                    // registered extensions materialize agent roles.
+                    contentKind: 'agent',
+                    ...(asString(operation.target) !== undefined
+                        ? { target: asString(operation.target) }
+                        : {}),
+                    ...(asString(operation.path) !== undefined
+                        ? { path: asString(operation.path) }
+                        : {}),
+                    status: status,
+                    ...(asString(operation.failure) !== undefined
+                        ? { failure: asString(operation.failure) }
+                        : {}),
+                },
+            ];
+        });
+    });
+    const refreshAdvice = asArray(record.providerRefreshAdvice).flatMap((entry) => {
+        const advice = asRecord(entry);
+        const provider = asString(advice?.provider);
+        const contentKind = asString(advice?.contentKind);
+        if (!advice || provider === undefined || contentKind === undefined) {
+            return [];
+        }
+        const visibility = asRecord(advice.visibility);
+        return [
+            {
+                provider,
+                scope: asString(advice.scope) ?? scope,
+                contentKind: contentKind,
+                ...(visibility
+                    ? {
+                        visibility: {
+                            ...(asString(visibility.state) !== undefined
+                                ? { state: asString(visibility.state) }
+                                : {}),
+                            ...(asString(visibility.reason) !== undefined
+                                ? { reason: asString(visibility.reason) }
+                                : {}),
+                            ...(asRecord(visibility.policy)
+                                ? {
+                                    policy: visibility.policy,
+                                }
+                                : {}),
+                        },
+                    }
+                    : {}),
+            },
+        ];
+    });
+    return {
+        scope,
+        ran: true,
+        failedOperations,
+        operationResults,
+        extensionResults,
+        refreshAdvice,
+    };
+}
+/**
+ * Builds a refresh-policy lookup from observed sync advice.
+ *
+ * Returns `undefined` for a provider the run reported nothing about, so the
+ * mapper falls back to the registered registry policy rather than inventing
+ * one.
+ */
+export function refreshPolicyFromAdvice(advice) {
+    return ({ provider, scope, contentKind }) => advice.find((candidate) => candidate.provider === provider &&
+        candidate.scope === scope &&
+        candidate.contentKind === contentKind)?.visibility?.policy;
+}

package/dist/commands/tools/update/index.d.ts

@@ -2,10 +2,6 @@ import { type AutoSyncDependencies } from '../../tools/shared/auto-sync.js';
 import type { ToolInfo } from '../../tools/shared/types.js';
 import { Command } from 'commander';
 import { type UpdateTarget, type UpdateResult, type UpdateToolsDependencies } from './update-tools.js';
-export declare function buildSyncSubprocessArgs(entrypoint: string, execArgv: string[], options: {
-    cwd: string;
-    scope: 'project' | 'user';
-}): string[];
 export declare function createToolsUpdateCommand(dependencies?: UpdateToolsDependencies, syncDependencies?: AutoSyncDependencies): Command;
 /**
  * @internal Exported for focused unit coverage. Current/newer workflow tools

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/update/index.ts"],"names":[],"mappings":"AAgBA,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,kCAAkC,CAAC;AAS1C,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAKvE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAG7B,MAAM,gBAAgB,CAAC;AAmBxB,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAAA;CAAE,GAClD,MAAM,EAAE,CAaV;AAgCD,wBAAgB,wBAAwB,CACtC,YAAY,GAAE,uBAA6C,EAC3D,gBAAgB,GAAE,oBAA8C,GAC/D,OAAO,CAkPT;AAwCD;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAS7E;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,YAAY,GACnB,OAAO,CAOT;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,OAAO,GACd,MAAM,CAMR"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/update/index.ts"],"names":[],"mappings":"AAeA,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,kCAAkC,CAAC;AAa1C,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAKvE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAG7B,MAAM,gBAAgB,CAAC;AAgCxB,wBAAgB,wBAAwB,CACtC,YAAY,GAAE,uBAA6C,EAC3D,gBAAgB,GAAE,oBAA8C,GAC/D,OAAO,CAkPT;AAuDD;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAS7E;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,YAAY,GACnB,OAAO,CAOT;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,OAAO,GACd,MAAM,CAMR"}

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

@@ -1,4 +1,3 @@
-import { execFile } from 'node:child_process';
 import { chmod } from 'node:fs/promises';
 import { join } from 'node:path';
 import { buildCommandContext } from '../../../app/command-context.js';
@@ -8,10 +7,13 @@ import { copyDirWithStatus, copyFileWithStatus, } from '../../init/tools/shared/
 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 { reconcilePackLifecycles } from '../../tools/shared/pack-lifecycle.js';
-import { evaluatePackLifecycleOutcome, } from '../../tools/shared/pack-lifecycle-outcome.js';
+import { evaluatePackLifecycleOutcome, providerSyncOutcomeFromAutoSync, } from '../../tools/shared/pack-lifecycle-outcome.js';
+import { withLifecycleProviderEvidence } from '../../tools/shared/pack-provider-evidence.js';
 import { reconcileProjectToolsConfig } from '../../tools/shared/project-tools-config.js';
+import { applySyncEvidence } from '../../tools/shared/provider-reachability.js';
 import { scanTools } from '../../tools/shared/scan-tools.js';
 import { readOatConfig, writeOatConfig } from '../../../config/oat-config.js';
 import { resolveAssetsRoot } from '../../../fs/assets.js';
@@ -36,35 +38,7 @@ const defaultDependencies = {
     inventoryScopedPack,
     reconcilePacks: reconcilePackLifecycles,
 };
-export function buildSyncSubprocessArgs(entrypoint, execArgv, options) {
-    // `--scope` is a per-command option on `sync` (not a global flag), so it must
-    // come AFTER the `sync` subcommand token. `--cwd` remains a global flag and
-    // can precede the subcommand.
-    return [
-        ...execArgv,
-        entrypoint,
-        '--cwd',
-        options.cwd,
-        'sync',
-        '--scope',
-        options.scope,
-    ];
-}
-const defaultSyncDependencies = {
-    runSync: async ({ scope, cwd }) => {
-        await new Promise((resolve, reject) => {
-            execFile(process.execPath, buildSyncSubprocessArgs(process.argv[1], process.execArgv, {
-                cwd,
-                scope,
-            }), { cwd: process.cwd() }, (error) => {
-                if (error)
-                    reject(error);
-                else
-                    resolve();
-            });
-        });
-    },
-};
+const defaultSyncDependencies = inProcessSyncDependencies;
 const VALID_PACKS = [
     'core',
     'ideas',
@@ -270,18 +244,26 @@ function finalizeUpdateLifecycle(lifecycle, syncResults) {
         const relevant = syncResults.filter(({ scopes }) => scopes.some((scope) => outcome.selection.targetScopes.includes(scope)));
         if (relevant.length === 0)
             return outcome;
+        const merged = {
+            synced: relevant.every(({ synced }) => synced),
+            scopes: [...new Set(relevant.flatMap(({ scopes }) => scopes))],
+            error: relevant.find(({ error }) => error)?.error ?? null,
+            evidence: relevant.flatMap(({ evidence }) => evidence),
+        };
+        // The pre-sync outcome already carries registry-derived activation and
+        // capability evidence; the sync run only refines projection and
+        // materialization, so the existing rows are re-projected rather than
+        // dropped.
+        const providers = applySyncEvidence(outcome.sync.providers, {
+            syncRan: merged.evidence.some(({ ran }) => ran),
+            syncOperationResults: merged.evidence.flatMap(({ operationResults }) => operationResults),
+            extensionResults: merged.evidence.flatMap(({ extensionResults }) => extensionResults),
+        });
         return evaluatePackLifecycleOutcome({
             selection: outcome.selection,
             lifecycle: outcome.canonical.results,
-            sync: {
-                scopes: [...new Set(relevant.flatMap(({ scopes }) => scopes))],
-                status: relevant.every(({ synced }) => synced) ? 'complete' : 'failed',
-                providers: [],
-                ...(relevant.find(({ error }) => error)?.error
-                    ? { error: relevant.find(({ error }) => error).error }
-                    : {}),
-            },
-            finalEvidence: outcome.finalEvidence,
+            sync: providerSyncOutcomeFromAutoSync(merged, providers),
+            finalEvidence: withLifecycleProviderEvidence(outcome.finalEvidence, providers),
         });
     });
 }