@aiwg/cli 2026.9.0 → 2026.9.2

package/dist/src/models/model-catalog.v1.json

@@ -52,6 +52,14 @@
       },
       "sourceUrl": "https://opencode.ai/docs/models", "verifiedAt": "2026-07-20"
     },
+    "pi": {
+      "roles": {
+        "reasoning": { "id": "configured/reasoning", "status": "unverified", "observed": false },
+        "coding": { "id": "configured/coding", "status": "unverified", "observed": false },
+        "efficiency": { "id": "configured/efficiency", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://github.com/earendil-works/pi/tree/main/packages/coding-agent#providers--models", "verifiedAt": "2026-09-04"
+    },
     "warp": {
       "roles": {
         "reasoning": { "id": "profile-selected", "status": "unverified", "observed": false },

package/dist/src/models/model-discovery.js

@@ -67,6 +67,13 @@ export const PROVIDER_DISCOVERY_DECISIONS = {
         reason: 'OpenHuman profiles accept semantic model hints but expose no standardized local model-list command.',
         documentation: 'https://github.com/roctinam/openhuman',
     },
+    pi: {
+        provider: 'pi',
+        status: 'native',
+        interface: 'pi --list-models',
+        reason: 'Pi exposes the configured provider/model catalog through a read-only non-interactive table.',
+        documentation: 'https://github.com/earendil-works/pi/tree/main/packages/coding-agent#cli-reference',
+    },
     warp: {
         provider: 'warp',
         status: 'unsupported',
@@ -161,6 +168,30 @@ export async function discoverOpenCodeModels(command = 'opencode', runner = runM
             : {}),
     };
 }
+export async function discoverPiModels(command = 'pi', runner = runModelDiscoveryCommand) {
+    const observedAt = new Date().toISOString();
+    const [version, result] = await Promise.all([
+        runtimeVersion(command, runner),
+        runner(command, ['--list-models'], { cwd: tmpdir(), timeoutMs: 15_000 }),
+    ]);
+    if (result.exitCode !== 0) {
+        const error = result.stderr.trim() || `Pi --list-models exited ${result.exitCode}`;
+        return { provider: 'pi', source: 'native', observedAt,
+            ...(version ? { runtimeVersion: version } : {}), accountScope: 'local-runtime',
+            models: [], errorKind: classifyDiscoveryError(error), error };
+    }
+    const lines = result.stdout.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+    const models = lines.slice(1).flatMap(line => {
+        const columns = line.split(/\s{2,}/);
+        if (columns.length < 2 || !/^[a-z0-9][a-z0-9._-]*$/i.test(columns[0]))
+            return [];
+        return [{ id: `${columns[0]}/${columns[1]}` }];
+    });
+    return { provider: 'pi', source: 'native', observedAt,
+        ...(version ? { runtimeVersion: version } : {}), accountScope: 'local-runtime', models,
+        ...(models.length === 0 ? { errorKind: 'invalid-output',
+            error: 'Pi returned no parseable provider/model rows.' } : {}) };
+}
 export async function discoverOpenClawModels(command = 'openclaw', runner = runModelDiscoveryCommand) {
     const observedAt = new Date().toISOString();
     const [version, result] = await Promise.all([
@@ -455,6 +486,7 @@ export async function resolveDynamicModelCatalog(options) {
         codex: () => discoverCodexModels(),
         opencode: () => discoverOpenCodeModels(),
         openclaw: () => discoverOpenClawModels(),
+        pi: () => discoverPiModels(),
     };
     const providerDiscovery = {};
     for (const provider of available) {

package/dist/src/models/provider-policy.js

@@ -27,7 +27,7 @@ const capabilityData = requireModelResource('model-capabilities.v1.json');
 const catalogData = requireModelResource('model-catalog.v1.json');
 const ProviderSchema = z.enum([
     'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
-    'opencode', 'openclaw', 'openhuman', 'warp', 'windsurf',
+    'opencode', 'openclaw', 'openhuman', 'pi', 'warp', 'windsurf',
 ]);
 const OutcomeSchema = z.enum([
     'native', 'compiled', 'inherited', 'global-only', 'informational', 'unsupported',
@@ -107,7 +107,7 @@ export function loadProviderModelCapabilities() {
         const expected = new Set(ProviderSchema.options);
         const actual = new Set(Object.keys(registryCache.providers));
         if (actual.size !== expected.size || [...expected].some(id => !actual.has(id))) {
-            throw new Error('Provider model capability registry must cover all 11 providers');
+            throw new Error('Provider model capability registry must cover all 12 providers');
         }
     }
     return registryCache;
@@ -159,6 +159,7 @@ function fieldNames(provider) {
         case 'copilot':
         case 'cursor':
         case 'opencode': return { model: 'model' };
+        case 'pi': return { model: 'model', effort: 'thinking' };
         case 'openhuman': return { model: 'model_hint' };
         case 'openclaw': return { model: 'subagents.model' };
         default: return {};

package/dist/src/output-modes/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './registry.js';
+export * from './runtime.js';
+//# sourceMappingURL=index.js.map

package/dist/src/output-modes/registry.js

@@ -1,23 +1,57 @@
 import { access, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
 import { constants } from 'node:fs';
-import { homedir, tmpdir } from 'node:os';
+import { tmpdir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { dirname, extname, join, resolve } from 'node:path';
 import { parse, stringify } from 'yaml';
+import { z } from 'zod';
+import { resolveUserConfigDir } from '../config/user-config-dir.mjs';
+const MODE_ID_PATTERN = /^[a-z0-9][a-z0-9.-]*$/;
 const PROTECTED = ['code', 'commands', 'citations', 'quoted-text', 'identifiers', 'machine-readable-blocks'];
 const STAGE_ORDER = ['semantic', 'voice', 'controlled-language', 'structure', 'presentation'];
+const modeIdSchema = z.string().regex(MODE_ID_PATTERN, 'must start with a lowercase letter or number and contain only lowercase letters, numbers, dots, or hyphens');
+const uniqueModeIds = z.array(modeIdSchema).refine(values => new Set(values).size === values.length, 'must not contain duplicates');
+const outputModeProfileSchema = z.object({
+    id: modeIdSchema,
+    version: z.string().min(1),
+    description: z.string().min(1),
+    kind: z.enum(['voice', 'controlled-language', 'structure', 'presentation']),
+    stage: z.enum(STAGE_ORDER),
+    order: z.number().int().optional(),
+    instructions: z.string(),
+    provenance: z.object({ source: z.string().min(1), license: z.string().min(1) }).strict(),
+    validation: z.object({
+        level: z.enum(['advisory', 'validated', 'conformance']),
+        hook: z.string().min(1).optional(),
+        standardVersion: z.string().min(1).optional(),
+    }).strict(),
+    compatible: uniqueModeIds.optional(),
+    conflicts: uniqueModeIds.optional(),
+    requires: uniqueModeIds.optional(),
+    supersedes: uniqueModeIds.optional(),
+    protectedContent: z.array(z.enum(PROTECTED)).refine(values => new Set(values).size === values.length, 'must not contain duplicates').optional(),
+    contextCost: z.number().int().nonnegative().optional(),
+    mergeStrategy: z.literal('weighted-voice').optional(),
+}).strict().superRefine((profile, ctx) => {
+    if (profile.validation.level !== 'advisory' && !profile.validation.hook) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['validation', 'hook'], message: `${profile.validation.level} modes require a validator hook` });
+    }
+    if (profile.validation.level === 'conformance' && !profile.validation.standardVersion) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['validation', 'standardVersion'], message: 'conformance modes require a standard version' });
+    }
+});
 const BUILTINS = [
     {
         id: 'unaltered', version: '1.0.0', description: 'No-op mode; preserves the provider output path unchanged.',
         kind: 'presentation', stage: 'presentation', order: -1000, instructions: '',
         provenance: { source: 'AIWG', license: 'MIT' }, validation: { level: 'advisory' }, contextCost: 0,
-        protectedContent: PROTECTED,
+        protectedContent: [...PROTECTED],
     },
     {
         id: 'wittgenstein-inspired', version: '1.0.0', description: 'Concise, proposition-oriented stylistic profile; not impersonation or attribution.',
         kind: 'voice', stage: 'voice', order: 100, instructions: 'Prefer concise propositions, clarify terms in use, and expose category errors. Do not imitate or attribute text to Ludwig Wittgenstein.',
         provenance: { source: 'AIWG original style guidance', license: 'MIT' }, validation: { level: 'advisory' }, contextCost: 48,
-        protectedContent: PROTECTED,
+        protectedContent: [...PROTECTED],
     },
     {
         id: 'asd-ste', version: '1.0.0', description: 'Operator-configured ASD Simplified Technical English adapter.',
@@ -25,13 +59,13 @@ const BUILTINS = [
         instructions: 'Apply only operator-supplied ASD-STE rules and approved terminology. Without licensed rules and a configured validator, describe output as advisory and never claim conformance.',
         provenance: { source: 'AIWG adapter; standard content supplied by operator', license: 'MIT adapter only' },
         validation: { level: 'advisory', standardVersion: 'operator-configured' }, contextCost: 64,
-        protectedContent: PROTECTED,
+        protectedContent: [...PROTECTED],
     },
 ];
 function profileDirs(cwd) {
     return [
         { dir: join(cwd, '.aiwg', 'output-modes'), source: 'project' },
-        { dir: join(homedir(), '.config', 'aiwg', 'output-modes'), source: 'user' },
+        { dir: join(resolveUserConfigDir(), 'output-modes'), source: 'user' },
     ];
 }
 async function readable(path) {
@@ -43,31 +77,33 @@ async function readable(path) {
         return false;
     }
 }
-function validateProfile(value, path) {
-    if (!value || typeof value !== 'object')
-        throw new Error(`Invalid output mode profile at ${path}: expected an object`);
-    const p = value;
-    for (const field of ['id', 'version', 'description', 'kind', 'stage', 'instructions', 'provenance', 'validation']) {
-        if (p[field] === undefined)
-            throw new Error(`Invalid output mode profile at ${path}: missing ${field}`);
+export function validateOutputModeProfile(value, path = '<profile>') {
+    const result = outputModeProfileSchema.safeParse(value);
+    if (!result.success) {
+        const details = result.error.issues
+            .map(issue => `${issue.path.length ? issue.path.join('.') : 'profile'}: ${issue.message}`)
+            .join('; ');
+        throw new Error(`Invalid output mode profile at ${path}: ${details}`);
     }
-    if (!['voice', 'controlled-language', 'structure', 'presentation'].includes(String(p.kind)))
-        throw new Error(`Invalid output mode kind in ${path}: ${p.kind}`);
-    if (!STAGE_ORDER.includes(String(p.stage)))
-        throw new Error(`Invalid output mode stage in ${path}: ${p.stage}`);
-    return p;
+    return result.data;
 }
 async function loadDirectory(dir, source) {
     if (!(await readable(dir)))
         return [];
     const result = [];
+    const seen = new Map();
     for (const name of (await readdir(dir)).sort()) {
         if (!['.yaml', '.yml', '.json'].includes(extname(name)))
             continue;
         const sourcePath = join(dir, name);
         const raw = await readFile(sourcePath, 'utf8');
         const value = extname(name) === '.json' ? JSON.parse(raw) : parse(raw);
-        result.push({ ...validateProfile(value, sourcePath), source, sourcePath });
+        const profile = validateOutputModeProfile(value, sourcePath);
+        const previous = seen.get(profile.id);
+        if (previous)
+            throw new Error(`Duplicate output mode '${profile.id}' in ${previous} and ${sourcePath}. Keep one definition per scope.`);
+        seen.set(profile.id, sourcePath);
+        result.push({ ...profile, source, sourcePath });
     }
     return result;
 }
@@ -84,7 +120,7 @@ async function loadVoiceAdapters(frameworkRoot) {
             id, version: String(voice.version ?? '1.0.0'), description: String(voice.description ?? `Adapted voice profile: ${id}`),
             kind: 'voice', stage: 'voice', order: 100, instructions: `Apply the existing voice profile '${id}' through voice-apply.`,
             provenance: { source: sourcePath, license: String(voice.license ?? 'project license') },
-            validation: { level: 'advisory' }, protectedContent: PROTECTED, contextCost: 32,
+            validation: { level: 'advisory' }, protectedContent: [...PROTECTED], contextCost: 32,
             mergeStrategy: 'weighted-voice', source: 'voice-adapter', sourcePath,
         });
     }
@@ -115,7 +151,10 @@ export async function readOutputModeState(cwd, scope) {
     if (!(await readable(path)))
         return { version: 1, modes: [] };
     const value = parse(await readFile(path, 'utf8'));
-    return { version: 1, modes: Array.isArray(value.modes) ? value.modes.map(String) : [] };
+    if (!value || value.version !== 1 || !Array.isArray(value.modes) || value.modes.some(mode => typeof mode !== 'string' || !MODE_ID_PATTERN.test(mode))) {
+        throw new Error(`Invalid output mode state at ${path}: expected version 1 and an array of valid mode IDs.`);
+    }
+    return { version: 1, modes: [...new Set(value.modes)] };
 }
 export async function writeOutputModeState(cwd, scope, modes) {
     const path = statePath(cwd, scope);
@@ -123,11 +162,16 @@ export async function writeOutputModeState(cwd, scope, modes) {
     await writeFile(path, stringify({ version: 1, modes }), 'utf8');
     return path;
 }
-export async function resolveOutputModes(cwd, frameworkRoot, invocation = []) {
+export async function resolveOutputModes(cwd, frameworkRoot, invocation = [], overrides = {}) {
     const registry = await loadOutputModeRegistry(cwd, frameworkRoot);
-    const project = await readOutputModeState(cwd, 'project');
-    const session = await readOutputModeState(cwd, 'session');
-    const selected = [...project.modes.map(id => ({ id, scope: 'project' })), ...session.modes.map(id => ({ id, scope: 'session' })), ...invocation.map(id => ({ id, scope: 'invocation' }))];
+    const project = overrides.project ?? (await readOutputModeState(cwd, 'project')).modes;
+    const session = overrides.session ?? (await readOutputModeState(cwd, 'session')).modes;
+    for (const [scope, modes] of [['project', project], ['session', session], ['invocation', invocation]]) {
+        if (!Array.isArray(modes) || modes.some(id => typeof id !== 'string' || !MODE_ID_PATTERN.test(id))) {
+            throw new Error(`Invalid ${scope} output mode selection: expected valid mode IDs.`);
+        }
+    }
+    const selected = [...project.map(id => ({ id, scope: 'project' })), ...session.map(id => ({ id, scope: 'session' })), ...invocation.map(id => ({ id, scope: 'invocation' }))];
     const effective = new Map();
     const diagnostics = [];
     for (const item of selected) {

package/dist/src/output-modes/runtime.js

@@ -16,8 +16,11 @@ function protectedPattern(classes) {
 function protect(content, classes) {
     const literals = [];
     const pattern = protectedPattern(classes);
+    let tokenPrefix = '\uE000AIWG_OUTPUT_MODE_';
+    while (content.includes(tokenPrefix))
+        tokenPrefix += '_';
     const protectedContent = pattern ? content.replace(pattern, value => {
-        const token = `\uE000${literals.length}\uE001`;
+        const token = `${tokenPrefix}${literals.length}\uE001`;
         literals.push({ token, value });
         return token;
     }) : content;
@@ -26,9 +29,10 @@ function protect(content, classes) {
 function restore(content, literals, mode) {
     let restored = content;
     for (const literal of literals) {
-        if (!restored.includes(literal.token))
-            throw new Error(`Output mode '${mode}' modified or removed a protected literal.`);
-        restored = restored.replaceAll(literal.token, literal.value);
+        const occurrences = restored.split(literal.token).length - 1;
+        if (occurrences !== 1)
+            throw new Error(`Output mode '${mode}' modified, removed, or duplicated a protected literal.`);
+        restored = restored.replace(literal.token, literal.value);
     }
     return restored;
 }
@@ -39,9 +43,10 @@ export async function applyOutputModes(input, modes, options) {
     const diagnostics = [];
     const applied = [];
     for (const mode of modes) {
-        const snapshot = content;
         const masked = protect(content, mode.protectedContent ?? []);
         const transformed = await options.transform(masked.content, mode);
+        if (typeof transformed !== 'string')
+            throw new Error(`Output mode '${mode.id}' transform returned a non-string result.`);
         content = restore(transformed, masked.literals, mode.id);
         if (mode.validation.level !== 'advisory') {
             if (!options.validate)
@@ -54,9 +59,6 @@ export async function applyOutputModes(input, modes, options) {
                 return { content: input, diagnostics, applied, fallback: 'unaltered' };
             }
         }
-        // A transform may only change semantic presentation, never return an absent result.
-        if (typeof content !== 'string')
-            content = snapshot;
         applied.push(mode.id);
     }
     return { content, diagnostics, applied, fallback: 'none' };

package/dist/src/plugin/skill-command-translator.js

@@ -38,6 +38,7 @@ const SKILLS_ONLY_PROVIDERS = new Set([
     'cursor',
     'hermes',
     'openhuman',
+    'pi',
 ]);
 /**
  * Check if a provider needs command files generated from skills.

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

@@ -470,6 +470,47 @@ providers:
     deploy_target: mixed
     aggregated_output: true
 
+  pi:
+    display_name: Pi Coding Agent
+    aliases:
+      - pi-coding-agent
+    status: experimental
+    daemon_tier: unsupported
+    daemon_pty_adapter: false
+    artifact_paths:
+      agents: .agents/skills/
+      commands: .pi/prompts/
+      skills: .pi/skills/
+      skills_cross_agent: .agents/skills/
+      rules: AGENTS.md
+      behaviors: .pi/extensions/
+    native_features:
+      cron: false
+      agent_teams: false
+      tasks: false
+      mcp: false
+      behaviors: true
+      mission_control: false
+      daemon: false
+    emulation:
+      cron: external-trigger
+      agent_teams: aiwg-mc
+      tasks: aiwg-mc
+      mcp: null
+      behaviors: null
+      mission_control: aiwg-mc
+      daemon: null
+    hook_wiring:
+      at_link_support: false
+      fallback: full-inject
+      context_file: AGENTS.md
+    interaction:
+      structured_questions: none
+      fallback: markdown
+      notes: Pi does not expose a built-in structured question tool.
+    deploy_target: project
+    aggregated_output: false
+
 # Feature definitions — documents what each feature key means and
 # what emulation strategies are available when native support is absent.
 features:

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

@@ -21,6 +21,7 @@ const ProviderDefinitionSchema = z.object({
         'opencode',
         'openclaw',
         'openhuman',
+        'pi',
         'warp',
         'windsurf',
         'generic',
@@ -131,6 +132,7 @@ export const PROVIDER_IDS = [
     'opencode',
     'openclaw',
     'openhuman',
+    'pi',
     'warp',
     'windsurf',
     'generic',
@@ -191,6 +193,17 @@ const CONTEXT_CONTRACTS = {
         bootstrapTargets: ['AGENTS.md'], maxContextBytes: null, recommendedMaxLines: null, nestedContext: false, support: 'degraded',
         verification: { method: 'AIWG mixed-scope adapter contract; host loading remains capability-dependent', source: 'agentic/code/providers/capability-matrix.yaml', lastVerified: VERIFIED_ON },
     },
+    pi: {
+        startupFiles: ['AGENTS.override.md', 'AGENTS.md', 'CLAUDE.md'],
+        precedence: ['provider/system', 'root-to-cwd context chain', 'AGENTS.override.md supersedes same-directory AGENTS.md and CLAUDE.md'],
+        loadMode: 'prose-directive', includeSyntax: null, configRegistration: null,
+        bootstrapTargets: ['AGENTS.md'], maxContextBytes: null, recommendedMaxLines: null, nestedContext: true, support: 'supported',
+        verification: {
+            method: 'Pi coding-agent resource loader and official README context-file documentation',
+            source: 'https://github.com/earendil-works/pi/blob/79680533c6b898894f2d2421c7f640b212d3dfdd/packages/coding-agent/README.md#context-files',
+            lastVerified: '2026-09-03',
+        },
+    },
     warp: {
         startupFiles: ['WARP.md', 'AGENTS.md'], precedence: ['provider/system', 'subdirectory rule', 'root rule', 'global rule'],
         loadMode: 'prose-directive', includeSyntax: null, configRegistration: null,
@@ -656,6 +669,65 @@ const BUILT_IN_SEEDS = [
         },
         matrixRef: 'openhuman',
     },
+    {
+        id: 'pi',
+        aliases: ['pi-coding-agent'],
+        builtIn: true,
+        surfaces: {
+            primary: 'pi',
+            compatibility: ['pi-coding-agent'],
+            precedence: ['AGENTS.override.md', 'AGENTS.md', '.agents/skills/', '.pi/skills/', '.pi/prompts/'],
+            related: [],
+        },
+        detection: {
+            // PI_CODING_AGENT_DIR only relocates configuration; it is deliberately
+            // not an active-runtime marker. Availability is proven by process or executable.
+            env: [],
+            process: ['pi'],
+            capabilityId: 'pi',
+        },
+        paths: {
+            artifacts: {
+                agents: '.agents/skills',
+                commands: '.pi/prompts',
+                skills: '.pi/.aiwg/skills',
+                rules: null,
+                behaviors: '.pi/extensions',
+            },
+            kernelSkills: '.agents/skills',
+            contextDiscovery: {
+                agents: '.agents/skills',
+                skills: '.agents/skills',
+                rules: null,
+                behaviors: '.pi/extensions',
+            },
+            configFile: 'AGENTS.md',
+            contextFiles: { aiwgMd: true, agentsMd: true, claudeMdHook: false, hookFile: null, contextFile: 'AGENTS.md' },
+        },
+        smithPaths: {
+            agents: '.agents/skills',
+            commands: '.pi/prompts',
+            skills: '.pi/skills',
+            rules: null,
+            fileExtension: '.md',
+            configFile: 'AGENTS.md',
+            aggregated: false,
+        },
+        skillNamespace: {
+            deploymentGroup: 'deep-recursion',
+            pathType: 'project',
+            skillsBaseDir: '.pi/skills',
+            subdirLayout: true,
+        },
+        adapters: {
+            agentFormat: 'agents-md',
+            hookBridge: null,
+            mcpInjection: null,
+            contextAggregation: 'agents-md',
+            ruleFormat: 'agents-md-section',
+        },
+        matrixRef: 'pi',
+    },
     {
         id: 'warp',
         aliases: [],

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

@@ -14,6 +14,7 @@ const PROVIDER_EXECUTABLES = {
     opencode: ['opencode'],
     openclaw: ['openclaw'],
     openhuman: ['openhuman'],
+    pi: ['pi'],
     warp: ['warp'],
     windsurf: ['windsurf'],
 };