@aiwg/cli 2026.8.7 → 2026.8.10

package/dist/src/extensions/project-quickref.js

@@ -7,13 +7,15 @@
  */
 import { createHash } from 'crypto';
 import { access, mkdir, readFile, readdir, rm, writeFile } from 'fs/promises';
-import { dirname, isAbsolute, join, resolve } from 'path';
+import { basename, dirname, isAbsolute, join, resolve } from 'path';
 import { homedir } from 'os';
 import { z } from 'zod';
 import { getProviderDefinition, normalizeProviderDefinitionId, } from '../providers/provider-definitions.js';
 import { OPERATIONAL_SHOW_TYPES } from '../artifacts/types.js';
 import { projectAiwgPath } from '../config/project-artifacts.js';
 import { appendAiwgSourceTrackBlock } from './project-local-gitignore.js';
+import { discoverProjectLocalBundles } from './project-local-discovery.js';
+import { enumerateBundleArtifacts } from './shadow-resolver.js';
 const OWNERSHIP_MARKER = '.aiwg-project-quickref.json';
 const ShowHintSchema = z.object({
     type: z.enum(OPERATIONAL_SHOW_TYPES),
@@ -35,6 +37,25 @@ export const ProjectQuickrefSchema = z.object({
     precedence: z.string().min(1).max(1024),
     entries: z.array(QuickrefEntrySchema).min(1).max(50),
 }).strict();
+const QuickrefOverrideSchema = z.object({
+    title: z.string().min(1).max(128).optional(),
+    summary: z.string().min(1).max(512).optional(),
+    discover: z.array(z.string().min(1).max(256)).max(10).optional(),
+    show: z.array(ShowHintSchema).max(20).optional(),
+    hidden: z.boolean().optional(),
+    order: z.number().int().optional(),
+}).strict();
+export const ProjectQuickrefConfigSchema = z.object({
+    version: z.literal('1'),
+    project: ProjectQuickrefSchema.shape.project.optional(),
+    precedence: z.string().min(1).max(1024).optional(),
+    entries: z.array(QuickrefEntrySchema).max(50).default([]),
+    discovery: z.object({
+        enabled: z.boolean().default(true),
+        excludeBundles: z.array(z.string().min(1)).max(200).default([]),
+        overrides: z.record(z.string(), QuickrefOverrideSchema).default({}),
+    }).strict().default({ enabled: true, excludeBundles: [], overrides: {} }),
+}).strict();
 function sha256(content) {
     return createHash('sha256').update(content).digest('hex');
 }
@@ -78,6 +99,158 @@ export async function loadProjectQuickref(projectDir) {
         return { sourcePath, errors: [`${sourcePath}: invalid JSON: ${error.message}`], exists: true };
     }
 }
+function slug(value) {
+    const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+    return normalized || 'project';
+}
+async function inferredProject(projectDir) {
+    let packageName = basename(resolve(projectDir));
+    let description = `Managed project-specific orientation for ${packageName}.`;
+    try {
+        const parsed = JSON.parse(await readFile(join(projectDir, 'package.json'), 'utf8'));
+        if (parsed.name)
+            packageName = parsed.name;
+        if (parsed.description)
+            description = parsed.description.slice(0, 512);
+    }
+    catch {
+        // package metadata is optional
+    }
+    const id = slug(packageName);
+    const name = packageName
+        .replace(/^@[^/]+\//, '')
+        .split(/[-_]/)
+        .filter(Boolean)
+        .map(part => part[0]?.toUpperCase() + part.slice(1))
+        .join(' ') || 'Project';
+    return { id, name, description };
+}
+async function loadManagedConfig(projectDir) {
+    const path = projectAiwgPath(projectDir, 'quickref.config.json');
+    const raw = await readIfPresent(path);
+    if (raw === null)
+        return { path };
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`${path}: invalid JSON: ${error.message}`);
+    }
+    const parsed = ProjectQuickrefConfigSchema.safeParse(json);
+    if (!parsed.success) {
+        throw new Error(parsed.error.issues.map(issue => `${path}: ${issue.path.join('.') || '(root)'}: ${issue.message}`).join('\n'));
+    }
+    return { path, config: parsed.data };
+}
+function dedupe(values) {
+    const seen = new Set();
+    return values.filter(value => {
+        const key = value.trim().toLowerCase();
+        if (!key || seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function dedupeShow(values) {
+    const seen = new Set();
+    return values.filter(value => {
+        const key = `${value.type}:${value.name.toLowerCase()}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/** Resolve legacy operator input or synthesize a managed definition from project-local bundles. */
+export async function resolveProjectQuickref(projectDir) {
+    const legacy = await loadProjectQuickref(projectDir);
+    if (legacy.exists) {
+        if (!legacy.definition)
+            throw new Error(legacy.errors.join('\n'));
+        return {
+            definition: legacy.definition,
+            exists: true,
+            sourcePath: legacy.sourcePath,
+            provenance: 'legacy',
+            warnings: [],
+        };
+    }
+    const managed = await loadManagedConfig(projectDir);
+    const discovery = await discoverProjectLocalBundles(projectDir);
+    if (discovery.errors.length > 0) {
+        throw new Error(discovery.errors.map(error => `${error.path}: ${error.field}: ${error.actual}`).join('\n'));
+    }
+    if (!managed.config && discovery.bundles.length === 0) {
+        return { exists: false, sourcePath: managed.path, provenance: 'managed', warnings: [] };
+    }
+    const config = managed.config ?? ProjectQuickrefConfigSchema.parse({ version: '1' });
+    const excluded = new Set(config.discovery.excludeBundles.map(id => id.toLowerCase()));
+    const warnings = [];
+    const candidates = [];
+    if (config.discovery.enabled) {
+        for (const bundle of discovery.bundles) {
+            if (excluded.has(bundle.id.toLowerCase()))
+                continue;
+            const override = config.discovery.overrides[bundle.id];
+            if (override?.hidden)
+                continue;
+            const artifacts = (await enumerateBundleArtifacts(bundle.artifactPath ?? bundle.bundlePath))
+                .sort((a, b) => a.type.localeCompare(b.type) || a.id.localeCompare(b.id));
+            const inferredShow = dedupeShow(artifacts.map(artifact => ({
+                type: artifact.type,
+                name: artifact.id,
+            }))).slice(0, 8);
+            if (artifacts.length > inferredShow.length && inferredShow.length === 8) {
+                warnings.push(`${bundle.id}: show hints truncated from ${artifacts.length} artifacts to 8`);
+            }
+            let discover = override?.discover ?? dedupe([
+                bundle.id,
+                bundle.manifest.name,
+                ...(bundle.manifest.keywords ?? []),
+            ]).slice(0, 3);
+            const show = override?.show ? dedupeShow(override.show) : inferredShow;
+            if (discover.length === 0 && show.length === 0)
+                discover = [bundle.id];
+            candidates.push({
+                order: override?.order ?? 0,
+                type: bundle.type,
+                id: bundle.id,
+                entry: {
+                    title: override?.title ?? bundle.manifest.name,
+                    summary: override?.summary ?? bundle.manifest.description,
+                    discover,
+                    show,
+                },
+            });
+        }
+    }
+    candidates.sort((a, b) => a.order - b.order || a.type.localeCompare(b.type) || a.id.localeCompare(b.id));
+    const discoveredEntries = candidates.map(candidate => candidate.entry);
+    const entries = [...discoveredEntries, ...config.entries];
+    if (entries.length > 50)
+        warnings.push(`quickref entries truncated from ${entries.length} to 50`);
+    const bounded = entries.slice(0, 50);
+    if (bounded.length === 0) {
+        return { exists: false, sourcePath: managed.path, provenance: 'managed', warnings };
+    }
+    return {
+        definition: {
+            version: '1',
+            project: config.project ?? await inferredProject(projectDir),
+            precedence: config.precedence ?? 'Use project-local capabilities before generic AIWG workflows when they apply.',
+            entries: bounded,
+        },
+        exists: true,
+        sourcePath: managed.path,
+        provenance: 'managed',
+        warnings,
+    };
+}
+export async function hasProjectQuickref(projectDir) {
+    return (await resolveProjectQuickref(projectDir)).exists;
+}
 export function renderProjectQuickref(definition) {
     const skillName = projectQuickrefSkillName(definition.project.id);
     const lines = [
@@ -111,11 +284,9 @@ export function renderProjectQuickref(definition) {
     return lines.join('\n');
 }
 export async function generateProjectQuickref(projectDir, options = {}) {
-    const loaded = await loadProjectQuickref(projectDir);
-    if (!loaded.exists)
+    const loaded = await resolveProjectQuickref(projectDir);
+    if (!loaded.exists || !loaded.definition)
         throw new Error(`Project quickref source not found: ${loaded.sourcePath}`);
-    if (!loaded.definition)
-        throw new Error(loaded.errors.join('\n'));
     if (!options.dryRun)
         await appendAiwgSourceTrackBlock(projectDir);
     const skillName = projectQuickrefSkillName(loaded.definition.project.id);
@@ -127,6 +298,14 @@ export async function generateProjectQuickref(projectDir, options = {}) {
         await mkdir(dirname(outputPath), { recursive: true });
         await writeFile(outputPath, content, 'utf8');
     }
+    if (!options.dryRun && loaded.provenance === 'managed') {
+        const snapshotPath = projectAiwgPath(projectDir, 'generated', 'project-quickref', 'definition.json');
+        const snapshot = JSON.stringify(loaded.definition, null, 2) + '\n';
+        if (await readIfPresent(snapshotPath) !== snapshot) {
+            await mkdir(dirname(snapshotPath), { recursive: true });
+            await writeFile(snapshotPath, snapshot, 'utf8');
+        }
+    }
     if (!options.dryRun) {
         const generatedRoot = projectAiwgPath(projectDir, 'generated', 'project-quickref');
         try {
@@ -149,6 +328,8 @@ export async function generateProjectQuickref(projectDir, options = {}) {
         content,
         changed,
         dryRun: options.dryRun ?? false,
+        provenance: loaded.provenance,
+        warnings: loaded.warnings,
     };
 }
 function resolveProviderSkillsRoot(provider, projectDir, homeDir) {
@@ -206,9 +387,9 @@ async function findStaleOwnedQuickrefs(root, projectDir, keepName, global) {
 }
 export async function deployProjectQuickref(projectDir, provider, options = {}) {
     const generated = await generateProjectQuickref(projectDir, { dryRun: options.dryRun });
-    const loaded = await loadProjectQuickref(projectDir);
+    const loaded = await resolveProjectQuickref(projectDir);
     if (!loaded.definition)
-        throw new Error(loaded.errors.join('\n'));
+        throw new Error(`Project quickref source not found: ${loaded.sourcePath}`);
     const target = resolveProviderSkillsRoot(provider, projectDir, options.homeDir ?? homedir());
     const targetDir = join(target.root, generated.skillName);
     const targetPath = join(targetDir, 'SKILL.md');
@@ -259,11 +440,17 @@ export async function deployProjectQuickref(projectDir, provider, options = {})
     };
 }
 export async function auditProjectQuickref(projectDir, providers, options = {}) {
-    const loaded = await loadProjectQuickref(projectDir);
+    let loaded;
+    try {
+        loaded = await resolveProjectQuickref(projectDir);
+    }
+    catch (error) {
+        return { exists: true, errors: [error.message], drift: [] };
+    }
     if (!loaded.exists)
-        return { exists: false, errors: loaded.errors, drift: [] };
+        return { exists: false, errors: [], drift: [] };
     if (!loaded.definition)
-        return { exists: true, errors: loaded.errors, drift: [] };
+        return { exists: true, errors: ['project quickref definition unavailable'], drift: [] };
     const content = renderProjectQuickref(loaded.definition);
     const skillName = projectQuickrefSkillName(loaded.definition.project.id);
     const generatedPath = projectAiwgPath(projectDir, 'generated', 'project-quickref', skillName, 'SKILL.md');

package/dist/src/features/catalog.js

@@ -70,6 +70,32 @@ export const FEATURE_CATALOG = [
         ],
         cost: '~3 MB — pure JS, no native deps',
     },
+    {
+        name: 'graph',
+        description: 'Graphology backend for rich artifact traversal and graph operators',
+        packages: ['graphology', 'graphology-operators', 'graphology-traversal'],
+        packageSpecs: {
+            graphology: '0.26.0',
+            'graphology-operators': '1.6.0',
+            'graphology-traversal': '0.3.0',
+        },
+        enables: [
+            'index.graphBackend: graphology',
+            'in-memory attributed graph traversal and operator workflows',
+        ],
+        cost: '~2 MB — pure JS, no native deps',
+    },
+    {
+        name: 'terminal',
+        description: 'Headless terminal state parsing for PTY orchestration and auditing',
+        packages: ['@xterm/headless'],
+        packageSpecs: { '@xterm/headless': '6.0.0' },
+        enables: [
+            'structured screen-state parsing for PTY orchestrators',
+            'auditable terminal snapshots without a browser DOM',
+        ],
+        cost: '~1 MB — pure JS, no native deps',
+    },
 ];
 /** Native packages require a successful runtime load, not just package files. */
 export const NATIVE_FEATURE_PACKAGES = new Set(FEATURE_CATALOG.flatMap(feature => feature.scriptPackages ?? []));

package/dist/src/features/cli.js

@@ -29,9 +29,7 @@ export async function main(args) {
         case 'remove':
             console.error(`Error: \`aiwg features ${subcommand}\` not yet implemented (#1219 Cycle 3).`);
             console.error('');
-            console.error('To install manually for now:');
-            console.error('  cd <aiwg install root>');
-            console.error('  npm install <packages>     # see `aiwg features info <name>` for the package list');
+            console.error('No files were changed. Feature removal must use a future AIWG CLI release.');
             process.exit(1);
             break;
         case 'help':

package/dist/src/features/runtime.js

@@ -11,7 +11,23 @@ export async function loadFeaturePackage(name) {
     }
     catch (featureError) {
         try {
-            return await (new Function('m', 'return import(m)'))(name);
+            const resolved = createRequire(import.meta.url).resolve(name);
+            return await import(pathToFileURL(resolved).href);
+        }
+        catch {
+            throw featureError;
+        }
+    }
+}
+/** Synchronous counterpart for optional CommonJS packages used by constructors. */
+export function requireFeaturePackage(name) {
+    const featureRequire = createRequire(path.join(getFeaturesRoot(), 'package.json'));
+    try {
+        return featureRequire(name);
+    }
+    catch (featureError) {
+        try {
+            return createRequire(import.meta.url)(name);
         }
         catch {
             throw featureError;

package/dist/src/issues/cli.js

@@ -8,6 +8,10 @@
  * @issue #1462
  */
 import { readFile, writeFile } from 'fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getFrameworkRoot } from '../channel/manager.mjs';
+import { readAiwgConfig } from '../config/aiwg-config.js';
 import { LocalIssueProviderCore, buildExternalIssueSnapshotFromLocal, buildLocalIssueConflictReport, createLiveIssueClient, localIssueRoot, parseCommentIdMappings, parseExternalIssueSnapshot, } from './index.js';
 export async function main(args, cwd = process.cwd()) {
     const parsed = parseArgs(args);
@@ -27,7 +31,11 @@ export async function main(args, cwd = process.cwd()) {
             return;
         case 'new':
         case 'create':
-            await handleNew(issues, parsed);
+            await handleNew(issues, parsed, cwd);
+            return;
+        case 'plan':
+        case 'draft-plan':
+            await handlePlan(parsed, cwd);
             return;
         case 'list':
         case 'ls':
@@ -68,12 +76,19 @@ async function handleInit(issues, args) {
     });
     printJsonOrText(args, config, `Initialized local issues with prefix ${config.issue_key.prefix}`);
 }
-async function handleNew(issues, args) {
+async function loadIssueComposer() {
+    const frameworkRoot = await getFrameworkRoot();
+    const modulePath = path.join(frameworkRoot, 'tools', 'issues', 'policy-boundary-composer.mjs');
+    return import(pathToFileURL(modulePath).href);
+}
+async function buildIssuePlan(args, cwd) {
     const title = stringFlag(args, 'title') ?? args.positional[1];
     if (!title)
-        throw new Error('Usage: aiwg issue new --title <title> [--body <text>|--body-file <path>]');
+        throw new Error('Usage: aiwg issue plan --title <title> [--body <text>|--body-file <path>]');
     const body = await readBody(args);
-    const issue = await issues.createIssue({
+    const config = await readAiwgConfig(cwd);
+    const composer = await loadIssueComposer();
+    return composer.planIssueDraft({
         title,
         body,
         type: stringFlag(args, 'type'),
@@ -81,8 +96,76 @@ async function handleNew(issues, args) {
         labels: csvFlag(args, 'label'),
         assignees: csvFlag(args, 'assignee'),
         author: stringFlag(args, 'author'),
-    });
-    printJsonOrText(args, issue, `Created ${issue.fields.id}: ${issue.fields.title}`);
+    }, { threatAssessment: config?.security?.threatAssessment });
+}
+async function handlePlan(args, cwd) {
+    const plan = await buildIssuePlan(args, cwd);
+    console.log(JSON.stringify(plan, null, 2));
+}
+async function handleNew(issues, args, cwd) {
+    const plan = await buildIssuePlan(args, cwd);
+    if (plan.disposition === 'blocked') {
+        throw new Error(`Issue draft rejected by ${plan.blockingRule}; no issue was written. Run aiwg issue plan to inspect suggested segments.`);
+    }
+    const authorizationDigest = stringFlag(args, 'authorize-policy');
+    if (plan.authorizationRequired && authorizationDigest !== plan.digest) {
+        throw new Error(`Issue draft requires explicit policy authorization. Review 'aiwg issue plan', then pass --authorize-policy ${plan.digest}. No issue was written.`);
+    }
+    const composer = await loadIssueComposer();
+    const records = new Map();
+    const adapter = {
+        async findByMarker(marker) {
+            const listed = await issues.listIssues({ limit: 10_000 });
+            for (const entry of listed.issues) {
+                const record = await issues.getIssue(entry.id, { body: true, comments: 0 });
+                if (record.body.includes(marker)) {
+                    records.set(record.fields.id, record);
+                    return { id: record.fields.id, reference: record.fields.id, body: record.body };
+                }
+            }
+            return null;
+        },
+        async create(draft) {
+            const record = await issues.createIssue({
+                title: draft.title,
+                body: draft.body,
+                type: stringFlag(args, 'type'),
+                priority: stringFlag(args, 'priority'),
+                labels: draft.labels,
+                assignees: draft.assignees,
+                author: stringFlag(args, 'author'),
+            });
+            records.set(record.fields.id, record);
+            return { id: record.fields.id, reference: record.fields.id, body: record.body };
+        },
+        async update(issue, patch) {
+            const record = records.get(issue.id) ?? await issues.getIssue(issue.id, { body: true, comments: 0 });
+            const references = [...patch.body.matchAll(/(?:Depends on|Related):\s+([A-Z][A-Z0-9_-]*-\d+)/g)]
+                .map((match) => match[1])
+                .filter((reference) => reference !== issue.id);
+            await issues.updateIssueFields(issue.id, {
+                links: {
+                    ...record.fields.links,
+                    related: [...new Set([...record.fields.links.related, ...references])],
+                    parent: patch.body.match(/Depends on:\s+([A-Z][A-Z0-9_-]*-\d+)/)?.[1] ?? record.fields.links.parent,
+                },
+            });
+            await issues.commentIssue(issue.id, patch.body.slice(patch.body.indexOf('## Related')), {
+                author: stringFlag(args, 'author') ?? 'aiwg',
+            });
+        },
+    };
+    const result = await composer.executeIssuePlan(plan, adapter, { authorizationDigest });
+    if (result.status !== 'created') {
+        throw new Error(`Issue creation ${result.status}: ${result.error ?? 'review the recovery envelope'}\n${JSON.stringify(result.recovery ?? result, null, 2)}`);
+    }
+    if (args.flags.has('json') || result.created.length > 1) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        const issue = result.created[0];
+        console.log(`Created ${issue.reference}: ${plan.segments[0].title}`);
+    }
 }
 async function handleList(issues, args) {
     const limit = stringFlag(args, 'limit');
@@ -313,7 +396,8 @@ function csvFlag(args, name) {
 function printUsage() {
     console.log(`Usage:
   aiwg issue init [--prefix KEY] [--padding N]
-  aiwg issue new --title "..." [--body "..."] [--body-file path]
+  aiwg issue plan --title "..." [--body "..."] [--body-file path] [--json]
+  aiwg issue new --title "..." [--body "..."] [--body-file path] [--authorize-policy DIGEST]
   aiwg issue list [--status open] [--label bug] [--search text] [--limit 20] [--json]
   aiwg issue show <KEY> [--comments last:10|all]
   aiwg issue import --from gitea|github --snapshot-file path [--json]

package/dist/src/mcp/server.mjs

@@ -7,7 +7,7 @@
  * @see https://modelcontextprotocol.io/specification/2025-11-25
  * @architecture @.aiwg/architecture/software-architecture-doc.md - Section 2.1 CLI Layer
  * @reference @docs/references/REF-066-mcp-specification-2025.md
- * @cli @docs/CLI_USAGE.md - mcp serve command
+ * @cli @docs/cli/agent-usage.md - mcp serve command
  * @frameworks @agentic/code/frameworks/sdlc-complete/
  * @frameworks @agentic/code/frameworks/media-marketing-kit/
  */

package/dist/src/ops/registry.js

@@ -13,7 +13,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { execSync } from 'child_process';
 import { resolveConfigDir } from '../config/user-config.js';
 import { resolveWorkspace } from '../config/workspace.js';
-import { projectAiwgPath } from '../config/project-artifacts.js';
+import { projectControlPath } from '../config/project-artifacts.js';
 /**
  * Extension type abbreviations
  */
@@ -455,7 +455,7 @@ export class OpsRegistry {
             throw new Error(`Workspace "${name}" not found`);
         }
         let canonical = null;
-        const canonicalConfigPath = projectAiwgPath(workspace.home, 'aiwg.config');
+        const canonicalConfigPath = projectControlPath(workspace.home, 'aiwg.config');
         let canonicalDeclared = false;
         if (existsSync(canonicalConfigPath)) {
             try {

package/dist/src/policy/authorization.js

@@ -9,7 +9,7 @@
 import { access, copyFile, mkdir, readFile, rename } from 'node:fs/promises';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { load as loadYaml } from 'js-yaml';
-import { projectAiwgPath } from '../config/project-artifacts.js';
+import { projectAiwgPath, projectControlPath } from '../config/project-artifacts.js';
 /**
  * Export provider mappings without inventing provider grants. Stable IDs,
  * principals, scopes, resources, actions, and conditions survive unchanged;
@@ -375,7 +375,7 @@ export async function archiveLegacyPermissionManifests(projectDir) {
     return archived;
 }
 export async function backupConfig(projectDir) {
-    const source = projectAiwgPath(projectDir, 'aiwg.config');
+    const source = projectControlPath(projectDir, 'aiwg.config');
     const backupDir = projectAiwgPath(projectDir, 'backups');
     await mkdir(backupDir, { recursive: true });
     const content = await readFile(source);

package/dist/src/providers/capability-matrix.yaml

@@ -323,9 +323,9 @@ providers:
     aggregated_output: true
 
   windsurf:
-    display_name: Windsurf
-    status: experimental
-    # Windsurf is an IDE extension requiring VS Code host — daemon not supported
+    display_name: Devin Desktop
+    status: stable
+    # Devin Desktop uses the Windsurf compatibility surface and requires a VS Code host — daemon not supported
     daemon_tier: unsupported
     daemon_pty_adapter: false
     artifact_paths:

package/dist/src/providers/provider-definitions.js

@@ -704,11 +704,13 @@ const BUILT_IN_SEEDS = [
     },
     {
         id: 'windsurf',
-        aliases: ['devin-desktop', 'devin-local', 'cascade'],
+        displayName: 'Devin Desktop',
+        status: 'stable',
+        aliases: ['devin', 'devin-desktop', 'devin-local', 'cascade'],
         builtIn: true,
         surfaces: {
-            primary: 'windsurf',
-            compatibility: ['devin-desktop', 'devin-local', 'cascade'],
+            primary: 'devin',
+            compatibility: ['devin-desktop', 'windsurf', 'devin-local', 'cascade'],
             precedence: ['.devin/rules/', '.windsurf/rules/', 'AGENTS.md', '.windsurfrules'],
             related: [
                 {
@@ -716,7 +718,7 @@ const BUILT_IN_SEEDS = [
                     displayName: 'Devin Desktop',
                     relationship: 'same-provider',
                     deployable: true,
-                    aliases: ['windsurf', 'cascade'],
+                    aliases: ['devin', 'windsurf', 'cascade'],
                     paths: {
                         rules: ['.devin/rules/*.md', '.windsurf/rules/*.md'],
                         skills: [],
@@ -724,7 +726,7 @@ const BUILT_IN_SEEDS = [
                         legacy: ['.windsurfrules'],
                     },
                     notes: [
-                        'Devin Desktop is the renamed Windsurf local IDE surface; --provider windsurf remains the deployable compatibility id.',
+                        'Devin Desktop is the current product name; --provider devin is preferred and --provider windsurf remains a deprecated compatibility id.',
                         '.devin/rules is preferred by Devin Desktop, but AIWG keeps .devin/ as ignored local provider output and currently emits the compatibility surface through .windsurf/ plus AGENTS.md.',
                     ],
                 },

package/dist/src/providers/provider-definitions.mjs

@@ -70,7 +70,7 @@ const MCP_INJECTION_DEFINITIONS = [
   },
   {
     id: 'windsurf',
-    aliases: ['devin-desktop'],
+    aliases: ['devin', 'devin-desktop', 'devin-local', 'cascade'],
     mcp: {
       providerId: 'windsurf',
       includeInSupportedProviders: true,

package/dist/src/serve/pty-bridge.js

@@ -288,16 +288,10 @@ async function spawnSandboxWsPty(session, agentId, wsEndpoint, opts) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let wsMod;
     try {
-        wsMod = await (new Function('m', 'return import(m)'))('ws');
+        wsMod = await loadFeaturePackage('ws');
     }
     catch {
-        try {
-            // @ts-expect-error Optional runtime dependency; this workspace does not ship @types/ws.
-            wsMod = await import('ws');
-        }
-        catch {
-            throw new Error('ws package required for sandbox PTY bridge. Run: npm install ws');
-        }
+        throw new Error('WebSocket support is required for the sandbox PTY bridge; run `aiwg features install webserver`');
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const WS = wsMod.WebSocket ?? wsMod.default?.WebSocket ?? wsMod.default;

package/dist/src/serve/screen-reader.js

@@ -10,15 +10,12 @@
  * @see src/serve/pty-bridge.ts — PTY WebSocket bridge
  */
 import { EventEmitter } from 'events';
-import { createRequire } from 'module';
-// @xterm/headless is an optional dependency. Load it once at module level
-// using createRequire so we can import the CJS bundle from ESM.
-const _require = createRequire(import.meta.url);
+import { requireFeaturePackage } from '../features/runtime.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let XtermTerminal;
 try {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const xterm = _require('@xterm/headless');
+    const xterm = requireFeaturePackage('@xterm/headless');
     XtermTerminal = xterm.Terminal;
 }
 catch {
@@ -48,7 +45,7 @@ export class ScreenReader {
     disposed = false;
     constructor(opts) {
         if (!XtermTerminal) {
-            throw new Error('@xterm/headless is required for ScreenReader. Install it: npm install @xterm/headless');
+            throw new Error('Terminal screen parsing is unavailable; run `aiwg features install terminal`');
         }
         this._rows = opts?.rows ?? 24;
         this._cols = opts?.cols ?? 80;

package/dist/src/smiths/context-pipeline/aiwg-md.js

@@ -16,7 +16,7 @@
  */
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
-import { projectAiwgPath } from '../../config/project-artifacts.js';
+import { projectControlPath } from '../../config/project-artifacts.js';
 import { buildParallelismSection, replaceOrAppendParallelismBlock } from './parallelism-section.js';
 import { buildContextFinalizationBlock, replaceOrAppendFinalizationBlock } from './finalization.js';
 import { buildExternalLinksSection, replaceOrAppendExternalLinksBlock, } from './external-links-section.js';
@@ -79,7 +79,7 @@ export async function buildAiwgMdContent(projectPath, stagedClaudeMdContent) {
         return replaceOrAppendExternalLinksBlock(withFinalization, externalLinksSection);
     }
     // Fallback stub.
-    const normalizedPath = projectAiwgPath(projectPath, 'AIWG.md');
+    const normalizedPath = projectControlPath(projectPath, 'AIWG.md');
     const normalizedRelative = path.relative(projectPath, normalizedPath).replace(/\\/g, '/');
     const normalizedLink = normalizedRelative.startsWith('.') ? normalizedRelative : `./${normalizedRelative}`;
     const stub = [