@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/extensions/managed-marker.js

@@ -0,0 +1,100 @@
+/**
+ * Managed-marker normalization for hash equivalence.
+ *
+ * The deployer injects a managed-marker comment into every deployed
+ * markdown artifact (see `tools/agents/providers/base.mjs:addManagedMarker`).
+ * Two forms exist:
+ *
+ *   1. YAML-frontmatter inline (current — non-breaking for parsers):
+ *
+ *        ---
+ *        # aiwg:managed v<VERSION> <SOURCE>
+ *        name: ...
+ *        ...
+ *        ---
+ *
+ *   2. HTML-comment-on-line-1 (legacy — files with no frontmatter):
+ *
+ *        <!-- aiwg:managed v<VERSION> <SOURCE> -->
+ *        # Some heading
+ *
+ * Source files in the repo do NOT carry the marker; it's a deploy-time
+ * artifact only. That means a naive `sha256(source) == sha256(deployed)`
+ * comparison will always fail by exactly one line, producing the spurious
+ * drift detected in #1086 and the same false-positive surface in
+ * `aiwg remove`'s pristine/mutated classifier (per #1048's design).
+ *
+ * This module makes the marker invisible to the equivalence relation:
+ * both deploy-time hash recording and post-deploy comparison hash the
+ * marker-stripped form. The marker therefore never participates in the
+ * "is this the same file?" check.
+ *
+ * Trade-off: an operator who removes the marker from a deployed file
+ * but leaves the rest unchanged is NOT flagged as drift (stripped both
+ * sides → same content → same hash). This is a conscious choice — the
+ * marker exists for `aiwg remove`'s ownership labelling, not as a
+ * tamper-evident seal. Real content edits remain detected normally.
+ *
+ * @implements #1086
+ */
+import { readFile } from 'fs/promises';
+import { createHash } from 'crypto';
+/**
+ * Match either marker form:
+ *   - HTML comment at line 1: `<!-- aiwg:managed v... ... -->\n`
+ *   - YAML comment inside frontmatter (line 2): `# aiwg:managed v... ...\n`
+ *
+ * Multiline mode anchors `^` to start of any line, so the YAML form is
+ * matched whether it appears as the first or second line of the file.
+ *
+ * The pattern intentionally does NOT consume any other line; it strips
+ * only the single marker line and its trailing newline.
+ */
+const MANAGED_MARKER_LINE_RE = /^(?:<!-- aiwg:managed [^\n]*-->|# aiwg:managed [^\n]*)\n/m;
+/**
+ * Return the content with the managed-marker line removed if present.
+ * Idempotent — calling twice on the same input is the same as calling once.
+ *
+ * If no marker is present, returns the input unchanged (referentially —
+ * same string instance).
+ */
+export function stripManagedMarker(content) {
+    return content.replace(MANAGED_MARKER_LINE_RE, '');
+}
+/**
+ * Read a file from disk, strip any managed-marker line, and return the
+ * SHA-256 hex digest of the result.
+ *
+ * Throws on read errors (caller should catch and treat as missing).
+ *
+ * Used in two places:
+ *   - `hashBundleArtifacts()` records this hash for source files at
+ *     deploy time. Source files have no marker, so this is identical
+ *     to the previous unnormalized hash — backwards-compatible with
+ *     existing registry entries.
+ *   - Drift detection (`aiwg doctor`) and pristine classification
+ *     (`aiwg remove`) hash the deployed file using this function. The
+ *     marker line is stripped before hashing so the two sides match.
+ */
+export async function sha256OfFileNormalized(absPath) {
+    const buf = await readFile(absPath, 'utf8');
+    const stripped = stripManagedMarker(buf);
+    return createHash('sha256').update(stripped, 'utf8').digest('hex');
+}
+/**
+ * Read a file and return both raw and managed-marker-normalized hashes.
+ *
+ * This is used by drift detectors that must remain compatible with
+ * registries populated before #1086 normalization shipped. In that narrow
+ * case the registry may contain the raw deployed hash, while newer deploys
+ * contain the normalized source hash.
+ */
+export async function sha256OfFileRawAndNormalized(absPath) {
+    const buf = await readFile(absPath, 'utf8');
+    const stripped = stripManagedMarker(buf);
+    return {
+        raw: createHash('sha256').update(buf, 'utf8').digest('hex'),
+        normalized: createHash('sha256').update(stripped, 'utf8').digest('hex'),
+    };
+}
+//# sourceMappingURL=managed-marker.js.map

package/dist/src/extensions/manifest.js

@@ -0,0 +1,196 @@
+/**
+ * Bundle Manifest Schema (Zod)
+ *
+ * Validates `.aiwg/{extensions,addons,frameworks,plugins,providers}/<name>/manifest.json`
+ * for project-local artifact bundles. Implements the design in
+ * `.aiwg/architecture/design-manifest-schema.md` (#1044).
+ *
+ * Layered above the per-artifact Extension type validation in `validation.ts`:
+ * the bundle manifest declares the bundle (a directory containing artifacts);
+ * the existing schemas validate individual artifact bodies inside the bundle.
+ *
+ * @implements #1044
+ * @architecture .aiwg/architecture/design-manifest-schema.md
+ */
+import { z } from 'zod';
+import { PlatformCompatibilitySchema, DeploymentConfigSchema, MemoryFootprintSchema, DeprecationSchema, } from './validation.js';
+// ============================================
+// Limits (from #1042 threat model + #1044 design)
+// ============================================
+export const MANIFEST_MAX_BYTES = 64 * 1024; // 64 KB
+export const MAX_BUNDLES_PER_PROJECT = 200;
+export const MAX_KEYWORDS_PER_MANIFEST = 50;
+export const MAX_OVERRIDES_PER_MANIFEST = 20;
+// ============================================
+// Project-local bundle types (#1040)
+// ============================================
+export const ProjectLocalTypeSchema = z.enum([
+    'extension',
+    'addon',
+    'framework',
+    'plugin',
+    'provider',
+]);
+// ============================================
+// Path safety helpers
+// ============================================
+/**
+ * Relative paths within a bundle. No `..`, no leading `/`, alphanumeric +
+ * underscore + hyphen, optional trailing slash.
+ */
+const safeRelativePath = z.string().regex(/^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*\/?$/, 'must be a relative 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])?$/;
+// ============================================
+// Per-type config blocks
+// ============================================
+const ArtifactListsSchema = z.object({
+    agents: z.array(z.string()).max(200).optional(),
+    skills: z.array(z.string()).max(500).optional(),
+    rules: z.array(z.string()).max(200).optional(),
+    templates: z.array(z.string()).max(200).optional(),
+    prompts: z.array(z.string()).max(200).optional(),
+    hooks: z.array(z.string()).max(50).optional(),
+    commands: z.array(z.string()).max(200).optional(),
+    behaviors: z.array(z.string()).max(50).optional(),
+});
+const EntryPathsSchema = z.object({
+    agents: safeRelativePath.optional(),
+    skills: safeRelativePath.optional(),
+    rules: safeRelativePath.optional(),
+    templates: safeRelativePath.optional(),
+    prompts: safeRelativePath.optional(),
+    hooks: safeRelativePath.optional(),
+    commands: safeRelativePath.optional(),
+    behaviors: safeRelativePath.optional(),
+}).strict();
+export const AddonConfigSchema = z.object({
+    entry: EntryPathsSchema.optional(),
+    ...ArtifactListsSchema.shape,
+    core: z.boolean().optional(),
+    autoInstall: z.boolean().optional(),
+}).strict();
+export const FrameworkConfigSchema = z.object({
+    path: safeRelativePath.optional(),
+    files: z.array(safeRelativePath).max(100).optional(),
+    ignore: z.array(safeRelativePath).max(100).optional(),
+    contextContributions: z.object({
+        hookFragment: safeRelativePath.optional(),
+        sectionsDir: safeRelativePath.optional(),
+        sectionsManifest: safeRelativePath.optional(),
+        priority: z.number().int().min(0).max(100).optional(),
+        description: z.string().max(512).optional(),
+    }).strict().optional(),
+}).strict();
+export const ExtensionConfigSchema = z.object({
+    entry: EntryPathsSchema.optional(),
+    ...ArtifactListsSchema.shape,
+}).strict();
+export const PluginConfigSchema = z.object({
+    payloadType: z.enum(['addon', 'framework', 'extension']),
+    payloadPath: safeRelativePath,
+}).strict();
+const ProviderCapabilityFeatureSchema = z.enum([
+    'cron',
+    'agent_teams',
+    'tasks',
+    'mcp',
+    'behaviors',
+    'mission_control',
+    'daemon',
+]);
+const ProviderCapabilityEmulationSchema = z.enum([
+    'native',
+    'hooks',
+    'aiwg-mc',
+    'aiwg-schedule',
+    'aiwg-daemon',
+]).nullable();
+const ProviderCapabilityOverridesSchema = z.object({
+    nativeFeatures: z.record(ProviderCapabilityFeatureSchema, z.boolean()).optional(),
+    emulation: z.record(ProviderCapabilityFeatureSchema, ProviderCapabilityEmulationSchema).optional(),
+}).strict();
+export const ProviderConfigSchema = z.object({
+    extends: z.enum([
+        'claude',
+        'codex',
+        'copilot',
+        'cursor',
+        'factory',
+        'hermes',
+        'opencode',
+        'openclaw',
+        'openhuman',
+        'warp',
+        'windsurf',
+    ]),
+    displayName: z.string().min(1).max(128).optional(),
+    aliases: z.array(z.string().min(1).max(64)).max(20).optional(),
+    capabilities: ProviderCapabilityOverridesSchema.optional(),
+}).strict();
+// ============================================
+// Top-level BundleManifestSchema
+// ============================================
+export const BundleManifestSchema = z.object({
+    // Required core fields
+    id: z.string()
+        .min(1)
+        .max(64)
+        .regex(bundleNamePattern, 'kebab-case alphanumeric, no leading/trailing hyphen'),
+    type: ProjectLocalTypeSchema,
+    name: z.string().min(1).max(128),
+    version: z.string().regex(/^\d+\.\d+\.\d+/, 'CalVer or SemVer (X.Y.Z[...])'),
+    description: z.string().min(1).max(1024),
+    manifestVersion: z.literal('1'),
+    platforms: PlatformCompatibilitySchema,
+    keywords: z.array(z.string().max(64)).min(1).max(MAX_KEYWORDS_PER_MANIFEST),
+    deployment: DeploymentConfigSchema,
+    // Optional standard metadata
+    author: z.string().max(128).optional(),
+    license: z.string().max(64).optional(),
+    repository: z.string().url().max(512).optional(),
+    // Type-discriminated nested config (exactly one matches `type`)
+    addonConfig: AddonConfigSchema.optional(),
+    frameworkConfig: FrameworkConfigSchema.optional(),
+    extensionConfig: ExtensionConfigSchema.optional(),
+    pluginConfig: PluginConfigSchema.optional(),
+    providerConfig: ProviderConfigSchema.optional(),
+    // Override / safety-critical declarations (#1041)
+    'safety-critical': z.boolean().optional(),
+    overrides: z.array(z.string().max(64)).max(MAX_OVERRIDES_PER_MANIFEST).optional(),
+    // Optional patterns shared with existing extension validation
+    deprecation: DeprecationSchema.optional(),
+    memory: MemoryFootprintSchema.optional(),
+})
+    .strict()
+    .refine((m) => {
+    // Discriminator alignment: type must match the present *Config block(s)
+    const present = {
+        addon: m.addonConfig !== undefined,
+        framework: m.frameworkConfig !== undefined,
+        extension: m.extensionConfig !== undefined,
+        plugin: m.pluginConfig !== undefined,
+        provider: m.providerConfig !== undefined,
+    };
+    const presentCount = Object.values(present).filter(Boolean).length;
+    // Extension is the only type that may omit its config block; others require it
+    if (m.type === 'extension') {
+        return presentCount === 0 || (presentCount === 1 && present.extension);
+    }
+    return presentCount === 1 && present[m.type];
+}, { message: 'type must match its corresponding *Config block (addon→addonConfig, framework→frameworkConfig, plugin→pluginConfig, provider→providerConfig; extension may omit extensionConfig)' });
+/**
+ * Convert a Zod error into the structured ManifestValidationError shape used
+ * by discovery and `aiwg validate-metadata`.
+ */
+export function zodErrorToValidationErrors(err, manifestPath) {
+    return err.errors.map((issue) => ({
+        path: manifestPath,
+        field: issue.path.join('.') || '(root)',
+        expected: issue.message,
+        actual: 'received' in issue ? String(issue.received) : 'invalid',
+        severity: 'error',
+    }));
+}
+//# sourceMappingURL=manifest.js.map

package/dist/src/extensions/project-local-activity.js

@@ -0,0 +1,114 @@
+/**
+ * Project-Local Activity Log Helper
+ *
+ * Inline activity-log emission for project-local artifact lifecycle events.
+ * Wraps the storage adapter from `resolveStorage('activity_log')` and emits
+ * single-line entries per the format frozen by the activity-log rule.
+ *
+ * The generic post-command hook in `cli/hooks/builtin/activity-log-hook.ts`
+ * emits one entry per CLI invocation (`aiwg use sdlc`). This helper emits
+ * per-event entries (per-bundle, per-provider) at finer granularity, as
+ * specified by the design doc.
+ *
+ * @design @.aiwg/architecture/design-doctor-log-promote.md
+ * @implements #1037
+ * @issue #1049
+ */
+import { formatEntry } from '../activity-log/types.js';
+import { resolveStorage } from '../storage/index.js';
+const LOG_PATH = 'activity.log';
+/** Map design-event → frozen wire-format op token. */
+const EVENT_TO_OP = {
+    discover: 'query',
+    deploy: 'deploy',
+    'deploy-failed': 'deploy',
+    conflict: 'deploy',
+    'shadow-acknowledged': 'deploy',
+    'shadow-refused': 'deploy',
+    remove: 'delete',
+    'remove-mutated': 'delete',
+    'remove-conflict': 'delete',
+    'remove-force': 'delete',
+    promote: 'promote',
+    'promote-failed': 'promote',
+};
+/**
+ * Append an activity-log entry for a project-local lifecycle event.
+ *
+ * Non-blocking: write failures are swallowed with a stderr warning. The
+ * caller's primary operation must not depend on log success.
+ *
+ * Wire format: `## [TS] <op> | <event>: <name>:<type> | <summary>`
+ */
+export async function appendProjectLocalActivity(ev) {
+    if (process.env['AIWG_SKIP_ACTIVITY_LOG']) {
+        const v = process.env['AIWG_SKIP_ACTIVITY_LOG'].toLowerCase().trim();
+        if (v && v !== '0' && v !== 'false')
+            return;
+    }
+    const op = EVENT_TO_OP[ev.event];
+    const compactSummary = `${ev.event}: ${ev.name}:${ev.type} | ${ev.summary}`;
+    const line = formatEntry({
+        timestamp: new Date(),
+        operation: op,
+        summary: compactSummary,
+    }) + '\n';
+    try {
+        const adapter = await resolveStorage('activity_log');
+        if (typeof adapter.append === 'function') {
+            const existing = (await adapter.read(LOG_PATH)) ?? '';
+            if (existing.length > 0 && !existing.endsWith('\n')) {
+                await adapter.append(LOG_PATH, '\n');
+            }
+            await adapter.append(LOG_PATH, line);
+        }
+        else {
+            const existing = (await adapter.read(LOG_PATH)) ?? '';
+            const trailing = existing.length === 0 || existing.endsWith('\n') ? '' : '\n';
+            await adapter.write(LOG_PATH, existing + trailing + line);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`project-local activity log append failed (non-fatal): ${msg}\n`);
+    }
+}
+/**
+ * Emit `discover` events for newly-seen bundles. Per #1049 design's
+ * "discover noise control": dedupe by reading the most recent N lines
+ * and skipping (name, type) pairs that already appeared.
+ *
+ * Cheap heuristic — exact log de-dup is not required. We just want to
+ * avoid filling the log with the same lines on every read-only command.
+ */
+export async function emitDiscoverEventsDeduped(bundles) {
+    if (bundles.length === 0)
+        return;
+    if (process.env['AIWG_SKIP_ACTIVITY_LOG']) {
+        const v = process.env['AIWG_SKIP_ACTIVITY_LOG'].toLowerCase().trim();
+        if (v && v !== '0' && v !== 'false')
+            return;
+    }
+    let recent = '';
+    try {
+        const adapter = await resolveStorage('activity_log');
+        recent = (await adapter.read(LOG_PATH)) ?? '';
+    }
+    catch {
+        // Read failed — fall through and emit unconditionally (rather than
+        // suppress important events because we couldn't read history).
+    }
+    const tail = recent.split('\n').slice(-200).join('\n');
+    for (const b of bundles) {
+        const marker = `discover: ${b.id}:${b.type}`;
+        if (tail.includes(marker))
+            continue;
+        await appendProjectLocalActivity({
+            event: 'discover',
+            name: b.id,
+            type: b.type,
+            summary: `manifest discovered`,
+        });
+    }
+}
+//# sourceMappingURL=project-local-activity.js.map

package/dist/src/extensions/project-local-discovery.js

@@ -0,0 +1,261 @@
+/**
+ * Project-Local Bundle Discovery
+ *
+ * Scans `.aiwg/{extensions,addons,frameworks,plugins,providers}/<name>/manifest.json`
+ * and validates each manifest against the unified schema. Read-only — no
+ * deployment side effects.
+ *
+ * @implements #1034
+ * @architecture .aiwg/architecture/adr-aiwg-directory-layout.md (#1039)
+ * @architecture .aiwg/architecture/design-manifest-schema.md (#1044)
+ */
+import { readFile, readdir, lstat, stat, access } from 'fs/promises';
+import { join } from 'path';
+import { BundleManifestSchema, zodErrorToValidationErrors, MANIFEST_MAX_BYTES, MAX_BUNDLES_PER_PROJECT, } from './manifest.js';
+import { ensureTrailingSlash, projectLocalDisplayPath, PROJECT_LOCAL_DIR_TO_TYPE, PROJECT_LOCAL_SCAN_DIRS, resolveProjectLocalSearchRoots, } from './project-local-paths.js';
+/**
+ * Scan all project-local `.aiwg/<type>/` directories for bundles. Returns
+ * a structured result with bundles, errors, and counts. Missing directories
+ * are silently skipped (per #1039 §3 / UC-PL-6).
+ */
+export async function discoverProjectLocalBundles(projectDir, options = {}) {
+    const bundles = [];
+    const errors = [];
+    const counts = {
+        extension: 0,
+        addon: 0,
+        framework: 0,
+        plugin: 0,
+        provider: 0,
+    };
+    let totalScanned = 0;
+    const searchRoots = resolveProjectLocalSearchRoots(projectDir);
+    for (const searchRoot of searchRoots) {
+        for (const dirName of PROJECT_LOCAL_SCAN_DIRS) {
+            const type = PROJECT_LOCAL_DIR_TO_TYPE[dirName];
+            const dirPath = join(searchRoot.rootPath, dirName);
+            let bundleNames;
+            try {
+                bundleNames = await readdir(dirPath);
+            }
+            catch {
+                // Directory absent — silently skip (no-op when absent per UC-PL-6)
+                continue;
+            }
+            for (const bundleName of bundleNames) {
+                const bundlePath = join(dirPath, bundleName);
+                // Skip non-directory entries (e.g., the legacy registry.json file)
+                let isDir;
+                try {
+                    const st = await lstat(bundlePath);
+                    if (st.isSymbolicLink()) {
+                        if (!options.allowSymlinks) {
+                            errors.push({
+                                path: bundlePath,
+                                field: '(bundle directory)',
+                                expected: 'regular directory',
+                                actual: 'symlink',
+                                hint: 'Pass --allow-symlinks to opt in (per #1042 threat model T3)',
+                                severity: 'error',
+                            });
+                            continue;
+                        }
+                        // Resolve the symlink and check the target is a directory
+                        const target = await stat(bundlePath);
+                        isDir = target.isDirectory();
+                    }
+                    else {
+                        isDir = st.isDirectory();
+                    }
+                }
+                catch {
+                    continue;
+                }
+                if (!isDir)
+                    continue;
+                const manifestPath = join(bundlePath, 'manifest.json');
+                // Silently skip directories without manifest.json — these are not
+                // project-local bundles. Most commonly, .aiwg/frameworks/<id>/ holds
+                // workspace state from initializeFrameworkWorkspace() (archive/,
+                // projects/, repo/, working/), not a bundle. Issue #1058.
+                try {
+                    await access(manifestPath);
+                }
+                catch {
+                    continue;
+                }
+                totalScanned++;
+                // Enforce per-project bundle count cap (#1042 D2 / NFR-PL-12)
+                if (totalScanned > MAX_BUNDLES_PER_PROJECT) {
+                    errors.push({
+                        path: dirPath,
+                        field: '(bundle count)',
+                        expected: `<= ${MAX_BUNDLES_PER_PROJECT} bundles per project`,
+                        actual: `>${MAX_BUNDLES_PER_PROJECT}`,
+                        hint: 'Refusing to scan further bundles. Reduce project-local artifact count.',
+                        severity: 'error',
+                    });
+                    const isEmpty = bundles.length === 0;
+                    return { bundles, errors, isEmpty, counts };
+                }
+                const result = await loadAndValidateManifest(manifestPath, type, projectDir, searchRoot);
+                if (result.bundle) {
+                    bundles.push(result.bundle);
+                    counts[result.bundle.type]++;
+                }
+                errors.push(...result.errors);
+            }
+        }
+    }
+    // Cross-bundle: check for case-insensitive id collisions within a single type
+    // (NFR-PL-6) and duplicate ids (per #1041 §4 case 6)
+    for (const type of ['extension', 'addon', 'framework', 'plugin', 'provider']) {
+        const bundlesOfType = bundles.filter((b) => b.type === type);
+        const idsLower = new Map();
+        for (const b of bundlesOfType) {
+            const key = b.id.toLowerCase();
+            const existing = idsLower.get(key) ?? [];
+            existing.push(b);
+            idsLower.set(key, existing);
+        }
+        for (const [, group] of idsLower) {
+            if (group.length > 1) {
+                for (const b of group) {
+                    errors.push({
+                        path: b.manifestPath,
+                        field: 'id',
+                        expected: 'unique id (case-insensitive) within type',
+                        actual: `${b.id} (collides with ${group.filter((g) => g !== b).map((g) => g.id).join(', ')})`,
+                        hint: 'Two bundles within the same type may not share an id, even differing only in case',
+                        severity: 'error',
+                    });
+                }
+                // Drop colliding bundles from the result so they don't get treated as
+                // valid downstream
+                for (const b of group) {
+                    const idx = bundles.indexOf(b);
+                    if (idx >= 0) {
+                        bundles.splice(idx, 1);
+                        counts[b.type]--;
+                    }
+                }
+            }
+        }
+    }
+    const isEmpty = bundles.length === 0 && errors.length === 0;
+    return { bundles, errors, isEmpty, counts };
+}
+/**
+ * Read a single manifest.json, validate it, and return either a bundle or
+ * structured errors. Used by the scanner; exported for tests.
+ */
+export async function loadAndValidateManifest(manifestPath, expectedType, projectDir, searchRoot) {
+    // Size cap (#1042 D1 / NFR-PL-11): refuse before parse
+    let st;
+    try {
+        st = await stat(manifestPath);
+    }
+    catch {
+        return {
+            errors: [{
+                    path: manifestPath,
+                    field: '(file)',
+                    expected: 'manifest.json present',
+                    actual: 'absent',
+                    hint: 'Project-local bundle directory missing manifest.json',
+                    severity: 'error',
+                }],
+        };
+    }
+    if (st.size > MANIFEST_MAX_BYTES) {
+        return {
+            errors: [{
+                    path: manifestPath,
+                    field: '(file size)',
+                    expected: `<= ${MANIFEST_MAX_BYTES} bytes`,
+                    actual: `${st.size} bytes`,
+                    hint: 'Manifest exceeds size limit; refusing to parse',
+                    severity: 'error',
+                }],
+        };
+    }
+    let raw;
+    try {
+        raw = await readFile(manifestPath, 'utf-8');
+    }
+    catch (err) {
+        return {
+            errors: [{
+                    path: manifestPath,
+                    field: '(read)',
+                    expected: 'readable manifest.json',
+                    actual: err.message,
+                    severity: 'error',
+                }],
+        };
+    }
+    // Encoding check (NFR-PL-5): UTF-8 BOM is allowed; we'll normalize. Other
+    // BOMs (UTF-16 LE/BE, Latin-1) are rejected.
+    if (raw.charCodeAt(0) === 0xFEFF) {
+        raw = raw.slice(1);
+    }
+    else if (raw.charCodeAt(0) === 0xFFFE || raw.charCodeAt(0) === 0xFEFF) {
+        return {
+            errors: [{
+                    path: manifestPath,
+                    field: '(encoding)',
+                    expected: 'UTF-8',
+                    actual: 'non-UTF-8 BOM detected',
+                    hint: 'Manifest must be UTF-8 encoded',
+                    severity: 'error',
+                }],
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        return {
+            errors: [{
+                    path: manifestPath,
+                    field: '(JSON parse)',
+                    expected: 'valid JSON',
+                    actual: err.message,
+                    severity: 'error',
+                }],
+        };
+    }
+    const result = BundleManifestSchema.safeParse(parsed);
+    if (!result.success) {
+        return { errors: zodErrorToValidationErrors(result.error, manifestPath) };
+    }
+    const manifest = result.data;
+    // Cross-check: manifest declared type must match the directory it lives in.
+    if (manifest.type !== expectedType) {
+        return {
+            errors: [{
+                    path: manifestPath,
+                    field: 'type',
+                    expected: `"${expectedType}" (matching directory .aiwg/${expectedType}s/)`,
+                    actual: `"${manifest.type}"`,
+                    hint: `Bundle in .aiwg/${expectedType}s/ must declare type: "${expectedType}"`,
+                    severity: 'error',
+                }],
+        };
+    }
+    const bundlePath = manifestPath.slice(0, -'/manifest.json'.length);
+    const localPath = ensureTrailingSlash(projectLocalDisplayPath(projectDir, bundlePath, searchRoot));
+    return {
+        bundle: {
+            id: manifest.id,
+            type: manifest.type,
+            manifest,
+            bundlePath,
+            localPath,
+            manifestPath: projectLocalDisplayPath(projectDir, manifestPath, searchRoot),
+        },
+        errors: [],
+    };
+}
+//# sourceMappingURL=project-local-discovery.js.map