@aiwg/cli 2026.7.19 → 2026.7.21

package/dist/src/artifacts/index-builder.js

@@ -20,6 +20,7 @@ import { loadManifest, writeManifest, statMatches, makeEntry } from './checksum-
 import { workspaceLinkedFiles } from '../smiths/context-pipeline/workspace-context.js';
 import { normalizeOperationalState } from './operational-state.js';
 import { DEFAULT_PROJECT_AIWG_DIR, resolveProjectAiwgDir, } from '../config/project-artifacts.js';
+import { normalizeStateTransferProjection } from './state-transfer.js';
 function pathContains(parent, child) {
     const relative = path.relative(parent, child);
     return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
@@ -322,10 +323,10 @@ export function parseRunbookDoc(data, body, filePath) {
 /**
  * Extract trigger phrases from a SKILL.md / agent body.
  *
- * Skills declare alternate activation phrases under a `## Triggers`
- * heading; the body typically lists them as bullet points. This
- * function pulls each bullet's leading phrase (the part before any
- * `→` arrow or em-dash explanation), lowercased and trimmed.
+ * Skills declare alternate activation phrases in `triggers`, `aliases`,
+ * `deprecated_names`, or under a `## Triggers` heading. This function pulls
+ * those names plus each bullet's leading phrase (the part before any `→`
+ * arrow or em-dash explanation), lowercased and trimmed.
  *
  * Returns an empty array when no `## Triggers` section is found —
  * non-skill artifacts get `triggers: undefined` after this is wired.
@@ -334,18 +335,20 @@ export function parseRunbookDoc(data, body, filePath) {
  */
 export function extractTriggers(body, frontmatter) {
     const phrases = [];
-    const declaredTriggers = Array.isArray(frontmatter?.triggers)
-        ? frontmatter.triggers
-        : [];
-    for (const trigger of declaredTriggers) {
-        if (typeof trigger !== 'string')
-            continue;
-        const phrase = trigger.trim().toLowerCase();
-        if (phrase.length === 0)
-            continue;
-        if (phrase.length > 200)
-            continue;
-        phrases.push(phrase);
+    for (const field of ['triggers', 'aliases', 'deprecated_names']) {
+        const declaredValues = Array.isArray(frontmatter?.[field])
+            ? frontmatter[field]
+            : [];
+        for (const value of declaredValues) {
+            if (typeof value !== 'string')
+                continue;
+            const phrase = value.trim().toLowerCase();
+            if (phrase.length === 0)
+                continue;
+            if (phrase.length > 200)
+                continue;
+            phrases.push(phrase);
+        }
     }
     // Find a triggers heading (case-insensitive). Accepted variants:
     //   ## Triggers
@@ -882,6 +885,7 @@ export async function buildIndex(cwd, options = {}) {
             // Script entrypoint metadata is meaningful for skills only (#1227).
             const script = type === 'skill' ? extractSkillScript(data) : undefined;
             const operationalState = normalizeOperationalState(data.operational_state);
+            const stateTransfer = normalizeStateTransferProjection(data.state_transfer);
             // Canonical short name (#1233) — used by the scorer to floor exact-name
             // queries to 1.0 so hyphenated kernel-skill names like `aiwg-doctor`
             // remain searchable even when the rendered title strips the hyphen.
@@ -907,6 +911,7 @@ export async function buildIndex(cwd, options = {}) {
                 ...(kernel ? { kernel } : {}),
                 ...(script ? { script } : {}),
                 ...(operationalState ? { operationalState } : {}),
+                ...(stateTransfer ? { stateTransfer } : {}),
             };
         }
         entries[relativePath] = entry;
@@ -957,6 +962,7 @@ export async function buildIndex(cwd, options = {}) {
         }
     }
     // Run citation sidecar edge extraction if configured
+    let citationMetrics = null;
     if (graphConfig?.edgeExtraction?.parser === 'citation-sidecar') {
         // Build REF-XXX → path map from all entries with ref frontmatter
         const entryFrontmatter = new Map();
@@ -971,6 +977,10 @@ export async function buildIndex(cwd, options = {}) {
         const refToPath = buildRefToPathMap(entryFrontmatter);
         // Parse each entry as a citation sidecar and extract edges
         let citationEdgeCount = 0;
+        let outgoingDeclarations = 0;
+        let incomingDeclarations = 0;
+        const canonicalOutgoing = new Set();
+        const declaredIncoming = new Set();
         for (const entryPath of Object.keys(entries)) {
             const fullPath = absoluteEntryPath(cwd, entryPath, graph);
             if (!fs.existsSync(fullPath))
@@ -979,6 +989,14 @@ export async function buildIndex(cwd, options = {}) {
             const result = parseCitationSidecar(content);
             if (!result)
                 continue;
+            outgoingDeclarations += result.cites.length;
+            incomingDeclarations += result.citedBy.length;
+            for (const targetRef of result.cites) {
+                canonicalOutgoing.add(`${result.ref}\0${targetRef}`);
+            }
+            for (const sourceRef of result.citedBy) {
+                declaredIncoming.add(`${sourceRef}\0${result.ref}`);
+            }
             const edges = citationResultToEdges(result, refToPath);
             if (!depGraph[entryPath]) {
                 depGraph[entryPath] = { upstream: [], downstream: [] };
@@ -1004,6 +1022,15 @@ export async function buildIndex(cwd, options = {}) {
                 citationEdgeCount++;
             }
         }
+        citationMetrics = {
+            canonicalEdges: canonicalOutgoing.size,
+            outgoingDeclarations,
+            incomingDeclarations,
+            unmirroredOutgoing: [...canonicalOutgoing]
+                .filter(edge => !declaredIncoming.has(edge)).length,
+            unmirroredIncoming: [...declaredIncoming]
+                .filter(edge => !canonicalOutgoing.has(edge)).length,
+        };
         if (verbose && citationEdgeCount > 0) {
             console.log(`  citation edges: ${citationEdgeCount}`);
         }
@@ -1038,7 +1065,9 @@ export async function buildIndex(cwd, options = {}) {
         manifestStats.pruned = 0;
     writeManifest(indexOutputDir, nextManifest);
     // Write stats
-    const totalEdges = Object.values(depGraph).reduce((sum, node) => sum + node.downstream.length, 0);
+    const downstreamEdges = Object.values(depGraph).reduce((sum, node) => sum + node.downstream.length, 0);
+    const adjacencyEntries = Object.values(depGraph).reduce((sum, node) => sum + node.upstream.length + node.downstream.length, 0);
+    const totalEdges = citationMetrics?.canonicalEdges ?? downstreamEdges;
     const orphaned = Object.entries(depGraph).filter(([, node]) => node.upstream.length === 0 && node.downstream.length === 0).length;
     const mostReferenced = Object.entries(depGraph)
         .map(([p, node]) => ({ path: p, count: node.downstream.length }))
@@ -1064,6 +1093,14 @@ export async function buildIndex(cwd, options = {}) {
         tagDistribution: tagDist,
         graphMetrics: {
             totalEdges,
+            ...(citationMetrics ? {
+                canonicalEdges: citationMetrics.canonicalEdges,
+                outgoingDeclarations: citationMetrics.outgoingDeclarations,
+                incomingDeclarations: citationMetrics.incomingDeclarations,
+                adjacencyEntries,
+                unmirroredOutgoing: citationMetrics.unmirroredOutgoing,
+                unmirroredIncoming: citationMetrics.unmirroredIncoming,
+            } : {}),
             orphanedArtifacts: orphaned,
             mostReferenced,
         },

package/dist/src/artifacts/query-engine.js

@@ -1740,14 +1740,18 @@ export async function showArtifact(cwd, params) {
         try {
             if (!webRelease)
                 throw new Error('verified web release context is unavailable');
-            const { fetchVerifiedRawResource } = await import('../resources/web-release.js');
-            const bytes = await fetchVerifiedRawResource(webRelease, filePath, {
-                baseUrl: params.webReleaseOptions?.baseUrl,
-                fetcher: params.webReleaseOptions?.fetcher,
-                allowInsecureLoopbackHttp: params.webReleaseOptions?.allowInsecureLoopbackHttp,
+            const { logicalIdFromFirstPartyPath, resolveAiwgResourceBytes } = await import('../resources/resolver.js');
+            const logicalId = logicalIdFromFirstPartyPath(entry.path);
+            if (!logicalId)
+                throw new Error(`indexed path is not a first-party AIWG resource: ${entry.path}`);
+            const resolved = await resolveAiwgResourceBytes(logicalId, {
+                source: 'web',
+                frameworkRoot: aiwgRoot ?? cwd,
+                webRelease,
+                webReleaseOptions: params.webReleaseOptions,
                 offline: params.offline,
             });
-            content = bytes.toString('utf8');
+            content = resolved.bytes.toString('utf8');
         }
         catch (error) {
             console.error(`Error: AIWG web resource show failed: ${error instanceof Error ? error.message : String(error)}`);

package/dist/src/artifacts/state-transfer.js

@@ -0,0 +1,27 @@
+export function normalizeStateTransferProjection(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("state_transfer must be an object");
+    }
+    const record = value;
+    const unknown = Object.keys(record).filter((key) => key !== "deleted_at");
+    if (unknown.length > 0) {
+        throw new Error(`state_transfer has unsupported fields: ${unknown.join(", ")}`);
+    }
+    if (!Object.hasOwn(record, "deleted_at")) {
+        throw new Error("state_transfer.deleted_at is required");
+    }
+    const deletedAt = record.deleted_at;
+    if (deletedAt === null)
+        return { deletedAt: null };
+    if (deletedAt instanceof Date && !Number.isNaN(deletedAt.getTime())) {
+        return { deletedAt: deletedAt.toISOString() };
+    }
+    if (typeof deletedAt !== "string"
+        || Number.isNaN(Date.parse(deletedAt))) {
+        throw new Error("state_transfer.deleted_at must be null or an ISO date-time");
+    }
+    return { deletedAt: new Date(deletedAt).toISOString() };
+}
+//# sourceMappingURL=state-transfer.js.map

package/dist/src/artifacts/stats.js

@@ -153,6 +153,14 @@ async function renderStats(cwd, stats, options, graphType) {
     // Dependency graph
     console.log('Dependency Graph:');
     console.log(`  Total edges:        ${stats.graphMetrics.totalEdges}`);
+    if (stats.graphMetrics.canonicalEdges !== undefined) {
+        console.log(`  Canonical edges:    ${stats.graphMetrics.canonicalEdges}`);
+        console.log(`  Outgoing declares:  ${stats.graphMetrics.outgoingDeclarations}`);
+        console.log(`  Incoming declares:  ${stats.graphMetrics.incomingDeclarations}`);
+        console.log(`  Adjacency entries:  ${stats.graphMetrics.adjacencyEntries}`);
+        console.log(`  Unmirrored outgoing:${String(stats.graphMetrics.unmirroredOutgoing).padStart(3)}`);
+        console.log(`  Unmirrored incoming:${String(stats.graphMetrics.unmirroredIncoming).padStart(3)}`);
+    }
     console.log(`  Orphaned artifacts: ${stats.graphMetrics.orphanedArtifacts}`);
     if (stats.graphMetrics.mostReferenced) {
         console.log(`  Most referenced:    ${stats.graphMetrics.mostReferenced.path} (${stats.graphMetrics.mostReferenced.count} dependents)`);

package/dist/src/cli/cli-extension-loader.js

@@ -41,10 +41,83 @@ export async function writeRegistry(cwd, registry) {
  * Called by `aiwg use <addon>` after reading the addon manifest.
  */
 export async function registerCliCommands(cwd, namespace, description, source, subcommands) {
+    if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(namespace)) {
+        throw new Error(`Invalid CLI namespace: ${namespace}`);
+    }
+    if (!source || !path.isAbsolute(source)) {
+        throw new Error('CLI extension source must be an absolute path.');
+    }
+    if (Object.keys(subcommands).length === 0) {
+        throw new Error(`CLI namespace '${namespace}' declares no subcommands.`);
+    }
+    for (const [name, subcommand] of Object.entries(subcommands)) {
+        if (!/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(name)) {
+            throw new Error(`Invalid CLI subcommand: ${namespace} ${name}`);
+        }
+        if (!subcommand
+            || typeof subcommand.file !== 'string'
+            || !/^[a-zA-Z0-9_-]+\.mjs$/.test(subcommand.file)) {
+            throw new Error(`CLI subcommand '${namespace} ${name}' must name a local .mjs file.`);
+        }
+        if (typeof subcommand.description !== 'string' || !subcommand.description.trim()) {
+            throw new Error(`CLI subcommand '${namespace} ${name}' requires a description.`);
+        }
+    }
     const existing = await readRegistry(cwd) ?? {};
     existing[namespace] = { source, description, subcommands };
     await writeRegistry(cwd, existing);
 }
+/**
+ * Read and validate an addon-shaped manifest's expandable CLI declaration.
+ *
+ * `sourceRoot` may be a bundled addon, a project-local addon, or the validated
+ * payload of a project-local plugin wrapper. Module files are constrained to
+ * the declared commands directory; registration never follows `..` paths.
+ */
+export async function loadCliCommandsContribution(sourceRoot) {
+    const manifestPath = path.join(sourceRoot, 'manifest.json');
+    let raw;
+    try {
+        raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw new Error(`Unable to read CLI extension manifest at ${manifestPath}: ${error.message}`);
+    }
+    const candidate = raw.cli_commands;
+    if (candidate === undefined)
+        return null;
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        throw new Error(`Invalid cli_commands block in ${manifestPath}`);
+    }
+    const commands = candidate;
+    if (typeof commands.namespace !== 'string'
+        || typeof commands.description !== 'string'
+        || !commands.subcommands
+        || typeof commands.subcommands !== 'object'
+        || Array.isArray(commands.subcommands)) {
+        throw new Error(`Incomplete cli_commands block in ${manifestPath}`);
+    }
+    const entry = commands.entry ?? 'commands/';
+    if (typeof entry !== 'string'
+        || path.isAbsolute(entry)
+        || entry.split(/[\\/]+/).includes('..')) {
+        throw new Error(`Unsafe cli_commands.entry in ${manifestPath}`);
+    }
+    const commandsSource = path.resolve(sourceRoot, entry);
+    const relative = path.relative(path.resolve(sourceRoot), commandsSource);
+    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(`cli_commands.entry escapes its addon root in ${manifestPath}`);
+    }
+    const manifest = {
+        namespace: commands.namespace,
+        description: commands.description,
+        entry,
+        subcommands: commands.subcommands,
+    };
+    return { manifest, commandsSource };
+}
 /**
  * Try to execute an addon-contributed CLI command
  *

package/dist/src/cli/handlers/help.js

@@ -80,6 +80,7 @@ function displayHelp() {
     helpGroup('DISCOVERY', [
         ['discover "<phrase>"', 'Find skills/agents/commands/rules by capability'],
         ['show <type> <name>', 'Stream the body of an indexed artifact'],
+        ['versions <list|resolve|show>', 'Browse and resolve signed AIWG web resource releases'],
         ['index <subcommand>', 'Manage the artifact index (build/query/discover/deps/stats)'],
         ['artifacts move --to <path>', 'Move/rename the project AIWG artifact root and reindex'],
     ]);
@@ -120,7 +121,7 @@ function displayHelp() {
         ['doctor', 'Check installation health'],
         ['version', 'Show version and channel info'],
         ['refresh', 'Update AIWG and redeploy frameworks (formerly: sync)'],
-        ['update', 'Check for updates'],
+        ['update', 'Update the active installation and re-deploy installed frameworks (alias: upgrade)'],
         ['help', 'Show this help message'],
     ]);
     helpGroup('CHANNEL', [

package/dist/src/cli/handlers/index.js

@@ -44,6 +44,7 @@ import { serveHandler } from './serve.js';
 import { lintHandler } from './lint.js';
 import { feedbackHandler } from './feedback.js';
 import { sessionHandler } from './session.js';
+import { sessionsHandler } from './sessions.js';
 import { sandboxHandler, sandboxHandlers } from './sandbox.js';
 import { diagnoseHandler } from './diagnose.js';
 import { localExecutorHandler, localExecutorServeHandler } from './local-executor.js';
@@ -54,6 +55,7 @@ import { cockpitHandler } from './cockpit.js';
 import { commandLogHandler } from './command-log.js';
 import { skillUsageHandler } from './skill-usage.js';
 import { modelsHandler } from './models.js';
+import { versionsHandler } from './resource-versions.js';
 // Re-export individual handlers
 export { 
 // Maintenance
@@ -61,11 +63,11 @@ helpHandler, versionHandler, doctorHandler, updateHandler, refreshHandler, regen
 // Framework management
 useHandler, listHandler, removeHandler, promoteHandler, installHandler, packagesHandler, marketplaceHandler, initHandler, setupHandler, issueHandler, issueAuditHandler, runHandler, 
 // Project
-newBundleHandler, quickrefHandler, newProjectHandler, 
+newBundleHandler, quickrefHandler, newProjectHandler, sessionHandler, sessionsHandler, 
 // Workspace
 statusHandler, wizardHandler, migrateWorkspaceHandler, rollbackWorkspaceHandler, 
 // Subcommands
-mcpHandler, catalogHandler, modelsHandler, indexHandler, artifactsHandler, corpusHandler, discoverHandler, showHandler, featuresHandler, skillsHandler, configHandler, opsHandler, storageHandler, activityLogHandler, commandLogHandler, skillUsageHandler, kbHandler, memoryHandler, reflectionsHandler, provenanceHandler, researchStoreHandler, researchQueryHandler, runtimeInfoHandler, agentcardHandler, 
+mcpHandler, catalogHandler, modelsHandler, versionsHandler, indexHandler, artifactsHandler, corpusHandler, discoverHandler, showHandler, featuresHandler, skillsHandler, configHandler, opsHandler, storageHandler, activityLogHandler, commandLogHandler, skillUsageHandler, kbHandler, memoryHandler, reflectionsHandler, provenanceHandler, researchStoreHandler, researchQueryHandler, runtimeInfoHandler, agentcardHandler, 
 // Agentic Tools (RLM)
 chunkHandler, fanoutHandler, rlmPrepHandler, rlmSearchHandler, rlmStatusCliHandler, rlmCacheHandler, 
 // Utilities
@@ -139,6 +141,7 @@ export const allHandlers = [
     mcpHandler,
     catalogHandler,
     modelsHandler,
+    versionsHandler,
     indexHandler,
     artifactsHandler,
     corpusHandler,
@@ -222,6 +225,7 @@ export const allHandlers = [
     feedbackHandler,
     // Session (#884)
     sessionHandler,
+    sessionsHandler,
     // Repo access policy (#1376)
     ...repoAccessHandlers,
 ];

package/dist/src/cli/handlers/resource-versions.js

@@ -0,0 +1,247 @@
+import path from "node:path";
+import { loadResourceTrustRootFile, readVerifiedRegularFile, resolveWebRelease, } from "../../resources/web-release.js";
+import { getProjectDir } from "../../config/aiwg-config.js";
+import { cleanWebResourceCache } from "../../resources/cache-cleanup.js";
+import { writeWebResourceLock } from "../../resources/lockfile.js";
+const MAX_RESOURCE_MANIFEST_BYTES = 4 * 1024 * 1024;
+const DEFAULT_CHANNELS = ["stable", "latest", "canary", "main"];
+function usage() {
+    return [
+        "Usage: aiwg versions <list|resolve|show|clean-cache> [selector] [--json] [--pretty] [--offline]",
+        "",
+        "Examples:",
+        "  aiwg versions list --json",
+        "  aiwg versions resolve stable --json",
+        "  aiwg versions resolve stable --write-lock",
+        "  aiwg versions show 2026.7.18",
+        "  aiwg versions clean-cache --dry-run",
+    ].join("\n");
+}
+function flagValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    const value = args[index + 1];
+    if (!value || value.startsWith("--"))
+        throw new Error(`${flag} requires a value`);
+    return value;
+}
+function parseArgs(args) {
+    const [rawSubcommand = "list", ...rest] = args;
+    if (rawSubcommand !== "list" &&
+        rawSubcommand !== "resolve" &&
+        rawSubcommand !== "show" &&
+        rawSubcommand !== "clean-cache") {
+        throw new Error(`Unknown versions subcommand: ${rawSubcommand}\n\n${usage()}`);
+    }
+    const valueFlagIndexes = new Set();
+    for (const flag of ["--channels", "--target", "--prefix"]) {
+        const index = rest.indexOf(flag);
+        if (index !== -1) {
+            valueFlagIndexes.add(index);
+            valueFlagIndexes.add(index + 1);
+        }
+    }
+    const positionals = rest.filter((arg, index) => !arg.startsWith("--") && !valueFlagIndexes.has(index));
+    if ((rawSubcommand === "resolve" || rawSubcommand === "show") && positionals.length !== 1) {
+        throw new Error(`aiwg versions ${rawSubcommand} requires exactly one version, range, digest, or channel selector\n\n${usage()}`);
+    }
+    if (rawSubcommand === "list" && positionals.length > 0) {
+        throw new Error(`aiwg versions list does not accept positional selectors\n\n${usage()}`);
+    }
+    if (rawSubcommand === "clean-cache" && positionals.length > 0) {
+        throw new Error(`aiwg versions clean-cache does not accept positional selectors\n\n${usage()}`);
+    }
+    const writeLock = rest.includes("--write-lock");
+    if ((rawSubcommand === "list" || rawSubcommand === "clean-cache") && writeLock) {
+        throw new Error(`aiwg versions ${rawSubcommand} cannot write resources.lock.json; use resolve or show with --write-lock`);
+    }
+    const channelsValue = flagValue(rest, "--channels");
+    const channels = channelsValue
+        ? channelsValue.split(",").map((channel) => channel.trim()).filter(Boolean)
+        : [...DEFAULT_CHANNELS];
+    if (channels.length === 0)
+        throw new Error("--channels must include at least one channel");
+    return {
+        subcommand: rawSubcommand,
+        selector: positionals[0],
+        json: rest.includes("--json") || rest.includes("--format=json"),
+        pretty: rest.includes("--pretty"),
+        offline: rest.includes("--offline"),
+        writeLock,
+        dryRun: rest.includes("--dry-run"),
+        force: rest.includes("--force"),
+        channels,
+    };
+}
+function webReleaseOptionsFromEnvironment() {
+    const baseUrl = process.env.AIWG_RESOURCE_BASE_URL;
+    const cacheRoot = process.env.AIWG_RESOURCE_CACHE_ROOT;
+    const trustRootFile = process.env.AIWG_RESOURCE_TRUST_ROOT_FILE;
+    const publicKeyPem = trustRootFile === undefined
+        ? undefined
+        : loadResourceTrustRootFile(path.resolve(trustRootFile));
+    return {
+        ...(baseUrl === undefined ? {} : { baseUrl }),
+        ...(cacheRoot === undefined ? {} : { cacheRoot }),
+        ...(publicKeyPem === undefined ? {} : { publicKeyPem }),
+        ...(process.env.AIWG_RESOURCE_ALLOW_INSECURE_LOOPBACK_HTTP === "1"
+            ? { allowInsecureLoopbackHttp: true }
+            : {}),
+    };
+}
+function readManifestSummary(release) {
+    const bytes = readVerifiedRegularFile(release.releaseManifestPath, {
+        label: "verified AIWG resource release manifest",
+        maxBytes: MAX_RESOURCE_MANIFEST_BYTES,
+        expectedSha256: release.manifestDigest,
+    });
+    const value = JSON.parse(bytes.toString("utf8"));
+    const bundles = Array.isArray(value.bundles) ? value.bundles : [];
+    const files = Array.isArray(value.files) ? value.files : [];
+    return {
+        schemaVersion: value.schemaVersion,
+        version: value.version,
+        compatibility: value.compatibility,
+        source: value.source,
+        bundles,
+        fileCount: files.length,
+    };
+}
+function releaseJson(release, manifest, lockfilePath) {
+    return {
+        selector: release.selector,
+        selectorKind: release.selectorKind,
+        version: release.version,
+        manifestSha256: release.manifestDigest,
+        manifestUrl: release.manifestUrl,
+        baseUrl: release.baseUrl,
+        cacheDir: release.cacheDir,
+        channelSequence: release.channelSequence,
+        fortemiCore: {
+            manifestSha256: release.fortemiManifestSha256,
+            manifestSize: release.fortemiManifestSize,
+            exportSha256: release.fortemiExportSha256,
+            exportSize: release.fortemiExportSize,
+        },
+        descriptorCount: release.descriptors.size,
+        ...(lockfilePath === undefined ? {} : { lockfile: lockfilePath }),
+        ...(manifest === undefined ? {} : { manifest }),
+    };
+}
+function printJson(value, pretty) {
+    console.log(JSON.stringify(value, null, pretty ? 2 : 0));
+}
+function printReleaseText(release, manifest, lockfilePath) {
+    console.log(`selector: ${release.selector} (${release.selectorKind})`);
+    console.log(`version: ${release.version}`);
+    if (release.channelSequence !== undefined)
+        console.log(`channel_sequence: ${release.channelSequence}`);
+    console.log(`manifest_sha256: ${release.manifestDigest}`);
+    console.log(`manifest_url: ${release.manifestUrl}`);
+    console.log(`cache_dir: ${release.cacheDir}`);
+    console.log(`fortemi_manifest_sha256: ${release.fortemiManifestSha256}`);
+    console.log(`fortemi_export_sha256: ${release.fortemiExportSha256}`);
+    console.log(`descriptor_count: ${release.descriptors.size}`);
+    if (lockfilePath !== undefined)
+        console.log(`lockfile: ${lockfilePath}`);
+    if (manifest) {
+        console.log(`schema_version: ${String(manifest.schemaVersion)}`);
+        console.log(`file_count: ${manifest.fileCount}`);
+        console.log(`bundle_count: ${manifest.bundles.length}`);
+    }
+}
+export const versionsHandler = {
+    id: "versions",
+    name: "Resource Versions",
+    description: "Browse and resolve signed AIWG web resource releases",
+    category: "index",
+    aliases: [],
+    async execute(ctx) {
+        if (ctx.args[0] === "help" || ctx.args[0] === "--help" || ctx.args[0] === "-h") {
+            console.log(usage());
+            return { exitCode: 0 };
+        }
+        let parsed;
+        try {
+            parsed = parseArgs(ctx.args);
+        }
+        catch (error) {
+            return { exitCode: 2, message: error instanceof Error ? error.message : String(error) };
+        }
+        try {
+            const baseOptions = webReleaseOptionsFromEnvironment();
+            if (parsed.subcommand === "clean-cache") {
+                const result = cleanWebResourceCache(getProjectDir(ctx, ctx.args), {
+                    cacheRoot: process.env.AIWG_RESOURCE_CACHE_ROOT,
+                    dryRun: parsed.dryRun,
+                    force: parsed.force,
+                });
+                if (parsed.json) {
+                    printJson(result, parsed.pretty);
+                }
+                else {
+                    console.log(`cache_root: ${result.cacheRoot}`);
+                    console.log(`dry_run: ${result.dryRun}`);
+                    console.log(`force: ${result.force}`);
+                    console.log(`locked: ${result.locked.length}`);
+                    console.log(`preserved: ${result.preserved.length}`);
+                    console.log(`removed: ${result.removed.length}`);
+                    console.log(`skipped: ${result.skipped.length}`);
+                }
+                return { exitCode: 0 };
+            }
+            if (parsed.subcommand === "list") {
+                const resolved = [];
+                const unavailable = [];
+                for (const channel of parsed.channels) {
+                    try {
+                        const release = await resolveWebRelease({
+                            ...baseOptions,
+                            selector: channel,
+                            offline: parsed.offline,
+                        });
+                        resolved.push(releaseJson(release));
+                    }
+                    catch (error) {
+                        unavailable.push({
+                            channel,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
+                if (parsed.json) {
+                    printJson({ channels: resolved, unavailable }, parsed.pretty);
+                }
+                else {
+                    for (const release of resolved) {
+                        console.log(`${release.selector}: ${release.version} ${release.manifestSha256}`);
+                    }
+                    if (resolved.length === 0)
+                        console.log("No configured channels resolved.");
+                }
+                return { exitCode: 0 };
+            }
+            const release = await resolveWebRelease({
+                ...baseOptions,
+                selector: parsed.selector,
+                offline: parsed.offline,
+            });
+            const manifest = parsed.subcommand === "show" ? readManifestSummary(release) : undefined;
+            const lockfilePath = parsed.writeLock
+                ? writeWebResourceLock(getProjectDir(ctx, ctx.args), release).path
+                : undefined;
+            if (parsed.json) {
+                printJson(releaseJson(release, manifest, lockfilePath), parsed.pretty);
+            }
+            else {
+                printReleaseText(release, manifest, lockfilePath);
+            }
+            return { exitCode: 0 };
+        }
+        catch (error) {
+            return { exitCode: 1, message: error instanceof Error ? error.message : String(error) };
+        }
+    },
+};
+//# sourceMappingURL=resource-versions.js.map