@aiwg/cli 2026.9.24 → 2026.10.1

package/dist/src/decision/sensitivity/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/decision/validate.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
 import { canonicalJson } from '../security/artifact-trust.js';
 import { admitEntry, EntryAdmissionError } from './entry.js';
 import { DECISION_API_VERSION, DECISION_API_VERSION_STRUCTURED } from './types.js';
@@ -29,6 +30,8 @@ export class DecisionValidationError extends Error {
     }
 }
 let validators = null;
+let decisionAjv = null;
+let preprocessedEvidenceValidator = null;
 function schemaRoot() {
     const here = dirname(fileURLToPath(import.meta.url));
     const candidates = [resolve(here, '../../schemas/decision'), resolve(here, '../../../schemas/decision')];
@@ -47,6 +50,7 @@ function getValidators() {
     ajv.addSchema(admissionSchema);
     ajv.addSchema(contextEvidenceSchema);
     ajv.addSchema(providerPrefixSchema);
+    decisionAjv = ajv;
     validators = new Map();
     for (const [kind, filename] of Object.entries(schemaFiles)) {
         const schema = JSON.parse(readFileSync(resolve(schemaRoot(), filename), 'utf8'));
@@ -58,6 +62,26 @@ function getValidators() {
     }
     return validators;
 }
+/**
+ * D24: closed-schema errors for a PreprocessedEvidence manifest, with formats enforced, or
+ * null when valid. The runtime resolver runs this so it can never accept what the schema rejects.
+ */
+export function preprocessedEvidenceSchemaErrors(value) {
+    if (!preprocessedEvidenceValidator) {
+        const ajv = new Ajv2020({ strict: true, allErrors: true });
+        addFormats(ajv);
+        preprocessedEvidenceValidator = ajv.compile(JSON.parse(readFileSync(resolve(schemaRoot(), 'PreprocessedEvidence.v1.schema.json'), 'utf8')));
+    }
+    return preprocessedEvidenceValidator(value) ? null : ajvMessage(preprocessedEvidenceValidator.errors);
+}
+/** D24: RulesetResult v1alpha2 `preprocessingLineage` shape errors, or null when valid. */
+export function preprocessingLineageSchemaErrors(value) {
+    getValidators();
+    const validate = decisionAjv.getSchema('https://aiwg.io/schemas/decision/RulesetResult.v1alpha2.schema.json#/$defs/preprocessingLineage');
+    if (!validate)
+        throw new DecisionValidationError('preprocessing lineage schema is unavailable');
+    return validate(value) ? null : ajvMessage(validate.errors);
+}
 export function artifactDigest(value) {
     const started = performance.now();
     admitEntry(value);
@@ -116,6 +140,7 @@ export function assertDecisionWriterVersion(value, semantic) {
  */
 export const DECISION_RESULT_V1ALPHA2_FIELDS = [
     { field: 'batchResult', scope: 'decision', owner: 'D07', semantic: 'batch-receipt' },
+    { field: 'batchRequests', scope: 'ruleset', owner: 'D04', semantic: 'batch-request-usage' },
     { field: 'batch', scope: 'attempt', owner: 'D04', semantic: 'batch-provenance' },
     { field: 'admission', scope: 'attempt', owner: 'D05', semantic: 'admission-evidence' },
     { field: 'context', scope: 'decision', owner: 'D06', semantic: 'context-evidence' },
@@ -126,6 +151,7 @@ export const DECISION_RESULT_V1ALPHA2_FIELDS = [
     { field: 'calibrationCompatibility', scope: 'decision', owner: 'D09', semantic: 'calibration-pin' },
     { field: 'cache', scope: 'ruleset', owner: 'D15', semantic: 'result-cache-receipt' },
     { field: 'projection', scope: 'ruleset', owner: 'D10', semantic: 'projection-opt-out' },
+    { field: 'preprocessingLineage', scope: 'ruleset', owner: 'D24', semantic: 'trust-projection' },
 ];
 /** JSON paths of every v1alpha2-only field present in a DecisionResult or RulesetResult. */
 export function decisionResultV1Alpha2Fields(value) {

package/dist/src/extensions/commands/definitions.js

@@ -182,6 +182,42 @@ export const installationCommand = {
         allowedTools: ['Read', 'Write'],
     },
 };
+export const decisionCommand = {
+    id: 'decision',
+    type: 'command',
+    name: 'Decision Driver',
+    description: 'Inspect, validate and run governed decision classification workflows',
+    version: '1.0.0',
+    capabilities: ['cli', 'decision', 'classification', 'mcp', 'validation'],
+    keywords: ['decision', 'classification', 'patterns', 'mcp', 'evaluate', 'validate'],
+    category: 'utility',
+    platforms: { claude: 'full', generic: 'full' },
+    deployment: { pathTemplate: '.{platform}/commands/{id}.md', core: true },
+    metadata: {
+        type: 'command',
+        template: 'utility',
+        argumentHint: '<capabilities|patterns|validate|evaluate|setup> [options]',
+        allowedTools: ['Read', 'Write', 'Bash'],
+    },
+};
+export const gatesCommand = {
+    id: 'gates',
+    type: 'command',
+    name: 'Gates',
+    description: 'Validate, evaluate and inspect declarative gate packs offline',
+    version: '1.0.0',
+    capabilities: ['cli', 'gates', 'validation', 'evaluation'],
+    keywords: ['gates', 'gate pack', 'validate', 'evaluate', 'promotion', 'hold', 'rollback'],
+    category: 'utility',
+    platforms: { claude: 'full', generic: 'full' },
+    deployment: { pathTemplate: '.{platform}/commands/{id}.md', core: true },
+    metadata: {
+        type: 'command',
+        template: 'utility',
+        argumentHint: '<validate|evaluate|show|list> [options]',
+        allowedTools: ['Read'],
+    },
+};
 // Renamed from `refreshCommand` as part of #694 (avoid collision with git sync
 // semantics) and re-linked to `refreshHandler` in #919. Users who type
 // `aiwg sync` still reach this handler via its 'sync' alias and see a
@@ -3715,6 +3751,8 @@ export const commandDefinitions = [
     contextFirewallCommand,
     updateCommand,
     installationCommand,
+    decisionCommand,
+    gatesCommand,
     refreshCommand,
     regenerateCommand,
     workspaceContextCommand,

package/dist/src/extensions/manifest.js

@@ -40,6 +40,7 @@ export const ProjectLocalTypeSchema = z.enum([
  */
 const safeRelativePath = z.string().regex(/^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*\/?$/, 'must be a relative path (alphanumeric + _-, no leading slash, no ..)');
 const safeModuleFile = z.string().regex(/^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*\.mjs$/, 'must be a relative .mjs path (alphanumeric + _-, no leading slash, no ..)');
+const safeJsonFile = z.string().regex(/^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*\.json$/, 'must be a relative .json path (alphanumeric + _-, no leading slash, no ..)');
 // Single-char ids are allowed; multi-char ids must end with alphanumeric
 // (no trailing hyphen). This pattern: `[a-z0-9]([a-z0-9-]*[a-z0-9])?`
 const bundleNamePattern = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
@@ -55,6 +56,7 @@ const ArtifactListsSchema = z.object({
     hooks: z.array(z.string()).max(50).optional(),
     commands: z.array(z.string()).max(200).optional(),
     behaviors: z.array(z.string()).max(50).optional(),
+    gatePacks: z.array(z.string().min(1).max(128)).max(50).optional(),
 });
 const EntryPathsSchema = z.object({
     agents: safeRelativePath.optional(),
@@ -65,6 +67,7 @@ const EntryPathsSchema = z.object({
     hooks: safeRelativePath.optional(),
     commands: safeRelativePath.optional(),
     behaviors: safeRelativePath.optional(),
+    gatePacks: safeRelativePath.optional(),
 }).strict();
 export const AddonConfigSchema = z.object({
     entry: EntryPathsSchema.optional(),
@@ -76,6 +79,10 @@ export const FrameworkConfigSchema = z.object({
     path: safeRelativePath.optional(),
     files: z.array(safeRelativePath).max(100).optional(),
     ignore: z.array(safeRelativePath).max(100).optional(),
+    gatePacks: z.array(z.string().min(1).max(128)).max(50).optional(),
+    entry: z.object({
+        gatePacks: safeRelativePath.optional(),
+    }).strict().optional(),
     contextContributions: z.object({
         hookFragment: safeRelativePath.optional(),
         sectionsDir: safeRelativePath.optional(),
@@ -136,6 +143,37 @@ export const ProviderConfigSchema = z.object({
     aliases: z.array(z.string().min(1).max(64)).max(20).optional(),
     capabilities: ProviderCapabilityOverridesSchema.optional(),
 }).strict();
+/**
+ * Review attestation for one gate metric provider (#2831).
+ *
+ * A reviewer records who reviewed which exact provider bytes and when. The
+ * `codeDigest` must equal the loader-computed code digest over the provider
+ * module plus its resolved local imports (and lockfile-pinned externals);
+ * registration refuses absent attestations and digest mismatches. Null or
+ * unknown digests never verify: they fail closed.
+ */
+export const GateProviderReviewSchema = z.object({
+    reviewer: z.string().min(1).max(128),
+    reviewedAt: z.string().datetime(),
+    codeDigest: z.string().regex(/^sha256:[0-9a-f]{64}$/, 'must be a sha256 digest'),
+}).strict();
+/**
+ * One addon/extension gate metric provider declared by a bundle manifest
+ * (#2831). The module is loaded ONLY through the gates registry from this
+ * declaration, inside the bundle root (no traversal, no escaping symlinks,
+ * no absolute paths, size-limited), never by arbitrary import. Core
+ * providers remain the default; this field is optional and disabled unless
+ * the caller explicitly enables bundle providers.
+ */
+export const GateProviderEntrySchema = z.object({
+    id: z.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/, 'must be a namespaced provider id <scope>/<name> (alphanumeric plus . _ -)'),
+    version: z.string().regex(/^\d+\.\d+\.\d+/, 'CalVer or SemVer (X.Y.Z[...])'),
+    module: safeModuleFile,
+    description: z.string().min(1).max(512),
+    review: GateProviderReviewSchema.optional(),
+    reviewFile: safeJsonFile.optional(),
+}).strict().refine((entry) => (entry.review !== undefined) !== (entry.reviewFile !== undefined), { message: 'exactly one of review or reviewFile is required' });
+export const GateProvidersSchema = z.array(GateProviderEntrySchema).max(20).refine((entries) => new Set(entries.map((entry) => entry.id)).size === entries.length, { message: 'gate provider ids must be unique within a bundle' }).refine((entries) => new Set(entries.map((entry) => entry.module)).size === entries.length, { message: 'gate provider modules must be unique within a bundle' });
 export const CliCommandsSchema = z.object({
     namespace: z.string()
         .min(1)
@@ -197,6 +235,12 @@ export const BundleManifestSchema = z.object({
     // Expandable CLI namespace contributed by an addon-shaped bundle.
     // The same block is accepted by bundled addon manifests.
     cli_commands: CliCommandsSchema.optional(),
+    // Addon/extension gate metric providers (#2831). Optional and disabled by
+    // default: the gates loader resolves each `module` inside the bundle root
+    // only, verifies the review attestation digest against the computed code
+    // digest, and registers the provider through the gates registry. Core
+    // providers remain the default when this field is absent.
+    gateProviders: GateProvidersSchema.optional(),
 })
     .strict()
     .refine((m) => {

package/dist/src/gates/discovery.js

@@ -0,0 +1,315 @@
+import { lstatSync, readdirSync, readFileSync, existsSync, realpathSync, statSync } from 'node:fs';
+import { basename, join, resolve, sep } from 'node:path';
+import { parseDecisionJson, parseDecisionYaml } from '../decision/entry.js';
+import { MANIFEST_MAX_BYTES } from '../extensions/manifest.js';
+import { validateGateDocument } from './schema.js';
+export const GATE_PACKS_DIR = 'gate-packs';
+/** Admission cap for one gate-pack authoring file, checked before reading (same as the artifact index). */
+export const GATE_PACK_MAX_BYTES = 256 * 1024;
+/** Manifest-declared bundle subdirs stay inside the bundle: segments only, no `..`, no leading `/`. */
+const SAFE_RELATIVE_DIR = /^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*\/?$/;
+const realpathIfExists = (candidate) => {
+    try {
+        return realpathSync(candidate);
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Resolve a manifest-declared gate-packs dir inside its bundle. A raw
+ * `entry.gatePacks` value is validated as a safe relative path and contained
+ * by realpath: `../../../outside` and symlink escapes are load errors, never
+ * followed. A missing dir resolves (callers treat it as empty); a hostile
+ * declaration throws even when the dir is absent.
+ */
+export function resolveGatePacksDir(bundleDir, declared) {
+    const subdir = declared ?? GATE_PACKS_DIR;
+    if (!SAFE_RELATIVE_DIR.test(subdir)) {
+        throw new Error(`gatePacks dir '${subdir}' must be a relative path inside the bundle`
+            + ` (alphanumeric + _-, no leading slash, no ..): ${bundleDir}`);
+    }
+    const absolute = resolve(bundleDir, subdir);
+    const realBundle = realpathIfExists(bundleDir);
+    const realTarget = realpathIfExists(absolute);
+    if (realBundle !== null && realTarget !== null
+        && realTarget !== realBundle && !realTarget.startsWith(realBundle + sep)) {
+        throw new Error(`gatePacks dir '${subdir}' escapes its bundle: ${bundleDir}`);
+    }
+    return absolute;
+}
+const GATE_PACK_SUFFIXES = ['.gatepack.yaml', '.gatepack.yml', '.gatepack.json'];
+/** True when the filename is a gate-pack authoring file (never HITL `gates/`). */
+export function isGatePackFile(filename) {
+    const lower = filename.toLowerCase();
+    return GATE_PACK_SUFFIXES.some(suffix => lower.endsWith(suffix));
+}
+/**
+ * Sorted gate-pack authoring files directly under the bundle's gate-packs
+ * dir. Every match is lstat-checked before it is returned: symlinks are
+ * rejected (never followed), only regular files qualify, the 256 KiB cap is
+ * enforced before any read, and the realpath must stay inside the dir.
+ */
+export function listGatePackFiles(bundleDir, gatePacksDir = GATE_PACKS_DIR) {
+    const dir = resolveGatePacksDir(bundleDir, gatePacksDir);
+    const realDir = realpathIfExists(dir);
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries.filter(isGatePackFile).sort()) {
+        const full = join(dir, entry);
+        let status;
+        try {
+            status = lstatSync(full);
+        }
+        catch (error) {
+            throw new Error(`gate pack unreadable: ${full}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (status.isSymbolicLink())
+            throw new Error(`gate pack must not be a symlink: ${full}`);
+        if (!status.isFile())
+            throw new Error(`gate pack is not a regular file: ${full}`);
+        if (status.size > GATE_PACK_MAX_BYTES) {
+            throw new Error(`gate pack exceeds 256 KiB before reading: ${full}`);
+        }
+        const real = realpathIfExists(full);
+        if (realDir !== null && real !== null && real !== realDir && !real.startsWith(realDir + sep)) {
+            throw new Error(`gate pack escapes its bundle: ${full}`);
+        }
+        files.push(full);
+    }
+    return files;
+}
+/** Read the bundle manifest's gate-pack declaration when present (both legacy and Zod shapes). */
+export function readBundleGatePacksDeclaration(bundleDir) {
+    const manifestPath = join(resolve(bundleDir), 'manifest.json');
+    if (!existsSync(manifestPath))
+        return {};
+    let manifest;
+    try {
+        const status = statSync(manifestPath);
+        if (!status.isFile() || status.size > MANIFEST_MAX_BYTES)
+            return {};
+        manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+    if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest))
+        return {};
+    const root = manifest;
+    const entry = root.entry;
+    const dir = typeof entry?.gatePacks === 'string' ? entry.gatePacks
+        : typeof entry?.['gate-packs'] === 'string' ? String(entry['gate-packs'])
+            : undefined;
+    const topNames = Array.isArray(root.gatePacks)
+        ? root.gatePacks.filter((name) => typeof name === 'string')
+        : undefined;
+    for (const configKey of ['addonConfig', 'extensionConfig', 'frameworkConfig']) {
+        const config = root[configKey];
+        if (!config || typeof config !== 'object')
+            continue;
+        if (topNames === undefined && Array.isArray(config.gatePacks)) {
+            const names = config.gatePacks.filter((name) => typeof name === 'string');
+            return { ...(dir ? { dir } : {}), names };
+        }
+        const configEntry = config.entry;
+        if (dir === undefined && typeof configEntry?.gatePacks === 'string') {
+            return { dir: configEntry.gatePacks, ...(topNames ? { names: topNames } : {}) };
+        }
+    }
+    if (root.frameworkConfig && typeof root.frameworkConfig === 'object') {
+        const framework = root.frameworkConfig;
+        if (Array.isArray(framework.gatePacks)) {
+            const names = framework.gatePacks.filter((name) => typeof name === 'string');
+            const frameworkEntry = framework.entry;
+            const frameworkDir = typeof frameworkEntry?.gatePacks === 'string' ? frameworkEntry.gatePacks : dir;
+            return { ...(frameworkDir ? { dir: frameworkDir } : {}), names };
+        }
+    }
+    return { ...(dir ? { dir } : {}), ...(topNames ? { names: topNames } : {}) };
+}
+/**
+ * Parse one authoring file with admission limits and closed-schema validation.
+ * Never returns an invalid pack. The file is lstat-checked before any read:
+ * symlinks are rejected, only regular files qualify, and the 256 KiB cap is
+ * enforced up front so an unbounded read can never happen here.
+ */
+export function loadGatePackFile(filePath) {
+    let status;
+    try {
+        status = lstatSync(filePath);
+    }
+    catch (error) {
+        throw new Error(`gate pack unreadable: ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (status.isSymbolicLink())
+        throw new Error(`gate pack must not be a symlink: ${filePath}`);
+    if (!status.isFile())
+        throw new Error(`gate pack is not a regular file: ${filePath}`);
+    if (status.size > GATE_PACK_MAX_BYTES)
+        throw new Error(`gate pack exceeds 256 KiB before reading: ${filePath}`);
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`gate pack unreadable: ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let document;
+    try {
+        document = filePath.toLowerCase().endsWith('.json') ? parseDecisionJson(content) : parseDecisionYaml(content);
+    }
+    catch (error) {
+        throw new Error(`gate pack unparseable: ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+        const pack = validateGateDocument(document);
+        if (pack.kind !== 'GatePack')
+            throw new Error(`expected kind GatePack, got '${String(document.kind)}'`);
+        return pack;
+    }
+    catch (error) {
+        throw new Error(`gate pack invalid: ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Register every pack in one bundle directory. Invalid packs are rejected
+ * with a file-pathed diagnostic; nothing invalid enters the registry.
+ */
+export function registerBundleGatePacks(registry, bundleDir, origin) {
+    const declaration = readBundleGatePacksDeclaration(bundleDir);
+    // The declared gate-packs dir itself must be a real directory (checked
+    // before realpath resolution): a symlinked dir would load packs from
+    // outside the bundle under the bundle's origin.
+    try {
+        if (lstatSync(join(resolve(bundleDir), declaration.dir ?? GATE_PACKS_DIR)).isSymbolicLink()) {
+            throw new Error(`bundle gate-packs dir must not be a symlink: ${bundleDir}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && /symlink/.test(error.message))
+            throw error;
+        /* absent dir: listGatePackFiles reports nothing */
+    }
+    // Containment validation (throws on traversal escapes).
+    const gatePacksDir = resolveGatePacksDir(bundleDir, declaration.dir);
+    const files = listGatePackFiles(bundleDir, declaration.dir ?? GATE_PACKS_DIR);
+    const wanted = declaration.names ? new Set(declaration.names) : null;
+    const loaded = [];
+    for (const file of files) {
+        const short = basename(file).replace(/\.gatepack\.(yaml|yml|json)$/i, '');
+        if (wanted && !wanted.has(short))
+            continue;
+        const pack = loadGatePackFile(file);
+        try {
+            registry.registerPack(pack, origin.bundle === undefined ? { namespace: origin.namespace } : origin);
+        }
+        catch (error) {
+            throw new Error(`gate pack rejected: ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        loaded.push(pack.metadata.id);
+    }
+    if (wanted) {
+        for (const name of wanted) {
+            if (!files.some(file => basename(file).replace(/\.gatepack\.(yaml|yml|json)$/i, '') === name)) {
+                throw new Error(`gate pack missing: ${gatePacksDir}/${name}.gatepack.yaml (declared by manifest)`);
+            }
+        }
+    }
+    return loaded;
+}
+/**
+ * Derive a `--pack-dir` bundle's contribution origin from its manifest, never
+ * from its path. Unverified `--pack-dir` bundles are ALWAYS project-scoped:
+ * only the installed tree (via `discoverShippedGatePacks`) contributes
+ * `aiwg:` packs. A manifest whose `{id, type}` claims a shipped bundle
+ * (under `<aiwgRoot>/agentic/code/...`) or an installed project bundle
+ * (under `<cwd>/.aiwg/...`) that is not its own directory refuses:
+ * impersonating a trusted bundle id through an unverified path is a load
+ * error. Path substrings such as `/addons/` are never consulted.
+ */
+export function originForPackDir(bundleDir, options) {
+    const manifestPath = join(resolve(bundleDir), 'manifest.json');
+    let claimed = null;
+    try {
+        const status = statSync(manifestPath);
+        if (!status.isFile() || status.size > MANIFEST_MAX_BYTES)
+            return { namespace: 'project' };
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        if (typeof manifest?.id === 'string' && manifest.id.trim() !== ''
+            && (manifest.type === 'framework' || manifest.type === 'addon' || manifest.type === 'extension')) {
+            claimed = { id: manifest.id, type: manifest.type };
+        }
+    }
+    catch {
+        return { namespace: 'project' };
+    }
+    if (claimed !== null) {
+        const plural = claimed.type === 'framework' ? 'frameworks' : claimed.type === 'addon' ? 'addons' : 'extensions';
+        const candidates = [];
+        if (options?.aiwgRoot)
+            candidates.push({ root: join(resolve(options.aiwgRoot), 'agentic/code', plural, claimed.id), label: 'shipped' });
+        if (options?.cwd)
+            candidates.push({ root: join(resolve(options.cwd), '.aiwg', plural, claimed.id), label: 'installed' });
+        const own = realpathIfExists(resolve(bundleDir));
+        for (const candidate of candidates) {
+            const trusted = realpathIfExists(candidate.root);
+            if (trusted === null)
+                continue;
+            if (own === null || own !== trusted) {
+                throw new Error(`pack-dir bundle claims a ${candidate.label} bundle id '${claimed.id}'`
+                    + ` that is not its own directory: ${bundleDir}`);
+            }
+        }
+    }
+    return { namespace: 'project' };
+}
+const BUNDLE_GROUPS = [
+    { kind: 'framework', sub: 'frameworks' },
+    { kind: 'addon', sub: 'addons' },
+    { kind: 'extension', sub: 'extensions' },
+];
+/**
+ * Register shipped packs under `agentic/code/<group>/<bundle>/gate-packs/`.
+ * Shipped packs use the `aiwg:` namespace (`aiwg:<bundle>/<name>`); the
+ * bundle kind is only an install hint. Project-local bundles register under
+ * their own `framework:`/`addon:`/`extension:` namespace via
+ * `registerBundleGatePacks` directly.
+ */
+export function discoverShippedGatePacks(aiwgRoot, registry) {
+    const loaded = [];
+    for (const group of BUNDLE_GROUPS) {
+        const groupDir = resolve(aiwgRoot, 'agentic/code', group.sub);
+        let bundles;
+        try {
+            bundles = readdirSync(groupDir).filter(name => {
+                try {
+                    return statSync(join(groupDir, name)).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            }).sort();
+        }
+        catch {
+            continue;
+        }
+        for (const bundle of bundles) {
+            const bundleDir = join(groupDir, bundle);
+            const files = listGatePackFiles(bundleDir);
+            if (!files.length && !existsSync(join(bundleDir, 'manifest.json')))
+                continue;
+            if (!files.length)
+                continue;
+            loaded.push(...registerBundleGatePacks(registry, bundleDir, { namespace: 'aiwg', bundle }));
+        }
+    }
+    return loaded;
+}
+//# sourceMappingURL=discovery.js.map