@aopslabs/aops 0.3.31 → 0.3.33

package/dist/commands/view.js

@@ -7,7 +7,7 @@ import { readAopsRepoConfig } from '../utils/repo-config.js';
 import { resolveProjectBindingContext } from '../utils/project-context.js';
 import { invokeHostedToolWithApiState, requireApiState, unwrapHostedToolResult, } from '../utils/agent-gateway.js';
 import { resolveRepoFirstAgentspacePaths, resolveRepoFirstProjectmanPaths, } from '../utils/repo-first-projectman.js';
-import { resolveRepoFirstWorkspaceRelativeRoot } from '../utils/repo-first-storage.js';
+import { resolveAopsCacheRoot, resolveRepoFirstWorkspaceRelativeRoot } from '../utils/repo-first-storage.js';
 import { resolveHostedWorkspacePaths } from '../utils/hosted-workspace.js';
 import { readLocalMemoryEntryFiles } from '../utils/memory-workspace.js';
 import { readSessionStateNudges } from '../utils/session-state.js';
@@ -352,7 +352,7 @@ async function loadWorkspace(context) {
     const pmPaths = resolveRepoFirstProjectmanPaths(context);
     const agentPaths = resolveRepoFirstAgentspacePaths(context);
     const hostedPaths = resolveHostedWorkspacePaths(context.repoRoot);
-    const docRoot = path.join(context.repoRoot, '.aops', 'docman');
+    const docRoot = path.join(resolveAopsCacheRoot(context.repoRoot), 'docman');
     const [boardsRaw, tasksRaw, sprintsRaw, issuesRaw, feedbackRaw, reviewRequestsRaw, utasksRaw, memory, discussions, experience, skills, prompts, docsRaw, sessionStateNudges,] = await Promise.all([
         readMarkdownRecords(pmPaths.boards, { repoRoot: context.repoRoot }),
         readMarkdownRecords(pmPaths.tasks, { repoRoot: context.repoRoot }),
@@ -461,6 +461,50 @@ function microtaskUid(microtask, phase, phaseIndex, microIndex) {
     const microPos = typeof microtask.position === 'number' ? microtask.position : microIndex;
     return `P${phasePos}M${microPos}`;
 }
+function phasesForSprint(workspace, sprint) {
+    const embedded = recordArray(sprint.frontmatter.phases);
+    if (embedded.length > 0)
+        return embedded;
+    const bodyPhaseOrder = new Map();
+    let pendingPhasePosition;
+    for (const line of sprint.body.split(/\r?\n/)) {
+        const heading = line.match(/^###\s+(\d+)\./);
+        if (heading) {
+            pendingPhasePosition = Number(heading[1]) - 1;
+            continue;
+        }
+        const id = pendingPhasePosition !== undefined ? line.match(/^- ID:\s+(.+)$/) : undefined;
+        if (id) {
+            bodyPhaseOrder.set(id[1].trim(), pendingPhasePosition);
+            pendingPhasePosition = undefined;
+        }
+    }
+    const aliases = idAliases(sprint);
+    const matching = workspace.utasks.filter((utask) => [utask.frontmatter.sprintLocalId, utask.frontmatter.sprintId, utask.frontmatter.sprintRemoteId]
+        .some((value) => sameIdOrPrefix(value, aliases)));
+    const grouped = new Map();
+    for (const utask of matching) {
+        const phaseId = stringValue(utask.frontmatter.phaseRemoteId)
+            ?? stringValue(utask.frontmatter.phaseId)
+            ?? stringValue(utask.frontmatter.phaseName)
+            ?? 'unassigned';
+        const phase = grouped.get(phaseId) ?? {
+            id: phaseId,
+            name: stringValue(utask.frontmatter.phaseName) ?? 'Unassigned',
+            position: bodyPhaseOrder.get(phaseId)
+                ?? (typeof utask.frontmatter.phasePosition === 'number' ? utask.frontmatter.phasePosition : grouped.size),
+            microtasks: [],
+        };
+        phase.microtasks.push({ ...utask.frontmatter });
+        grouped.set(phaseId, phase);
+    }
+    return [...grouped.values()].sort((left, right) => (typeof left.position === 'number' ? left.position : Number.MAX_SAFE_INTEGER)
+        - (typeof right.position === 'number' ? right.position : Number.MAX_SAFE_INTEGER)).map((phase) => ({
+        ...phase,
+        microtasks: recordArray(phase.microtasks).sort((left, right) => (typeof left.position === 'number' ? left.position : Number.MAX_SAFE_INTEGER)
+            - (typeof right.position === 'number' ? right.position : Number.MAX_SAFE_INTEGER)),
+    }));
+}
 function boardColumns(board) {
     const columns = recordArray(board.frontmatter.columns);
     if (columns.length > 0)
@@ -1203,7 +1247,7 @@ async function buildSprintView(context, options, selector) {
     const reviewRequests = reviewRequestsForSubject(workspace, sprint);
     const memory = memoryForSubject(workspace, 'projectman.sprint', sprint);
     const discussions = discussionsForSubject(workspace, 'projectman.sprint', sprint);
-    const phases = recordArray(sprint.frontmatter.phases);
+    const phases = phasesForSprint(workspace, sprint);
     const microtaskRows = phases.flatMap((phase, phaseIndex) => recordArray(phase.microtasks).map((microtask, microIndex) => [
         microtaskUid(microtask, phase, phaseIndex, microIndex),
         phase.name ?? '-',
@@ -1656,13 +1700,13 @@ export async function runViewExperience(options = {}) {
 export async function runViewSkills(options = {}) {
     await emitView('view.skills', options, async (context, viewOptions) => {
         const workspace = await loadWorkspace(context);
-        return hostedView('Hosted Skills Mirror', '.aops/hosted/skills', workspace.skills, viewOptions);
+        return hostedView('Hosted Skills Mirror', '.aops-cache/hosted/skills', workspace.skills, viewOptions);
     });
 }
 export async function runViewPrompts(options = {}) {
     await emitView('view.prompts', options, async (context, viewOptions) => {
         const workspace = await loadWorkspace(context);
-        return hostedView('Hosted Prompts Mirror', '.aops/hosted/prompts', workspace.prompts, viewOptions);
+        return hostedView('Hosted Prompts Mirror', '.aops-cache/hosted/prompts', workspace.prompts, viewOptions);
     });
 }
 export async function runViewDocs(options = {}) {
@@ -1674,7 +1718,7 @@ export async function runViewDocs(options = {}) {
                 data: workspace.docs.map(materializeRecord),
             },
             markdown: ['# Docman Mirror Documents', '', docTable(workspace.docs, viewOptions)].join('\n'),
-            footer: commonFooter('.aops/docman', workspace.docs),
+            footer: commonFooter('.aops-cache/docman', workspace.docs),
         };
     });
 }
@@ -1722,9 +1766,9 @@ Examples:
 Notes:
   Use dashboard for a first scan across boards, tasks, memory, issues, and recent discussions.
   Use view digest for handoff/resume context; digest is scoped and usually cheaper than a full dashboard.
-  Dashboard is read-only and reads local .aops/** files only.
+  Dashboard is read-only and reads local .aops-cache/** files only.
 `);
-    addNoArg(cmd, 'boards', 'List Projectman boards from .aops/projectman', runViewBoards);
+    addNoArg(cmd, 'boards', 'List Projectman boards from .aops-cache/projectman', runViewBoards);
     addOneArg(cmd, 'board', 'Show a Projectman board with tasks and sprints', runViewBoard);
     const tasksCmd = addViewOptions(cmd.command('tasks').description('List Projectman kanban tasks'))
         .option('--board <selector>', 'Filter by board slug, name, id, or 8+ char prefix')
@@ -1845,7 +1889,7 @@ Examples:
   aops-cli view digest --task <selector> --depth deep --max-bytes 32768
 
 Notes:
-  local-cache view commands use local .aops/** files only.
+  local-cache view commands use local .aops-cache/** files only.
   hosted view commands call read-only hosted list APIs and do not sync, mutate, or write cache files.
 `);
     return cmd;

package/dist/lib/commercial-setup-readiness-adapter.js

@@ -126,7 +126,6 @@ export function createExistingAgentAssetsReadinessAuthority(options) {
         const result = await options.provider.apply({
             action: 'install',
             fromRelease: options.fromRelease,
-            target: 'all',
         });
         if (result.availability !== 'available' || result.state !== 'ready') {
             throw new Error('commercial_setup_agent_assets_not_ready');

package/dist/lib/community-migration-snapshot.js

@@ -435,9 +435,7 @@ async function inspectRestoreDatabases(params) {
     return { main, candidate, rescue };
 }
 export function assertCommunityNativeRestoredSnapshotStateV1(evidence, restored) {
-    if (restored.migrationPlan.action !== 'verify-only' || restored.requiresSnapshotEvidence ||
-        restored.migrationPlan.pendingMigrations.length !== 0 ||
-        restored.sourceFingerprintSha256 !== evidence.sourceMigrationStateFingerprintSha256 ||
+    if (restored.sourceFingerprintSha256 !== evidence.sourceMigrationStateFingerprintSha256 ||
         restored.lineageId !== evidence.sourceLineageId ||
         restored.schemaFingerprintSha256 !== evidence.sourceSchemaFingerprintSha256 ||
         restored.receiptFingerprintSha256 !== evidence.sourceReceiptFingerprintSha256 ||
@@ -793,6 +791,12 @@ export async function cleanupCommunityNativeManagedRestoreRescueV1(params) {
         receipt.restoredStateFingerprintSha256 !== evidenceRead.evidence.sourceStateFingerprintSha256) {
         throw new Error('community_native_managed_restore_cleanup_receipt_mismatch');
     }
+    const observed = await inspectRestoreDatabases({ runtime, state, candidateDatabase, rescueDatabase, signal: params.signal });
+    if (!observed.main || observed.candidate) {
+        throw new Error('community_native_managed_restore_cleanup_state_invalid');
+    }
+    if (!observed.rescue)
+        return { rescueDatabase, dropped: false };
     const policy = readCommunityNativeMigrationPolicy(params.sourceRoot);
     const restored = await (params.planStrictPgSchema ?? planCommunityStrictPgSchema)({
         repoUrl: buildCommunityNativePostgresUrl(state, 'aops'),
@@ -800,12 +804,6 @@ export async function cleanupCommunityNativeManagedRestoreRescueV1(params) {
         policy,
     });
     assertCommunityNativeRestoredSnapshotStateV1(evidenceRead.evidence, restored);
-    const observed = await inspectRestoreDatabases({ runtime, state, candidateDatabase, rescueDatabase, signal: params.signal });
-    if (!observed.main || observed.candidate) {
-        throw new Error('community_native_managed_restore_cleanup_state_invalid');
-    }
-    if (!observed.rescue)
-        return { rescueDatabase, dropped: false };
     await dropDatabase({ runtime, state, database: rescueDatabase, signal: params.signal });
     return { rescueDatabase, dropped: true };
 }

package/dist/lib/community-native-database-recovery.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { compareCanonicalText } from '@aopslabs/artifact-trust-contracts';
 import { createCommunityNativeApplicationReferenceV1, readCommunityNativeApplicationUpdate, sameCommunityNativeApplicationContent, } from './community-native-application-recovery.js';
 import { assertCommunityNativeRestoredSnapshotStateV1, cleanupCommunityNativeManagedRestoreRescueV1, readCommunityNativeSnapshotEvidenceV1, restoreCommunityNativeManagedSnapshotV1, } from './community-migration-snapshot.js';
-import { inspectCommunityNativeSource, loadExternalPostgresUrl, } from './community-native-lifecycle.js';
+import { loadExternalPostgresUrl, } from './community-native-lifecycle.js';
 import { planCommunityNativeMigration } from './community-native-migration.js';
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const RAW_SHA256 = /^[a-f0-9]{64}$/;
@@ -243,15 +243,6 @@ function writePhase(params) {
         recordedAt: params.now().toISOString(),
     });
 }
-function assertPriorSource(params) {
-    const source = inspectCommunityNativeSource(params.sourceRoot);
-    const expected = params.prepared.prior.content;
-    if (source.releaseVersion !== expected.releaseVersion || source.packageSha256 !== expected.packageSha256 ||
-        source.lockfileSha256 !== expected.lockfileSha256 || source.sourceFileCount !== expected.sourceFileCount ||
-        source.sourceInventorySha256 !== expected.sourceInventorySha256) {
-        throw new Error('community_native_database_restore_prior_source_mismatch');
-    }
-}
 function evidenceFileName(kind, planSha256) {
     return `${kind === 'managed-verified-backup' ? 'managed' : 'external'}-${planSha256}.json`;
 }
@@ -274,7 +265,6 @@ export async function restoreCommunityNativeDatabaseForUpdate(params, dependenci
         !update.outcome.migration.snapshotEvidenceSha256) {
         throw new Error('community_native_database_restore_migrating_update_required');
     }
-    assertPriorSource({ sourceRoot: params.sourceRoot, prepared: update.prepared });
     const migration = update.outcome.migration;
     const evidenceKind = migration.snapshotEvidenceKind;
     const evidenceSha256 = migration.snapshotEvidenceSha256;
@@ -350,6 +340,7 @@ export async function restoreCommunityNativeDatabaseForUpdate(params, dependenci
     if (!sameCommunityNativeApplicationContent(active, update.prepared.target)) {
         throw new Error('community_native_database_restore_update_target_not_active');
     }
+    const recoverySourceRoot = path.resolve(params.state.source.root);
     if (evidenceRead.evidence.kind === 'external-snapshot-attestation') {
         if (params.state.profile !== 'native-external-postgres') {
             throw new Error('community_native_database_restore_external_profile_mismatch');
@@ -370,7 +361,7 @@ export async function restoreCommunityNativeDatabaseForUpdate(params, dependenci
         }
         const repoUrl = loadExternalPostgresUrl(params.state.postgres.configRef, params.state.postgres.tlsPolicy);
         const planned = await (dependencies.planNativeMigration ?? planCommunityNativeMigration)({
-            sourceRoot: path.resolve(params.sourceRoot),
+            sourceRoot: recoverySourceRoot,
             repoUrl,
             signal: params.signal,
         });
@@ -408,7 +399,7 @@ export async function restoreCommunityNativeDatabaseForUpdate(params, dependenci
         evidencePath: prepared.evidencePath,
         expectedEvidenceSha256: prepared.evidenceSha256,
         backupRoot: params.paths.backupRoot,
-        sourceRoot: path.resolve(params.sourceRoot),
+        sourceRoot: recoverySourceRoot,
         state: params.state.postgres,
         instanceName: params.state.instanceName,
         instanceRoot: params.paths.instanceRoot,
@@ -444,7 +435,7 @@ export async function restoreCommunityNativeDatabaseForUpdate(params, dependenci
         evidenceRoot: params.paths.migrationEvidenceRoot,
         evidencePath: prepared.evidencePath,
         expectedEvidenceSha256: prepared.evidenceSha256,
-        sourceRoot: path.resolve(params.sourceRoot),
+        sourceRoot: recoverySourceRoot,
         state: params.state.postgres,
         instanceName: params.state.instanceName,
         instanceRoot: params.paths.instanceRoot,

package/dist/lib/community-native-lifecycle.js

@@ -1905,6 +1905,9 @@ export async function resolveCommunityNativeSnapshotEvidence(params) {
             '--bundle-dir', input.bundleDirectory,
             '--receipt', input.receiptPath,
             '--set-id', input.backupSetId,
+            '--policy', input.policyPath,
+            '--inventory', input.inventoryPath,
+            '--migrations-root', input.migrationsRoot,
         ], {
             encoding: 'utf8',
             env: { ...process.env, AOPS_PG_URL: input.repoUrl },
@@ -1944,6 +1947,13 @@ export async function resolveCommunityNativeSnapshotEvidence(params) {
     const firstPending = params.context.planning.migrationPlan.pendingMigrations?.[0]?.tag;
     const repoUrl = loadUrl(postgres);
     const snapshotEntry = ownedSetSnapshotEntry(params.context.sourceRoot);
+    const packagedSnapshotAssets = path.join(params.context.sourceRoot, 'scripts', 'community-migration-policy-package-v1.json');
+    const snapshotPolicyPath = existsSync(packagedSnapshotAssets)
+        ? packagedSnapshotAssets
+        : path.join(params.context.sourceRoot, 'apps', 'aops-server', 'scripts', 'community-migration-policy-v1.json');
+    const snapshotInventoryPath = existsSync(packagedSnapshotAssets)
+        ? path.join(params.context.sourceRoot, 'scripts', 'community-domain-ownership-v1.json')
+        : path.join(params.context.sourceRoot, 'apps', 'aops-server', 'scripts', 'community-domain-ownership-v1.json');
     const bundleDirectory = path.join(params.backupRoot, `${params.instanceName}-${firstPending ? `pre-${firstPending}` : 'pre-migration'}-owned-set`);
     const receiptPath = `${bundleDirectory}.receipt.json`;
     const snapshot = snapshotEntry
@@ -1953,6 +1963,9 @@ export async function resolveCommunityNativeSnapshotEvidence(params) {
             bundleDirectory,
             receiptPath,
             backupSetId: `${params.instanceName}-${Date.now()}`,
+            policyPath: snapshotPolicyPath,
+            inventoryPath: snapshotInventoryPath,
+            migrationsRoot: params.context.sourceRoot,
         })
         : null;
     if (snapshot) {

package/dist/lib/setup-agent-assets-bridge.js

@@ -1,176 +1,56 @@
+import { installSimpleAgentAssets, readSimpleAgentAssetsState, resolveSimpleAgentAssetsRoots, } from './simple-agent-assets.js';
+import { resolveSetupAgentAssetsReleaseV1 } from './setup-agent-assets-release.js';
 export const SETUP_AGENT_ASSETS_CONTRACT = Object.freeze({
-    task: 'TASK-136',
-    surface: 'agent-assets-client-v1',
-    statusCommand: 'aops assets status --verify quick --json',
-    installCommand: 'aops assets install --target all --apply --json',
-    repairCommand: 'aops assets repair --repair-bindings --apply --json',
-    transitionRemovalCondition: 'Satisfied by the native TASK-136 provider composed after TASK-137; never route through setup agent-assets.',
-});
-export const SETUP_AGENT_ASSETS_GATEWAYS = Object.freeze({
-    codex: '<codex-home>/skills/aops/SKILL.md',
-    claude: '<claude-home>/skills/aops/SKILL.md',
+    surface: 'aops-assets-simple-v1',
+    statusCommand: 'aops assets status --json',
+    installCommand: 'aops assets install --target all --json',
 });
-export async function verifySetupAgentAssetsReleaseInput(verifyRelease, releaseRoot) {
-    return verifyRelease({ releaseRoot, verificationMode: 'offline' });
-}
 export function createSetupAgentAssetsProvider(dependencies = {}) {
-    const resolveRoots = dependencies.roots ?? resolveAgentAssetsRoots;
-    const readStatus = dependencies.readStatus ?? readAgentAssetsStoreStatus;
-    const inspectBindings = dependencies.inspectBindings ?? inspectRuntimeGatewayBindings;
-    const verifyRelease = dependencies.verifyRelease ?? verifyAndLoadCommunityCoreReleaseInput;
-    const applyCore = dependencies.applyCore ?? applyVerifiedCommunityCore;
-    const repairBindings = dependencies.repairBindings ?? repairAgentAssetRuntimeBindings;
-    const inspectLegacyPointers = dependencies.inspectLegacyPointers ?? inspectLegacyAopsPointers;
-    const migrateLegacyPointers = dependencies.migrateLegacyPointers ?? migrateLegacyAopsPointers;
+    const getRoots = dependencies.roots ?? (() => resolveSimpleAgentAssetsRoots());
     const resolveRelease = dependencies.resolveRelease ?? resolveSetupAgentAssetsReleaseV1;
     const inspect = async () => {
-        const roots = resolveRoots({});
-        const store = readStatus({ assetRoot: roots.assetRoot, verify: 'quick' });
-        const bindings = inspectBindings({
-            assetRoot: roots.assetRoot,
-            runtimeHomes: {
-                codex: roots.runtimeHomes.codex.absolutePath,
-                claude: roots.runtimeHomes.claude.absolutePath,
-            },
-        });
-        const states = AGENT_ASSET_RUNTIME_IDS.map((runtime) => bindings[runtime].state);
-        const recoveryReasons = store.recoveryReasons ?? [];
-        const storeDrift = recoveryReasons.length > 0;
-        const ready = store.state === 'ready' && !storeDrift && states.every((state) => state === 'ready');
-        const conflict = states.some((state) => state === 'ownership-conflict' || state === 'unsafe-path');
+        const roots = getRoots();
+        const state = readSimpleAgentAssetsState(roots);
+        const ready = state.current !== null;
         return Object.freeze({
             availability: 'available',
-            state: ready ? 'ready' : conflict ? 'conflict' : 'action-required',
-            summary: ready
-                ? 'The verified AOPS core and all registered runtime gateways are ready.'
-                : conflict
-                    ? 'A global runtime gateway has an ownership or unsafe-path conflict.'
-                    : store.state === 'ready' && storeDrift
-                        ? 'The verified AOPS core remains usable, but authenticated staging or receipt drift requires inspection.'
-                        : store.state === 'ready'
-                            ? 'The verified AOPS core is ready, but one or more runtime bindings require repair.'
-                            : 'The verified global AOPS client core is not installed.',
-            nextActions: Object.freeze(ready
-                ? []
-                : conflict
-                    ? ['Inspect `aops assets status --verify full --json`; unknown user files are never overwritten.']
-                    : store.state === 'ready' && storeDrift
-                        ? ['Inspect `aops assets status --verify full --json` and reconcile only the reported managed recovery state.']
-                        : store.state === 'ready'
-                            ? ['Run `aops assets repair --repair-bindings --apply --json`.']
-                            : ['Run `aops assets install --target all --apply --json`.']),
+            state: ready ? 'ready' : 'action-required',
+            summary: ready ? `AOPS asset release ${state.current} is installed.` : 'AOPS global assets are not installed yet.',
+            nextActions: Object.freeze(ready ? [] : ['Run `aops assets install --target all --json`.']),
             data: Object.freeze({
-                store,
-                runtimeBindings: bindings,
-                recommendedAction: store.state === 'ready'
-                    ? storeDrift ? 'inspect-recovery' : 'repair'
-                    : 'install',
+                surface: SETUP_AGENT_ASSETS_CONTRACT.surface,
+                currentVersion: state.current,
+                previousVersion: state.previous,
+                storeRoot: roots.storeRoot,
+                recommendedAction: ready ? null : 'install',
             }),
         });
     };
     return Object.freeze({
         status: inspect,
-        async resolveRelease(options) {
-            return resolveRelease(options);
-        },
+        resolveRelease,
         async apply(options) {
-            const roots = resolveRoots({});
-            const target = resolveAgentAssetTargetSelection(options.target);
-            const runtimeHomes = selectAgentAssetRuntimeHomes(target, {
-                codex: roots.runtimeHomes.codex.absolutePath,
-                claude: roots.runtimeHomes.claude.absolutePath,
-            });
-            if (options.action === 'install' || options.action === 'update') {
-                if (!options.fromRelease)
-                    throw new Error('setup_init_agent_assets_release_required_for_install');
-                const release = await verifySetupAgentAssetsReleaseInput(verifyRelease, options.fromRelease);
-                const classifications = inspectLegacyPointers({ assetRoot: roots.assetRoot, runtimeHomes });
-                const conflicts = classifications.filter((item) => (item.state !== 'absent'
-                    && item.state !== 'managed-ready'
-                    && item.state !== 'recognized-legacy') || (item.state === 'recognized-legacy' && !item.eligible));
-                if (conflicts.length > 0) {
-                    throw new Error(`setup_init_agent_assets_runtime_conflict:${conflicts.map((item) => `${item.runtime}:${item.state}`).join(',')}`);
-                }
-                const legacyRuntimes = new Set(classifications
-                    .filter((item) => item.state === 'recognized-legacy')
-                    .map((item) => item.runtime));
-                const directRuntimeHomes = Object.freeze(Object.fromEntries(target.runtimes
-                    .filter((runtime) => !legacyRuntimes.has(runtime))
-                    .map((runtime) => [runtime, runtimeHomes[runtime]])));
-                await applyCore({
-                    assetRoot: roots.assetRoot,
-                    release,
-                    requestedOperation: options.action,
-                    runtimeHomes: directRuntimeHomes,
-                });
-                if (legacyRuntimes.size > 0) {
-                    await migrateLegacyPointers({
-                        assetRoot: roots.assetRoot,
-                        runtimeHomes: Object.freeze(Object.fromEntries(target.runtimes
-                            .filter((runtime) => legacyRuntimes.has(runtime))
-                            .map((runtime) => [runtime, runtimeHomes[runtime]]))),
-                    });
-                }
-            }
-            else {
-                await repairBindings({
-                    assetRoot: roots.assetRoot,
-                    runtimeHomes,
-                });
-            }
+            const roots = getRoots();
+            if (!options.fromRelease)
+                throw new Error('setup_init_agent_assets_release_required_for_install');
+            installSimpleAgentAssets({ releaseRoot: options.fromRelease, roots, target: 'all' });
             return inspect();
         },
     });
 }
-function normalizeProviderStatus(status) {
-    if (status.availability !== 'available') {
-        throw new Error('setup_agent_assets_provider_contract_invalid');
-    }
-    return Object.freeze({
-        ...status,
-        nextActions: Object.freeze([...status.nextActions]),
-        data: Object.freeze({
-            ...status.data,
-            surface: SETUP_AGENT_ASSETS_CONTRACT.surface,
-            gatewayDestinations: SETUP_AGENT_ASSETS_GATEWAYS,
-            legacyRepoMirrorInstallerUsed: false,
-        }),
-    });
-}
 export async function inspectSetupAgentAssets(provider) {
     if (!provider) {
         return Object.freeze({
             availability: 'task-136-pending',
             state: 'action-required',
-            summary: 'The canonical global AOPS agent-assets client is not available in this build yet.',
-            nextActions: Object.freeze([
-                'Complete TASK-136 on the TASK-137 merge base, then run `aops assets status --verify quick --json`.',
-            ]),
-            data: Object.freeze({
-                task: SETUP_AGENT_ASSETS_CONTRACT.task,
-                surface: SETUP_AGENT_ASSETS_CONTRACT.surface,
-                gatewayDestinations: SETUP_AGENT_ASSETS_GATEWAYS,
-                legacyRepoMirrorInstallerUsed: false,
-                transitionRemovalCondition: SETUP_AGENT_ASSETS_CONTRACT.transitionRemovalCondition,
-            }),
+            summary: 'The AOPS assets provider is unavailable.',
+            nextActions: Object.freeze(['Install the official AOPS CLI package.']),
         });
     }
-    return normalizeProviderStatus(await provider.status());
+    return provider.status();
 }
 export async function applySetupAgentAssets(provider, options) {
-    if (!provider?.apply) {
-        throw new Error('setup_init_agent_assets_contract_unavailable_task_136');
-    }
-    return normalizeProviderStatus(await provider.apply({
-        ...options,
-        target: 'all',
-    }));
+    if (!provider?.apply)
+        throw new Error('setup_init_agent_assets_provider_unavailable');
+    return provider.apply(options);
 }
-import { verifyAndLoadCommunityCoreReleaseInput } from './agent-assets/release-input.js';
-import { resolveAgentAssetsRoots } from './agent-assets/roots.js';
-import { inspectRuntimeGatewayBindings } from './agent-assets/runtime-binding-reader.js';
-import { readAgentAssetsStoreStatus } from './agent-assets/store-reader.js';
-import { applyVerifiedCommunityCore, repairAgentAssetRuntimeBindings, } from './agent-assets/store-writer.js';
-import { inspectLegacyAopsPointers, migrateLegacyAopsPointers, } from './agent-assets/legacy-pointer-migration.js';
-import { resolveSetupAgentAssetsReleaseV1 } from './setup-agent-assets-release.js';
-import { AGENT_ASSET_RUNTIME_IDS, resolveAgentAssetTargetSelection, selectAgentAssetRuntimeHomes, } from './agent-assets/runtime-targets.js';

package/dist/lib/setup-agent-assets-release.js

@@ -1,58 +1,30 @@
-import { lstatSync, realpathSync } from 'node:fs';
+import { lstatSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
-import { resolveSetupOfficialCatalogReleaseV1, } from './setup-official-catalog-bridge.js';
-import { AgentAssetsError } from './agent-assets/envelope.js';
-function localAgentAssetsReleaseRoot(candidate) {
-    if (!candidate)
-        return undefined;
-    const releaseRoot = path.resolve(candidate);
-    try {
-        const root = lstatSync(releaseRoot);
-        if (!root.isDirectory() || root.isSymbolicLink())
-            return undefined;
-        for (const name of ['agent-assets-release.json', 'agent-assets-release.sigstore.json']) {
-            const entry = lstatSync(path.join(releaseRoot, name));
-            if (!entry.isFile() || entry.isSymbolicLink())
-                return undefined;
-        }
-        const assets = lstatSync(path.join(releaseRoot, 'agent-assets'));
-        if (!assets.isDirectory() || assets.isSymbolicLink())
-            return undefined;
-        return realpathSync.native(releaseRoot);
-    }
-    catch {
-        return undefined;
-    }
-}
+import { loadSimpleAgentAssetsRelease } from './simple-agent-assets.js';
 function defaultBundledCandidates() {
     const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
     return Object.freeze([
-        path.resolve(moduleDirectory, '..', 'agent-assets-release'),
-        path.resolve(moduleDirectory, '..', '..', 'agent-assets-release'),
+        path.resolve(moduleDirectory, '..', '..', 'aops-assets-release'),
+        path.resolve(moduleDirectory, '..', 'aops-assets-release'),
     ]);
 }
 export function resolveBundledAgentAssetsReleaseV1(dependencies = {}) {
     for (const candidate of (dependencies.bundledCandidates ?? defaultBundledCandidates)()) {
-        const fromRelease = localAgentAssetsReleaseRoot(candidate);
-        if (fromRelease)
-            return Object.freeze({ fromRelease, source: 'bundled-npm' });
+        try {
+            if (!lstatSync(candidate).isDirectory())
+                continue;
+            loadSimpleAgentAssetsRelease(candidate);
+            return Object.freeze({ fromRelease: path.resolve(candidate), source: 'bundled-npm' });
+        }
+        catch {
+        }
     }
     return undefined;
 }
-export async function resolveSetupAgentAssetsReleaseV1(options = {}, dependencies = {}) {
+export async function resolveSetupAgentAssetsReleaseV1(_options = {}, dependencies = {}) {
     const bundled = resolveBundledAgentAssetsReleaseV1(dependencies);
-    if (bundled)
-        return bundled;
-    try {
-        return await (dependencies.fallback ?? resolveSetupOfficialCatalogReleaseV1)(options);
-    }
-    catch (cause) {
-        throw new AgentAssetsError('verified_source_unavailable', 'agent_assets_verified_source_unavailable:reinstall_the_official_aops_cli_package_or_use_--from-release_as_an_offline_override', {
-            nextActions: [
-                'Reinstall the official AOPS CLI package or retry with `--from-release` pointing to an exact signed release bundle.',
-            ],
-            cause,
-        });
-    }
+    if (!bundled)
+        throw new Error('aops_assets_bundled_release_missing');
+    return bundled;
 }

package/dist/lib/setup-init-orchestrator.js

@@ -82,7 +82,6 @@ function createSetupInstallerPlan(options, selectedPath, security, readiness, ef
             targetAuthProvider: options.targetAuthProvider ?? null,
             targetTlsPolicy: options.targetTlsPolicy ?? null,
             agentAssets: normalizeAgentAssetsAction(options.agentAssets) ?? null,
-            agentAssetsRelease: options.agentAssetsRelease ? path.resolve(options.agentAssetsRelease) : null,
             noCatalog: options.noCatalog === true,
             catalogRelease: options.catalogRelease ? path.resolve(options.catalogRelease) : null,
             catalogIdempotencyKey: normalizeNonEmpty(options.catalogIdempotencyKey) ?? null,
@@ -177,10 +176,10 @@ function normalizeAgentAssetsAction(value) {
     const normalized = normalizeNonEmpty(value)?.toLowerCase();
     if (!normalized)
         return undefined;
-    if (normalized === 'status' || normalized === 'install' || normalized === 'repair' || normalized === 'skip') {
+    if (normalized === 'status' || normalized === 'install' || normalized === 'skip') {
         return normalized;
     }
-    throw new Error('setup_init_agent_assets_action_invalid:choose_status_install_repair_or_skip');
+    throw new Error('setup_init_agent_assets_action_invalid:choose_status_install_or_skip');
 }
 function resolveAgentAssetsReleasePath(value) {
     const normalized = normalizeNonEmpty(value);
@@ -361,7 +360,7 @@ export async function runSetupInitOrchestrator(options = {}, dependencies = {})
         }
         await dependencies.assertInstallerReleaseCurrent(dependencies.installerRelease);
     }
-    if ((requestedAgentAssetsAction === 'install' || requestedAgentAssetsAction === 'repair') &&
+    if (requestedAgentAssetsAction === 'install' &&
         !dependencies.agentAssets?.apply) {
         throw new Error('setup_init_agent_assets_contract_unavailable_task_136');
     }
@@ -375,10 +374,10 @@ export async function runSetupInitOrchestrator(options = {}, dependencies = {})
     let officialCatalogRelease;
     let officialCatalogReleaseSource;
     if (localServerPath && !options.noCatalog && dependencies.officialCatalog) {
-        const selectedRelease = options.catalogRelease ?? options.agentAssetsRelease;
+        const selectedRelease = options.catalogRelease;
         if (normalizeNonEmpty(selectedRelease)) {
             officialCatalogRelease = resolveOfficialCatalogReleasePath(selectedRelease);
-            officialCatalogReleaseSource = options.catalogRelease ? 'explicit-catalog-release' : 'explicit-agent-assets-release';
+            officialCatalogReleaseSource = 'explicit-catalog-release';
         }
         else {
             const resolution = await dependencies.officialCatalog.resolveRelease({
@@ -734,15 +733,14 @@ export async function runSetupInitOrchestrator(options = {}, dependencies = {})
         agentAssetsAction = 'skip';
     }
     else if (!agentAssetsAction && dependencies.agentAssets?.apply) {
-        const recommendedAction = agentAssetsCheck?.data?.recommendedAction === 'repair' ? 'repair' : 'install';
-        agentAssetsAction = recommendedAction;
+        agentAssetsAction = 'install';
     }
-    if (agentAssetsAction === 'install' || agentAssetsAction === 'repair') {
+    if (agentAssetsAction === 'install') {
         if (!dependencies.agentAssets?.apply) {
             throw new Error('setup_init_agent_assets_contract_unavailable_task_136');
         }
-        let fromRelease = options.agentAssetsRelease ?? officialCatalogRelease;
-        if (agentAssetsAction === 'install' && !normalizeNonEmpty(fromRelease) && dependencies.agentAssets.resolveRelease) {
+        let fromRelease;
+        if (agentAssetsAction === 'install' && dependencies.agentAssets.resolveRelease) {
             const resolution = await dependencies.agentAssets.resolveRelease({
                 sourceRoot: options.sourceRoot,
                 instance: options.instance,
@@ -750,11 +748,9 @@ export async function runSetupInitOrchestrator(options = {}, dependencies = {})
             });
             fromRelease = resolution.fromRelease;
         }
-        const appliedAssets = await progress('Installing global AOPS agent gateways...', () => applySetupAgentAssets(dependencies.agentAssets, {
+        const appliedAssets = await progress('Installing global AOPS skills...', () => applySetupAgentAssets(dependencies.agentAssets, {
             action: agentAssetsAction,
-            fromRelease: agentAssetsAction === 'install'
-                ? resolveAgentAssetsReleasePath(fromRelease)
-                : undefined,
+            fromRelease: resolveAgentAssetsReleasePath(fromRelease),
         }));
         steps.push({ action: `assets.${agentAssetsAction}`, status: appliedAssets.state, target: 'all' });
         result = await inspect();