@open-agent-toolkit/cli 0.2.63 → 0.2.64

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),
         });
     });
 }

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

@@ -1 +1 @@
-{"version":3,"file":"update-tools.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/update/update-tools.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"update-tools.d.ts","sourceRoot":"","sources":["../../../../src/commands/tools/update/update-tools.ts"],"names":[],"mappings":"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"}

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

@@ -2,8 +2,10 @@ import { join } from 'node:path';
 import { hasScopedPackRealizationEvidence, packScopeFactsFromInventory, projectPackEvidence, } from '../../tools/shared/pack-evidence.js';
 import { inventoryScopedPack } from '../../tools/shared/pack-inventory.js';
 import {} from '../../tools/shared/pack-lifecycle.js';
-import { evaluatePackLifecycleOutcome, resolveAdditivePackScopeSelection, } from '../../tools/shared/pack-lifecycle-outcome.js';
+import { evaluatePackLifecycleOutcome, notRunProviderSyncOutcome, resolveAdditivePackScopeSelection, } from '../../tools/shared/pack-lifecycle-outcome.js';
 import { getPackDefinition } from '../../tools/shared/pack-manifest.js';
+import { lifecycleProviderEvidence, withLifecycleProviderEvidence, } from '../../tools/shared/pack-provider-evidence.js';
+import { resolveProviderScopeContexts } from '../../tools/shared/provider-context.js';
 function getBundledPackAssets(pack, scope) {
     const assets = getPackDefinition(pack).assets.filter(({ scopes, ownership }) => scopes.includes(scope) && ownership[scope] === 'managed');
     return {
@@ -71,7 +73,7 @@ export async function updateTools(target, scopes, cwd, home, dryRun, dependencie
             return result;
         }
         const lifecycle = await dependencies.reconcilePacks(requests, { dryRun });
-        result.lifecycle = updateLifecycleOutcomes(lifecycle);
+        result.lifecycle = await updateLifecycleOutcomes(lifecycle);
         result.plans.push(...lifecycle.map(({ plan }) => plan));
         for (const entry of lifecycle) {
             const definition = getPackDefinition(entry.request.pack);
@@ -252,9 +254,14 @@ export async function updateTools(target, scopes, cwd, home, dryRun, dependencie
     }
     return result;
 }
-function updateLifecycleOutcomes(results) {
+async function updateLifecycleOutcomes(results) {
     const verifiable = results.filter(({ apply }) => apply === null || ('inventory' in apply && apply.inventory !== undefined));
     const packs = [...new Set(verifiable.map(({ request }) => request.pack))];
+    // Every request carries the scope root it acted on, so the config-aware
+    // provider context is resolvable without re-deriving paths here.
+    const providerContexts = await resolveProviderScopeContexts({
+        scopeRoots: Object.fromEntries(verifiable.map(({ request }) => [request.scope, request.scopeRoot])),
+    });
     return packs.map((pack) => {
         const lifecycle = verifiable.filter(({ request }) => request.pack === pack);
         const requestedScopes = lifecycle.map(({ request }) => request.scope);
@@ -273,13 +280,21 @@ function updateLifecycleOutcomes(results) {
                 .map(({ request }) => request.scope),
             unknownScopes: [],
         });
+        const providers = lifecycleProviderEvidence({
+            pack,
+            scopedInventories: finalScopes,
+            providerContexts,
+            scopes: selection.targetScopes,
+        });
+        const sync = notRunProviderSyncOutcome(providers, 'Auto-sync has not run for this operation');
+        const providerEvidence = withLifecycleProviderEvidence(finalEvidence, providers);
         if (lifecycle.every(({ apply }) => apply === null)) {
             return {
                 schemaVersion: 1,
                 selection,
                 canonical: { status: 'unchanged', results: lifecycle },
-                sync: { scopes: [], status: 'not-run', providers: [] },
-                finalEvidence,
+                sync,
+                finalEvidence: providerEvidence,
                 status: 'complete',
                 recovery: [],
             };
@@ -287,8 +302,8 @@ function updateLifecycleOutcomes(results) {
         return evaluatePackLifecycleOutcome({
             selection,
             lifecycle,
-            sync: { scopes: [], status: 'not-run', providers: [] },
-            finalEvidence,
+            sync,
+            finalEvidence: providerEvidence,
         });
     });
 }
@@ -305,7 +320,7 @@ export function failedUpdateLifecycleOutcomes(target, scopes, error) {
             targetScopes: scopes,
         },
         canonical: { status: 'failed', results: [] },
-        sync: { scopes: [], status: 'not-run', providers: [] },
+        sync: notRunProviderSyncOutcome([], 'Canonical apply failed before auto-sync'),
         finalEvidence: null,
         status: 'failed',
         recovery: [{ code: 'canonical-apply-failed', message }],

package/dist/config/json.d.ts

@@ -1,2 +1,38 @@
+/**
+ * Parse one OAT config document.
+ *
+ * This is the single parse chokepoint for every OAT config read, so the
+ * prototype question is decided here rather than in each consumer.
+ *
+ * `jsonc-parser`'s `parse` fills a plain object by assignment, and assignment
+ * to a member literally named `__proto__` reaches the legacy prototype setter.
+ * That loses the key as data *and* installs its value as the parsed object's
+ * prototype, after which normalization reads the injected members as though
+ * they had been configured: a config file holding only
+ * `{"__proto__":{"git":{"defaultBranch":"x"}}}` made `oat config get
+ * git.defaultBranch` answer `x`. So the tree API is used instead, and the tree
+ * is materialized here rather than by `getNodeValue`.
+ *
+ * Materialization defines every own key with `Object.defineProperty`, which
+ * stores `__proto__` as an ordinary own data property without ever invoking
+ * the prototype setter. The objects it builds are otherwise completely
+ * ordinary: they keep `Object.prototype`, so every consumer coercion — most
+ * importantly `String(value)` in the `projects.defaultScope` diagnostic at
+ * `config/oat-config.ts` — behaves byte-identically to the previous
+ * implementation, and the result round-trips through `JSON.stringify`
+ * unchanged. `getNodeValue` is deliberately not used: it returns
+ * null-prototype objects, which break those coercions, and it recurses, which
+ * roughly halved the accepted nesting depth and turned deep-but-valid
+ * documents into a `RangeError` instead of the contracted `SyntaxError`. The
+ * walk below uses an explicit stack for that reason, which restores parity
+ * with the previous implementation. Parity, not a guarantee: `parseTree` still
+ * recurses while scanning, so the hard limit is a stack depth that moves with
+ * the host and the JIT rather than a fixed number.
+ *
+ * The error contract is untouched: `parseTree` reports the same `ParseError`
+ * codes at the same offsets as `parse` for every input, so the set of
+ * documents that are rejected and the `SyntaxError` message are both
+ * byte-identical to the previous implementation.
+ */
 export declare function parseJsonConfig(raw: string, configPath: string): unknown;
 //# sourceMappingURL=json.d.ts.map

package/dist/config/json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/config/json.ts"],"names":[],"mappings":"AAYA,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAcxE"}
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/config/json.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAuBxE"}

package/dist/config/json.js

@@ -1,18 +1,150 @@
-import { parse as parseJsonc, printParseErrorCode, } from 'jsonc-parser';
+import { parseTree, printParseErrorCode, } from 'jsonc-parser';
 const JSON_CONFIG_PARSE_OPTIONS = {
     allowTrailingComma: true,
     disallowComments: true,
 };
+/**
+ * Parse one OAT config document.
+ *
+ * This is the single parse chokepoint for every OAT config read, so the
+ * prototype question is decided here rather than in each consumer.
+ *
+ * `jsonc-parser`'s `parse` fills a plain object by assignment, and assignment
+ * to a member literally named `__proto__` reaches the legacy prototype setter.
+ * That loses the key as data *and* installs its value as the parsed object's
+ * prototype, after which normalization reads the injected members as though
+ * they had been configured: a config file holding only
+ * `{"__proto__":{"git":{"defaultBranch":"x"}}}` made `oat config get
+ * git.defaultBranch` answer `x`. So the tree API is used instead, and the tree
+ * is materialized here rather than by `getNodeValue`.
+ *
+ * Materialization defines every own key with `Object.defineProperty`, which
+ * stores `__proto__` as an ordinary own data property without ever invoking
+ * the prototype setter. The objects it builds are otherwise completely
+ * ordinary: they keep `Object.prototype`, so every consumer coercion — most
+ * importantly `String(value)` in the `projects.defaultScope` diagnostic at
+ * `config/oat-config.ts` — behaves byte-identically to the previous
+ * implementation, and the result round-trips through `JSON.stringify`
+ * unchanged. `getNodeValue` is deliberately not used: it returns
+ * null-prototype objects, which break those coercions, and it recurses, which
+ * roughly halved the accepted nesting depth and turned deep-but-valid
+ * documents into a `RangeError` instead of the contracted `SyntaxError`. The
+ * walk below uses an explicit stack for that reason, which restores parity
+ * with the previous implementation. Parity, not a guarantee: `parseTree` still
+ * recurses while scanning, so the hard limit is a stack depth that moves with
+ * the host and the JIT rather than a fixed number.
+ *
+ * The error contract is untouched: `parseTree` reports the same `ParseError`
+ * codes at the same offsets as `parse` for every input, so the set of
+ * documents that are rejected and the `SyntaxError` message are both
+ * byte-identical to the previous implementation.
+ */
 export function parseJsonConfig(raw, configPath) {
     const errors = [];
-    const parsed = parseJsonc(raw, errors, JSON_CONFIG_PARSE_OPTIONS);
+    const root = parseTree(raw, errors, JSON_CONFIG_PARSE_OPTIONS);
     if (errors.length > 0) {
         const details = errors
             .map((error) => formatParseError(raw, error))
             .join('; ');
         throw new SyntaxError(`Config at ${configPath} is not valid JSON: ${details}`);
     }
-    return parsed;
+    // TypeScript narrowing after the rejection above: `parseTree` returns no root
+    // for any document that holds no value — empty or whitespace-only content,
+    // but also a stray `]` or comment-only content — and every one of those
+    // records a parse error and has already thrown. The branch keeps the walk
+    // total rather than describing a reachable case.
+    if (root === undefined) {
+        return undefined;
+    }
+    return materializeTree(root);
+}
+/**
+ * Assignment that cannot be intercepted by an accessor on the prototype chain.
+ *
+ * `target[key] = value` would invoke the legacy `__proto__` setter; a data
+ * descriptor never does. The descriptor matches what a plain assignment would
+ * otherwise produce, so the property is indistinguishable from an ordinary
+ * one, and re-defining a repeated key overwrites in place exactly as
+ * assignment did.
+ */
+function defineOwnProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true,
+    });
+}
+/**
+ * Convert a parse tree into plain JavaScript values without recursion.
+ *
+ * Each frame carries the callback that attaches its finished value to the
+ * parent container, so containers are created on the way down and filled as
+ * their children pop. Nesting depth costs a heap array entry rather than a
+ * call frame, which is what keeps a deeply nested config from overflowing the
+ * stack.
+ */
+function materializeTree(root) {
+    let result;
+    const stack = [
+        {
+            node: root,
+            attach: (value) => {
+                result = value;
+            },
+        },
+    ];
+    while (stack.length > 0) {
+        const frame = stack.pop();
+        if (frame === undefined) {
+            break;
+        }
+        const { node } = frame;
+        if (node.type === 'array') {
+            const children = node.children ?? [];
+            const array = new Array(children.length);
+            frame.attach(array);
+            // Pushed in reverse so children pop in source order.
+            for (let index = children.length - 1; index >= 0; index -= 1) {
+                const child = children[index];
+                if (child === undefined) {
+                    continue;
+                }
+                stack.push({
+                    node: child,
+                    attach: (value) => {
+                        array[index] = value;
+                    },
+                });
+            }
+            continue;
+        }
+        if (node.type === 'object') {
+            const object = {};
+            frame.attach(object);
+            const properties = node.children ?? [];
+            for (let index = properties.length - 1; index >= 0; index -= 1) {
+                const property = properties[index];
+                const keyNode = property?.children?.[0];
+                const valueNode = property?.children?.[1];
+                // A property with no value node is an incomplete document, which the
+                // error check has already rejected; skipping it matches `getNodeValue`.
+                if (keyNode === undefined || valueNode === undefined) {
+                    continue;
+                }
+                const key = String(keyNode.value);
+                stack.push({
+                    node: valueNode,
+                    attach: (value) => {
+                        defineOwnProperty(object, key, value);
+                    },
+                });
+            }
+            continue;
+        }
+        frame.attach(node.value);
+    }
+    return result;
 }
 function formatParseError(raw, error) {
     const location = offsetToLineColumn(raw, error.offset);

package/dist/drift/index.d.ts

@@ -3,5 +3,7 @@ export type { CopyTransform } from './detector.js';
 export type { DriftReport, DriftState } from './drift.types.js';
 export { filterKnownStrays } from './known-strays.js';
 export type { FilterKnownStraysOptions, FilterKnownStraysResult, KnownStrayCandidate, KnownStraySources, } from './known-strays.js';
+export { diagnoseSkillViews, resolveExpectedSkillProjections, } from './skill-view-diagnostic.js';
+export type { ExpectedProjection, ProjectedSkillVersion, SkillViewClass, SkillViewDiagnosis, SkillViewDiagnostic, SkillViewObservation, } from './skill-view-diagnostic.js';
 export { detectStrays } from './strays.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/drift/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/drift/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/drift/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EACV,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,+BAA+B,GAChC,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC"}

package/dist/drift/index.js

@@ -1,3 +1,4 @@
 export { detectDrift } from './detector.js';
 export { filterKnownStrays } from './known-strays.js';
+export { diagnoseSkillViews, resolveExpectedSkillProjections, } from './skill-view-diagnostic.js';
 export { detectStrays } from './strays.js';