@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/smiths/context-pipeline/managed-hook.js

@@ -0,0 +1,95 @@
+/**
+ * Additive AIWG hook installer for operator-owned provider context files.
+ *
+ * Generalizes the CLAUDE.md hook pattern (`ensureClaudeMdHook`, #1437) to any
+ * provider-facing main prompt/context file — AGENTS.md, WARP.md, .hermes.md.
+ * When such a file exists but is not AIWG-managed (operator-authored), the prior
+ * behavior was to warn and skip, leaving Codex/Warp/Hermes without the `@AIWG.md`
+ * bridge. This installs the minimal managed hook block **additively** (operator
+ * content preserved byte-for-byte), and never requires `--force` for the additive
+ * path — `--force` stays reserved for replacing the whole file.
+ *
+ * @issue #1597 (AGENTS.md / Codex) — sibling #1579 (WARP.md / Warp)
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { buildProviderBootstrapBlock } from './workspace-context.js';
+export const CONTEXT_HOOK_START = '<!-- AIWG:context-hook:start -->';
+export const CONTEXT_HOOK_END = '<!-- AIWG:context-hook:end -->';
+/** The managed block — loads canonical workspace context before framework context. */
+export function buildContextHookBlock(provider = 'codex') {
+    return [
+        CONTEXT_HOOK_START,
+        '',
+        buildProviderBootstrapBlock(provider),
+        '',
+        '<!--',
+        '  This block is managed by `aiwg regenerate` and `aiwg use`.',
+        '  Operator content above and below this block is preserved on regenerate.',
+        '  Edit .aiwg/AIWG.md (the normalized source) then run `aiwg regenerate`.',
+        '-->',
+        '',
+        CONTEXT_HOOK_END,
+    ].join('\n');
+}
+/** Does the file already carry the canonical context hook? */
+export function hasContextHook(content) {
+    return content.includes(CONTEXT_HOOK_START) || (/^[ \t]*@WORKSPACE\.md[ \t]*$/m.test(content) && /^[ \t]*@AIWG\.md[ \t]*$/m.test(content));
+}
+/**
+ * Ensure `filePath` contains the AIWG `@AIWG.md` hook block, preserving all
+ * operator-authored content. Additive by default (no `--force` needed).
+ */
+export async function ensureManagedHook(filePath, opts = {}) {
+    const base = path.basename(filePath);
+    const block = buildContextHookBlock(opts.provider);
+    const result = { path: filePath, action: 'skipped', warnings: [] };
+    let existing;
+    try {
+        existing = await fs.readFile(filePath, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            await fs.writeFile(filePath, `${block}\n`, 'utf8');
+            result.action = 'created';
+            return result;
+        }
+        throw err;
+    }
+    // Already has both bare includes (operator wired them by hand) — nothing to do.
+    if (!existing.includes(CONTEXT_HOOK_START) && /^[ \t]*@WORKSPACE\.md[ \t]*$/m.test(existing) && /^[ \t]*@AIWG\.md[ \t]*$/m.test(existing)) {
+        result.action = 'unchanged';
+        return result;
+    }
+    const s = existing.indexOf(CONTEXT_HOOK_START);
+    const e = existing.indexOf(CONTEXT_HOOK_END);
+    // No managed block — append it to the end, preserving everything above.
+    if (s === -1 && e === -1) {
+        const trimmed = existing.replace(/\n+$/, '\n');
+        await fs.writeFile(filePath, `${trimmed}\n${block}\n`, 'utf8');
+        result.action = 'inserted';
+        return result;
+    }
+    // Malformed (one marker only) — repair only with --force to avoid clobbering.
+    if (s === -1 || e === -1) {
+        if (opts.force) {
+            const trimmed = existing.replace(/\n+$/, '\n');
+            await fs.writeFile(filePath, `${trimmed}\n${block}\n`, 'utf8');
+            result.action = 'inserted';
+            return result;
+        }
+        result.warnings.push(`${base} has a malformed AIWG hook block (one marker missing); re-run with --force to repair.`);
+        return result;
+    }
+    // Block present — refresh it if it has drifted from canonical.
+    const endOff = e + CONTEXT_HOOK_END.length;
+    const current = existing.substring(s, endOff);
+    if (current === block) {
+        result.action = 'unchanged';
+        return result;
+    }
+    await fs.writeFile(filePath, existing.substring(0, s) + block + existing.substring(endOff), 'utf8');
+    result.action = 'updated';
+    return result;
+}
+//# sourceMappingURL=managed-hook.js.map

package/dist/src/smiths/context-pipeline/overflow.js

@@ -0,0 +1,212 @@
+/**
+ * AGENTS.md size validation and auto-split (PUW-029 / #1130).
+ *
+ * Per ADR-1 §6: when AGENTS.md content exceeds the 30KB warn threshold or
+ * Codex's 32KB hard cap, auto-split moves entries to the spillover block in
+ * AGENTS.override.md. The cap (32KB) comes from `codex-rs/config_toml.rs:68`.
+ * AGENTS.override.md takes precedence at load time (`agents_md.rs:65`).
+ *
+ * Priority semantics:
+ * - 1 (high): pinned to AGENTS.md; never moves to spillover
+ * - 2 (medium): default; moves second
+ * - 3 (low): moves first
+ * - safety-critical: always pinned to priority 1, regardless of manifest
+ *
+ * If priority-1 alone exceeds 32KB, that is a hard error (per ADR-1 §6 —
+ * operator must split the framework, not silently lose safeguards).
+ */
+export const SOFT_WARN_BYTES = 30 * 1024;
+export const HARD_ERROR_BYTES = 32 * 1024;
+export const SPILLOVER_START = '<!-- spillover-from-AGENTS.md:START -->';
+export const SPILLOVER_END = '<!-- spillover-from-AGENTS.md:END -->';
+/**
+ * Resolved priority for one entry — combines safety-critical pinning with
+ * the manifest priority lookup. Safety-critical always wins.
+ */
+function resolvePriority(entry, map) {
+    if (entry.safetyCritical)
+        return 1;
+    if (map[entry.id] !== undefined)
+        return map[entry.id];
+    if (map['*'] !== undefined)
+        return map['*'];
+    return 2;
+}
+/**
+ * Errors emitted when the safety-critical floor cannot fit.
+ *
+ * Thrown rather than silently truncating safeguards. Operator must break
+ * the framework into smaller bundles.
+ */
+export class SafetyCriticalOverflowError extends Error {
+    bytes;
+    constructor(bytes) {
+        super(`AGENTS.md priority-1 content alone is ${bytes} bytes, which exceeds the ${HARD_ERROR_BYTES}-byte hard cap. ` +
+            `Operator must split the framework or reduce safety-critical pinning. ` +
+            `Per ADR-1 §6, safety-critical content cannot be moved to the spillover block.`);
+        this.bytes = bytes;
+        this.name = 'SafetyCriticalOverflowError';
+    }
+}
+/**
+ * Split an entry list by priority, returning [keep, overflow] arrays where
+ * `keep` stays in the main file and `overflow` goes to the spillover block.
+ *
+ * Strategy: estimate bytes per entry; remove priority-3 first (alphabetical
+ * within tier), then priority-2 (alphabetical within tier), until the keep
+ * total is under the soft-warn threshold (30KB). Priority-1 stays in keep
+ * regardless. Returns the unsplit list when total is already under threshold.
+ */
+function splitEntriesByPriority(entries, map, estimateBytes, budgetBytes) {
+    // Annotate each entry with its priority and bytes.
+    const annotated = entries.map((e) => ({
+        entry: e,
+        priority: resolvePriority(e, map),
+        bytes: estimateBytes(e),
+    }));
+    // Sort: priority asc (1 stays first), then by id alphabetical for determinism.
+    annotated.sort((a, b) => a.priority - b.priority || a.entry.id.localeCompare(b.entry.id));
+    const keep = [];
+    const overflow = [];
+    let totalKept = 0;
+    for (const a of annotated) {
+        if (a.priority === 1) {
+            keep.push(a.entry);
+            totalKept += a.bytes;
+        }
+        else if (totalKept + a.bytes <= budgetBytes) {
+            keep.push(a.entry);
+            totalKept += a.bytes;
+        }
+        else {
+            overflow.push(a.entry);
+        }
+    }
+    // Re-sort keep array to its natural id order (callers expect alpha).
+    keep.sort((a, b) => a.id.localeCompare(b.id));
+    overflow.sort((a, b) => a.id.localeCompare(b.id));
+    return { keep, overflow };
+}
+/**
+ * Estimate the rendered byte size of one entry, including markdown overhead.
+ * Rough but stable: id + description + path + per-entry markdown skeleton.
+ */
+function defaultEstimateEntry(entry) {
+    let bytes = 6; // bullet + emphasis markers
+    bytes += entry.id.length;
+    bytes += entry.description.length;
+    bytes += entry.path.length;
+    bytes += 12; // "  - Path: `…`" overhead
+    if (entry.tags && entry.tags.length > 0) {
+        bytes += entry.tags.join(', ').length + 12;
+    }
+    if (entry.safetyCritical)
+        bytes += 24; // "(SAFETY-CRITICAL)" + emphasis
+    bytes += 4; // trailing whitespace + newline
+    return bytes;
+}
+/**
+ * Partition all sections into "in main" vs "in spillover" entry lists,
+ * preserving safety-critical pinning and respecting the priority map.
+ *
+ * Strategy: each section is split independently using a per-section budget
+ * proportional to the total budget. This is intentionally conservative —
+ * we'd rather overflow a few low-priority entries from each section than
+ * preferentially overflow one whole section.
+ *
+ * Throws SafetyCriticalOverflowError when priority-1 alone exceeds the
+ * hard cap. Otherwise returns the partition.
+ */
+export function partitionForOverflow(sections, priorityMap, totalBudgetBytes = SOFT_WARN_BYTES, estimateEntry = defaultEstimateEntry) {
+    // First, compute the priority-1 (pinned) byte total across all sections.
+    // If that alone exceeds the hard cap, throw — operator must intervene.
+    let priorityOneBytes = 0;
+    for (const section of sections) {
+        for (const entry of section.entries) {
+            if (resolvePriority(entry, priorityMap) === 1) {
+                priorityOneBytes += estimateEntry(entry);
+            }
+        }
+    }
+    if (priorityOneBytes > HARD_ERROR_BYTES) {
+        throw new SafetyCriticalOverflowError(priorityOneBytes);
+    }
+    // Compute total budget per section. Allocate proportionally to current
+    // section size so a small section doesn't get an outsized share.
+    const totalBytes = sections.reduce((acc, s) => acc + s.entries.reduce((a, e) => a + estimateEntry(e), 0), 0);
+    if (totalBytes <= totalBudgetBytes) {
+        return {
+            mainSections: sections,
+            spilloverSections: [],
+            estimatedMainBytes: totalBytes,
+            estimatedSpilloverBytes: 0,
+            splitOccurred: false,
+        };
+    }
+    const mainSections = [];
+    const spilloverSections = [];
+    let mainTotal = 0;
+    let spilloverTotal = 0;
+    for (const section of sections) {
+        const sectionBytes = section.entries.reduce((a, e) => a + estimateEntry(e), 0);
+        // Per-section share: proportional to section's contribution, but never
+        // exceeding the overall budget (and never zero). Earlier versions floored
+        // at 1024 unconditionally — that broke small-budget unit tests and
+        // arguably violated the global cap. The cap is the real invariant.
+        const share = totalBytes > 0
+            ? Math.min(totalBudgetBytes, Math.max(64, Math.floor((sectionBytes / totalBytes) * totalBudgetBytes)))
+            : totalBudgetBytes;
+        const { keep, overflow } = splitEntriesByPriority(section.entries, priorityMap, estimateEntry, share);
+        if (keep.length > 0) {
+            mainSections.push({ type: section.type, entries: keep });
+            mainTotal += keep.reduce((a, e) => a + estimateEntry(e), 0);
+        }
+        if (overflow.length > 0) {
+            spilloverSections.push({ type: section.type, entries: overflow });
+            spilloverTotal += overflow.reduce((a, e) => a + estimateEntry(e), 0);
+        }
+    }
+    return {
+        mainSections,
+        spilloverSections,
+        estimatedMainBytes: mainTotal,
+        estimatedSpilloverBytes: spilloverTotal,
+        splitOccurred: spilloverSections.length > 0,
+    };
+}
+/**
+ * Inject or update the spillover block within an existing AGENTS.override.md
+ * content string. Operator-authored content (everything outside the spillover
+ * markers) is preserved byte-for-byte.
+ *
+ * Returns the updated content. The caller writes this back to disk.
+ */
+export function injectSpilloverBlock(existingContent, spilloverMarkdown) {
+    const startIdx = existingContent.indexOf(SPILLOVER_START);
+    const endIdx = existingContent.indexOf(SPILLOVER_END);
+    if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) {
+        // No existing spillover block. Append a new one at the end.
+        const trimmed = existingContent.replace(/\n+$/, '');
+        const prefix = trimmed.length > 0 ? trimmed + '\n\n' : '';
+        return `${prefix}${SPILLOVER_START}\n${spilloverMarkdown}\n${SPILLOVER_END}\n`;
+    }
+    // Replace existing block in place.
+    const before = existingContent.slice(0, startIdx);
+    const after = existingContent.slice(endIdx + SPILLOVER_END.length);
+    return `${before}${SPILLOVER_START}\n${spilloverMarkdown}\n${SPILLOVER_END}${after}`;
+}
+/**
+ * Extract the operator-authored portion of AGENTS.override.md (everything
+ * outside the spillover block). Used for hash-protection diffs.
+ */
+export function extractNonSpillover(content) {
+    const startIdx = content.indexOf(SPILLOVER_START);
+    const endIdx = content.indexOf(SPILLOVER_END);
+    if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) {
+        return content;
+    }
+    const before = content.slice(0, startIdx).replace(/\n+$/, '');
+    const after = content.slice(endIdx + SPILLOVER_END.length).replace(/^\n+/, '');
+    return [before, after].filter(Boolean).join('\n\n');
+}
+//# sourceMappingURL=overflow.js.map

package/dist/src/smiths/context-pipeline/parallelism-section.js

@@ -0,0 +1,94 @@
+/**
+ * Parallelism Cap Section — context-file injector
+ *
+ * Generates the markdown section that surfaces the project's
+ * `.aiwg/aiwg.config` `parallelism` cap in regenerated context files
+ * (AIWG.md, CLAUDE.md, AGENTS.md). Agents read context at session start;
+ * having the cap inline means no extra IO every session.
+ *
+ * Wrapped in managed-block markers so future regenerations replace the
+ * section in-place without disturbing operator additions outside it.
+ *
+ * Env var `AIWG_HIDE_PARALLELISM_IN_CONTEXT=1` suppresses injection.
+ *
+ * @implements #1362
+ */
+import { readAiwgConfig, resolveParallelism, PROVIDER_PARALLELISM_DEFAULTS } from '../../config/aiwg-config.js';
+export const PARALLELISM_BLOCK_START = '<!-- AIWG-PARALLELISM-CAP:START -->';
+export const PARALLELISM_BLOCK_END = '<!-- AIWG-PARALLELISM-CAP:END -->';
+/**
+ * Build the parallelism-cap markdown section for injection into context files.
+ * Returns `''` when injection should be skipped:
+ *   - `AIWG_HIDE_PARALLELISM_IN_CONTEXT=1` is set
+ *   - No `.aiwg/aiwg.config` exists at the project path
+ */
+export async function buildParallelismSection(projectPath) {
+    if (process.env.AIWG_HIDE_PARALLELISM_IN_CONTEXT === '1')
+        return '';
+    const cfg = await readAiwgConfig(projectPath);
+    if (!cfg)
+        return '';
+    const primary = cfg.providers[0];
+    const resolved = resolveParallelism(cfg.parallelism, primary);
+    const providerDefaults = primary && PROVIDER_PARALLELISM_DEFAULTS[primary];
+    const isOverride = (field) => {
+        if (!providerDefaults)
+            return false;
+        if (field === 'rationale')
+            return false;
+        const def = providerDefaults[field];
+        return resolved[field] !== def;
+    };
+    const label = (field) => {
+        const value = resolved[field];
+        if (isOverride(field))
+            return `${value} (operator override)`;
+        if (primary)
+            return `${value} (provider default for ${primary})`;
+        return `${value} (conservative default — unknown provider)`;
+    };
+    const lines = [];
+    lines.push(PARALLELISM_BLOCK_START);
+    lines.push('## Parallelism Cap');
+    lines.push('');
+    lines.push('This project caps parallel agent fan-out (#1359):');
+    lines.push('');
+    lines.push(`- **max_parallel_subagents**: ${label('max_parallel_subagents')}`);
+    lines.push(`- **max_parallel_ralph_loops**: ${label('max_parallel_ralph_loops')}`);
+    lines.push(`- **max_parallel_mc_missions**: ${label('max_parallel_mc_missions')}`);
+    if (resolved.rationale) {
+        lines.push('');
+        lines.push(`*Rationale*: ${resolved.rationale}`);
+    }
+    lines.push('');
+    lines.push('When spawning parallel subagents, take the MIN of: this cap, `AIWG_CONTEXT_WINDOW` budget, the RLM 7-agent hard cap (RLM dispatches only), and the natural task decomposition. Bump via `aiwg config set --project parallelism.max_parallel_subagents N`.');
+    lines.push('');
+    lines.push(PARALLELISM_BLOCK_END);
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Replace an existing parallelism-cap block inside `content` (between the
+ * managed-block markers) with `newSection`. If no block exists yet, appends
+ * the new section. If `newSection` is empty (cap is hidden), strips any
+ * existing block in-place.
+ *
+ * Used by AIWG.md and AGENTS.md generators when reprocessing a file that
+ * already has a parallelism block from a prior regeneration.
+ */
+export function replaceOrAppendParallelismBlock(content, newSection) {
+    const startIdx = content.indexOf(PARALLELISM_BLOCK_START);
+    const endIdx = content.indexOf(PARALLELISM_BLOCK_END);
+    if (startIdx >= 0 && endIdx > startIdx) {
+        const before = content.slice(0, startIdx);
+        const after = content.slice(endIdx + PARALLELISM_BLOCK_END.length);
+        // Trim leading newline from `after` if present, since newSection ends with one
+        const cleanAfter = after.startsWith('\n') ? after.slice(1) : after;
+        return before + newSection + cleanAfter;
+    }
+    if (!newSection)
+        return content;
+    // No existing block — append before the final trailing newline
+    return content.trimEnd() + '\n\n' + newSection;
+}
+//# sourceMappingURL=parallelism-section.js.map

package/dist/src/smiths/context-pipeline/provider-policy.js

@@ -0,0 +1,64 @@
+/**
+ * Provider policy for AIWG.md, AGENTS.md, and CLAUDE.md hook emission.
+ *
+ * Per ADR-1 §3: AIWG.md is the cross-provider context entry point. Most
+ * providers reach it through AGENTS.md or a provider-native twin file
+ * (Hermes `.hermes.md`, Warp `WARP.md`). Claude Code reaches it through
+ * `CLAUDE.md` containing a `@AIWG.md` include — same pipeline, different
+ * link mechanism.
+ *
+ * Previous design (pre-#1437) bailed out entirely for the claude provider
+ * with the misleading rationale "claude uses CLAUDE.md natively." That
+ * conflated two facts: claude DOES read CLAUDE.md without aiwg-side
+ * wiring, but regenerate STILL needs to refresh AIWG.md and ensure the
+ * `@AIWG.md` link is present in CLAUDE.md. The fix splits the policy
+ * into three granular gates so each provider gets exactly what it needs.
+ *
+ * @issue #1437
+ */
+import { getProviderDefinition, listProviderDefinitions } from '../../providers/provider-definitions.js';
+/**
+ * Providers that receive AGENTS.md emission at project root.
+ *
+ * Sources kept in sync:
+ * - ADR-1 §3 default-on rollout (`.aiwg/architecture/adr-agents-md-aggregation.md`)
+ * - ADR-1 §4 per-provider variants table (file-name + twin-file emission)
+ */
+export const AGENTS_MD_PROVIDERS = new Set(listProviderDefinitions()
+    .filter((definition) => definition.paths.contextFiles.agentsMd)
+    .map((definition) => definition.id));
+/**
+ * Whether the context-pipeline has ANY work to do for this provider.
+ * Returns false only for providers that have no project-local context
+ * footprint: OpenClaw/OpenHuman (home-dir-only) and 'generic' (no specific provider).
+ *
+ * Claude returns TRUE — it needs AIWG.md + a CLAUDE.md hook update.
+ */
+export function shouldEmitContextFiles(provider) {
+    return shouldEmitAiwgMd(provider) || shouldEmitClaudeMdHook(provider);
+}
+/**
+ * Whether to emit AIWG.md at project root. True for every project-local
+ * provider; false only for home-dir-only providers and 'generic'.
+ */
+export function shouldEmitAiwgMd(provider) {
+    return getProviderDefinition(provider)?.paths.contextFiles.aiwgMd ?? false;
+}
+/**
+ * Whether to emit AGENTS.md at project root. True for the AGENTS-MD
+ * provider set (codex, copilot, cursor, windsurf, hermes, warp, factory,
+ * opencode). False for claude (uses CLAUDE.md hook instead), openclaw,
+ * and generic.
+ */
+export function shouldEmitAgentsMd(provider) {
+    return getProviderDefinition(provider)?.paths.contextFiles.agentsMd ?? false;
+}
+/**
+ * Whether to ensure the CLAUDE.md `@AIWG.md` hook is present. True only
+ * for the claude provider. CLAUDE.md gets a managed marker block with an
+ * `@AIWG.md` include; operator content outside the block is preserved.
+ */
+export function shouldEmitClaudeMdHook(provider) {
+    return getProviderDefinition(provider)?.paths.contextFiles.claudeMdHook ?? false;
+}
+//# sourceMappingURL=provider-policy.js.map

package/dist/src/smiths/context-pipeline/sanitizer.js

@@ -0,0 +1,93 @@
+/**
+ * Field sanitization for AGENTS.md link-index entries.
+ *
+ * Per ADR-1 §2: AGENTS.md is loaded into model context every session, so a poisoned
+ * link entry is a high-reach prompt-injection vector. The sanitizer rejects backticks,
+ * code fences, control characters, absolute URLs (any scheme except relative paths),
+ * and HTML at generation time, before the bytes are written.
+ *
+ * Description field is also length-capped at 120 chars.
+ */
+const DESCRIPTION_MAX_LEN = 120;
+const FORBIDDEN_PATTERNS = [
+    { pattern: /`/, reason: 'backtick' },
+    { pattern: /```/, reason: 'code fence' },
+    { pattern: /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/, reason: 'control character' },
+    { pattern: /<\s*[a-zA-Z][^>]*>/, reason: 'HTML tag' },
+    // Absolute URLs with schemes (http, https, file, ftp, etc.) — reject any scheme://
+    // Relative paths (./foo, foo/bar.md, ~/...) are allowed.
+    { pattern: /\b[a-zA-Z][a-zA-Z0-9+\-.]*:\/\//, reason: 'absolute URL' },
+];
+/**
+ * Sanitize a description field for the AGENTS.md link index.
+ *
+ * Returns `ok: false` with a `rejectedFor` reason when the input contains
+ * forbidden content. Caller decides whether to skip the entry or abort.
+ *
+ * On `ok: true`, the returned `value` is trimmed and length-capped.
+ */
+export function sanitizeDescription(input) {
+    if (typeof input !== 'string') {
+        return { ok: false, value: '', rejectedFor: 'non-string input' };
+    }
+    for (const { pattern, reason } of FORBIDDEN_PATTERNS) {
+        if (pattern.test(input)) {
+            return { ok: false, value: '', rejectedFor: reason };
+        }
+    }
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return { ok: false, value: '', rejectedFor: 'empty after trim' };
+    }
+    // Length-cap at 120 chars; truncate with ellipsis marker if needed.
+    const value = trimmed.length > DESCRIPTION_MAX_LEN
+        ? trimmed.slice(0, DESCRIPTION_MAX_LEN - 1).trimEnd() + '…'
+        : trimmed;
+    return { ok: true, value, rejectedFor: '' };
+}
+/**
+ * Sanitize a tag value. Tags are short identifiers (kebab-case typical).
+ * No length cap, but same forbidden-pattern set as description.
+ */
+export function sanitizeTag(input) {
+    if (typeof input !== 'string') {
+        return { ok: false, value: '', rejectedFor: 'non-string input' };
+    }
+    for (const { pattern, reason } of FORBIDDEN_PATTERNS) {
+        if (pattern.test(input)) {
+            return { ok: false, value: '', rejectedFor: reason };
+        }
+    }
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return { ok: false, value: '', rejectedFor: 'empty after trim' };
+    }
+    // Reject whitespace inside tags (kebab-case convention).
+    if (/\s/.test(trimmed)) {
+        return { ok: false, value: '', rejectedFor: 'whitespace in tag' };
+    }
+    return { ok: true, value: trimmed, rejectedFor: '' };
+}
+/**
+ * Convenience: sanitize an array of tags. Drops invalid tags rather than rejecting
+ * the whole array. Returns the kept tags and a list of rejection reasons for telemetry.
+ */
+export function sanitizeTags(inputs) {
+    const kept = [];
+    const rejected = [];
+    for (const input of inputs) {
+        const result = sanitizeTag(input);
+        if (result.ok) {
+            kept.push(result.value);
+        }
+        else {
+            rejected.push(`${input || '<empty>'}: ${result.rejectedFor}`);
+        }
+    }
+    return { kept, rejected };
+}
+export const SANITIZER_INTERNALS = {
+    DESCRIPTION_MAX_LEN,
+    FORBIDDEN_PATTERNS,
+};
+//# sourceMappingURL=sanitizer.js.map

package/dist/src/smiths/context-pipeline/types.js

@@ -0,0 +1,23 @@
+/**
+ * Type definitions for the context-pipeline module.
+ *
+ * The context-pipeline emits a canonical graph and provider adapters at the end of `aiwg use`:
+ *
+ * - WORKSPACE.md — provider-neutral project/operator context
+ * - AIWG.md      — generated framework context
+ * - provider startup files — minimal adapters that load WORKSPACE.md, then AIWG.md
+ *
+ * Per ADR-1 (.aiwg/architecture/adr-agents-md-aggregation.md). NOT part of agentsmith;
+ * agentsmith creates subagent personas, this module assembles cross-platform context.
+ */
+/**
+ * AIWG-wide brand defaults for the Codex `agents/openai.yaml` sidecar (PUW-028).
+ *
+ * Per ADR-1 signoff (2026-05-05): single brand identity for all skills.
+ * Per-category mapping is a follow-up if demand surfaces.
+ */
+export const AIWG_BRAND_DEFAULTS = {
+    icon: 'aiwg',
+    brandColor: '#0B5FFF',
+};
+//# sourceMappingURL=types.js.map