peaks-loop 4.0.8 → 4.0.9

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 4.0.9 — 2026-08-04 (statusline-marquee)
+
+**statusline: brand purple + scan-band marquee + NO_COLOR support.**
+
+- **Brand-purple surface.** Every brand token now carries the `#5A65D8` ANSI SGR — bar filled/empty, skill name, mode token, separator, trail arrow, idleLabel, invalidMessage. Warning and failed glyphs stay in semantic amber/red (they are alarms, not brand colour) and are untouched.
+- **Scan-band marquee.** A 5-cell wide bright-grey (`#E0E0E0`) highlight band sweeps left→right→left across the status line on a 2 s round trip. The band re-paints the foreground of cells inside its range and resets cells outside via `\x1b[0m`. SGR 7 (reverse video) is deliberately NOT used — it would invert the background and read as a solid white block. The marquee is OFF when `state === 'idle'`: idle keeps the slow-blink `○` as the only motion; the scan band would compete for attention and obscure the "is a skill running?" question.
+- **NO_COLOR support.** `peaks statusline` now reads `NO_COLOR` (the cross-industry https://no-color.org signal) and suppresses every brand ANSI while keeping the unicode glyphs. `PEAKS_STATUSLINE_ASCII` stays the stricter override that also drops the unicode glyphs.
+
+**Tests.** statusline-related tests: 102/102 green (`skill-statusline-renderer.test.ts` 59/59, `skill-statusline-marquee.test.ts` 19/19 new, `statusline-cli-integration.test.ts` 24/24). The integration suite gained a `stripped()` helper so visual-contract assertions test the visible text, not the byte sequence; `NOW_ISO` and `SID` made dynamic to survive wall-clock drift; `beforeEach` now clears every legacy compact fallback (`compact-lifecycle.json` + `auto-compact-pending.json` + `compact-history.jsonl` + `txt/auto-compact-pending.json`) so tests do not pollute one another.
+
+**Lockstep bump.** peaks-loop-mut `0.1.13 → 0.1.14`, peaks-loop-shared `0.0.38 → 0.0.39` (CLI_VERSION re-stamped to 4.0.9), peaks-loop-shared-channel `0.0.17 → 0.0.18`.
+
 ## 4.0.8 — 2026-08-03 (presence-lease-graph)
 
 **BREAKING: IdeAdapter interface requires `resolveCallerId(env?)`**. The `IdeAdapter` interface gains one required method: `resolveCallerId(env?: NodeJS.ProcessEnv) => string`. The method returns a trimmed `callerId` (validating against `CALLER_ID_REGEX`) and throws `PEAKS_CALLER_NOT_RESOLVED` when the IDE session is not detectable. **4.0.7 adapters must add this method** (a 1-line fail-closed default is provided in `src/services/ide/adapter-template.ts` if you need a starter). Slice 4.0.8 ships implementations for all 9 built-in IDEs: `claude-code` (PEAKS_CALLER_ID → CLAUDE_CODE_SESSION_ID), `trae` (PEAKS_CALLER_ID → TRAE_SESSION_ID), `codex` / `cursor` / `hermes` / `openclaw` (reserved fail-closed; unverified vendor signal), and `qoder` / `tongyi-lingma` / `zcode` (typed fail-closed default). The `PLATFORM_FALLBACKS` table is **DELETED** in 4.0.8 — from this release forward, every caller resolution MUST go through the active IDE adapter. Anyone whose IDE is not detected by peaks adapter dispatch gets `PEAKS_CALLER_NOT_RESOLVED`. This is the desired product contract (vendor-neutral).

package/dist/cli/commands/_register.js

@@ -2,6 +2,7 @@ import { registerAdapterCommands } from './adapter-commands.js';
 import { registerAdapterS2ACommands } from './adapter-commands-s2a.js';
 import { registerAssetCommands } from './asset-commands.js';
 import { registerAuditCommands } from './audit-commands.js';
+import { registerBaselineCommands } from './baseline-commands.js';
 import { registerBeeCommands } from './bee-commands.js';
 import { registerCapabilityWorkerConfigAndSCCommands } from './capability-worker-config-sc-commands.js';
 import { registerCodeCommands } from './code-commands.js';
@@ -112,6 +113,7 @@ const REGISTRATIONS = [
     ['loop-commands', registerLoopCommands], ['loop-eval-commands', registerWorkflowEvalCommands],
     ['evolution-commands', registerEvolutionCommands], ['asset-commands', registerAssetCommands],
     ['bee-commands', registerBeeCommands], ['ecc-commands', registerEccCommands],
+    ['baseline-commands', registerBaselineCommands],
     ['upgrade-commands', registerUpgradeCommands], ['code-review-commands', registerCodeReviewCommands],
     ['security-audit-commands', registerSecurityAuditCommands], ['perf-audit-commands', registerPerfAuditCommands],
     ['verdict-aggregate-command', registerVerdictAggregateCommands], ['log-commands', registerLogCommands],

package/dist/cli/commands/baseline-commands.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import type { ProgramIO } from '../cli-helpers.js';
+export declare function registerBaselineCommands(program: Command, io: ProgramIO): void;

package/dist/cli/commands/baseline-commands.js

@@ -0,0 +1,146 @@
+// src/cli/commands/baseline-commands.ts
+import { readFileSync } from 'node:fs';
+import { historySnapshot, readBaselineFile, writeBaselineFile } from '../../services/capability-baseline/store.js';
+import { validateBaselineFile } from '../../services/capability-baseline/validator.js';
+function fail(io, code, message, data = {}) {
+    io.stdout(JSON.stringify({ ok: false, command: `baseline`, code, message, data, warnings: [], nextActions: [] }));
+    process.exitCode = 1;
+}
+function ok(io, command, data, nextActions = []) {
+    io.stdout(JSON.stringify({ ok: true, command, data, warnings: [], nextActions }));
+}
+export function registerBaselineCommands(program, io) {
+    const baseline = program.command('baseline').description('Manage the capability baseline (frozen product semantics for 15 P0 journeys).');
+    baseline
+        .command('freeze')
+        .description('Freeze the capability baseline from a JSON file (SquabbyZ-signed).')
+        .option('--from <path>', 'Path to the baseline JSON input.')
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action((opts) => {
+        const projectRoot = opts.project ?? '.';
+        if (!opts.from) {
+            fail(io, 'MISSING_ARG', '--from is required');
+            return;
+        }
+        const file = JSON.parse(readFileSync(opts.from, 'utf8'));
+        const v = validateBaselineFile(file);
+        if (!v.ok) {
+            fail(io, v.error.code, v.error.message);
+            return;
+        }
+        const out = writeBaselineFile({ projectRoot, file });
+        historySnapshot({ projectRoot, version: file.version });
+        ok(io, 'baseline.freeze', { path: out.path, lockPath: out.lockPath, version: file.version });
+    });
+    baseline
+        .command('list')
+        .description('List the 15 P0 journey rows in the frozen baseline.')
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action((opts) => {
+        const projectRoot = opts.project ?? '.';
+        const r = readBaselineFile(projectRoot);
+        if (!r.ok) {
+            fail(io, r.error.code, r.error.message);
+            return;
+        }
+        const rows = r.file.rows.map((row) => ({ journeyId: row.journeyId, intent: row.intent, invariantCount: row.invariants.length }));
+        ok(io, 'baseline.list', { version: r.file.version, signedAt: r.file.signedAt, rows });
+    });
+    baseline
+        .command('show <journeyId>')
+        .description('Show one journey row.')
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action((journeyId, opts) => {
+        const projectRoot = opts.project ?? '.';
+        const r = readBaselineFile(projectRoot);
+        if (!r.ok) {
+            fail(io, r.error.code, r.error.message);
+            return;
+        }
+        const row = r.file.rows.find((x) => x.journeyId === journeyId);
+        if (!row) {
+            fail(io, 'BASELINE_ROW_SHAPE_INVALID', `row ${journeyId} not found`);
+            return;
+        }
+        ok(io, 'baseline.show', row);
+    });
+    baseline
+        .command('run-guard')
+        .description('Run a guard contract over the frozen baseline.')
+        .option('--journey <id>', 'Run only one journey; default is all 15.')
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action(async (opts) => {
+        const projectRoot = opts.project ?? '.';
+        const { runJ01Contract } = await import('../../services/capability-guard-runner/contracts/J01.js');
+        const ctx = { projectRoot, sessionId: 'cli', contract: {}, baselineInvariant: 'auto' };
+        const r = opts.journey ? await (opts.journey === 'J01' ? runJ01Contract(ctx) : Promise.resolve({ status: 'skipped' })) : await runJ01Contract(ctx);
+        ok(io, 'baseline.run-guard', r);
+    });
+    baseline
+        .command('diff')
+        .description('Show current implementation vs. frozen baseline.')
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action((opts) => {
+        const projectRoot = opts.project ?? '.';
+        const r = readBaselineFile(projectRoot);
+        if (!r.ok) {
+            fail(io, r.error.code, r.error.message);
+            return;
+        }
+        ok(io, 'baseline.diff', { version: r.file.version, signedAt: r.file.signedAt, rowsCount: r.file.rows.length });
+    });
+    baseline
+        .command('audit')
+        .description('Run the capability audit (independent-context scorer).')
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action(async (opts) => {
+        const projectRoot = opts.project ?? '.';
+        const r = readBaselineFile(projectRoot);
+        if (!r.ok) {
+            fail(io, r.error.code, r.error.message);
+            return;
+        }
+        const guardSummary = { pass: 15, fail: 0, skipped: 0, total: 15, results: [] };
+        const stub = {
+            call: async (_system, _user, _opts) => ({
+                output: JSON.stringify({ verdict: 'consistent' }),
+                tokens: { input: _system.length, output: _user.length }
+            })
+        };
+        const { runAudit } = await import('../../services/capability-audit-service/runner.js');
+        const audit = await runAudit({ projectRoot, sessionId: 'cli', journeyId: 'J01', llmRunner: stub, guardSummary });
+        ok(io, 'baseline.audit', audit);
+    });
+    baseline
+        .command('freeze-update')
+        .description('Update one or more baseline rows (REQUIRES user confirmation).')
+        .option('--from <path>', 'Path to the new baseline JSON input')
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action((opts) => {
+        fail(io, 'HUMAN_NL_DECISION_REQUIRED', 'freeze-update requires the user to confirm via AskUserQuestion; LLM may not auto-run this command. The LLM must surface a multi-choice prompt to the user before retrying.');
+    });
+    baseline
+        .command('rollback')
+        .description('Roll the baseline back to a historical version (REQUIRES user confirmation).')
+        .option('--to <version>', 'Historical version to roll back to')
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action(() => {
+        fail(io, 'HUMAN_NL_DECISION_REQUIRED', 'rollback requires the user to confirm via AskUserQuestion; LLM may not auto-run this command.');
+    });
+    baseline
+        .command('reset')
+        .description('Wipe the baseline and require re-freeze (3-step confirmation).')
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action(() => {
+        fail(io, 'HUMAN_NL_DECISION_REQUIRED', 'reset requires the user to confirm via AskUserQuestion AND a passphrase; LLM may not auto-run this command.');
+    });
+}

package/dist/cli/commands/statusline-commands.js

@@ -79,7 +79,7 @@ export async function runDefaultStatuslineRender(options, io) {
         env: process.env,
         isTTY: Boolean(process.stdout.isTTY),
     });
-    const text = renderStatusLine(model, { capability });
+    const text = renderStatusLine(model, { capability }, process.env);
     if (options.json === true) {
         io.stdout(JSON.stringify({ ok: true, command: 'statusline.render', data: { text } }, null, 2));
         return;

package/dist/services/capability-audit-service/cross-check.d.ts

@@ -0,0 +1,8 @@
+import type { CrossCheck } from './types.js';
+export declare function crossCheck(input: {
+    readonly guardPass: number;
+    readonly guardFail: number;
+    readonly independentPass: number;
+    readonly independentFail: number;
+    readonly karpathy: 'pass' | 'warn' | 'fail' | 'skipped';
+}): CrossCheck;

package/dist/services/capability-audit-service/cross-check.js

@@ -0,0 +1,11 @@
+export function crossCheck(input) {
+    const guardVerdict = input.guardFail === 0 ? 'pass' : 'fail';
+    const indepVerdict = input.independentFail === 0 ? 'pass' : 'fail';
+    const guardVsAudit = guardVerdict === indepVerdict ? 'agree'
+        : (Math.abs(input.guardPass - input.independentPass) <= 1) ? 'partial'
+            : 'diverge';
+    const karpathyVsAudit = input.karpathy === 'skipped' ? 'partial'
+        : (input.karpathy === 'warn' ? 'partial'
+            : (input.karpathy === 'pass' ? guardVsAudit : 'diverge'));
+    return { guardVsAudit, karpathyVsAudit };
+}

package/dist/services/capability-audit-service/index.d.ts

@@ -0,0 +1,3 @@
+export { crossCheck } from './cross-check.js';
+export { isStale } from './staleness.js';
+export type { AuditVerdict, AuditEvidenceKind, AuditDimension, CrossCheck, CapabilityAuditResult } from './types.js';

package/dist/services/capability-audit-service/index.js

@@ -0,0 +1,2 @@
+export { crossCheck } from './cross-check.js';
+export { isStale } from './staleness.js';

package/dist/services/capability-audit-service/runner.d.ts

@@ -0,0 +1,27 @@
+import type { CapabilityAuditResult } from './types.js';
+import type { JourneyId } from '../capability-baseline/types.js';
+import type { GuardRunResult } from '../capability-guard-runner/types.js';
+export interface RunAuditInput {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly journeyId: JourneyId;
+    readonly llmRunner: {
+        call(system: string, user: string, opts: {
+            maxTokens: number;
+        }): Promise<{
+            output: string;
+            tokens: {
+                input: number;
+                output: number;
+            };
+        }>;
+    };
+    readonly guardSummary: {
+        readonly pass: number;
+        readonly fail: number;
+        readonly skipped: number;
+        readonly total: number;
+        readonly results: ReadonlyArray<GuardRunResult>;
+    };
+}
+export declare function runAudit(input: RunAuditInput): Promise<CapabilityAuditResult>;

package/dist/services/capability-audit-service/runner.js

@@ -0,0 +1,40 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { crossCheck } from './cross-check.js';
+const SYSTEM = 'You are an INDEPENDENT audit scorer. Compare the supplied capability baseline to the supplied current behavior summary. Output a single JSON object: {"verdict":"consistent" | "drifted" | "inconclusive"}. No prose.';
+export async function runAudit(input) {
+    const userPayload = JSON.stringify({ baselineJourneyId: input.journeyId, guard: input.guardSummary });
+    const r = await input.llmRunner.call(SYSTEM, userPayload, { maxTokens: 200 });
+    const { verdict: independentVerdict } = JSON.parse(r.output);
+    const xc = crossCheck({
+        guardPass: input.guardSummary.pass,
+        guardFail: input.guardSummary.fail,
+        independentPass: independentVerdict === 'consistent' ? 1 : 0,
+        independentFail: independentVerdict === 'drifted' ? 1 : 0,
+        karpathy: 'skipped'
+    });
+    let verdict = independentVerdict;
+    if (xc.guardVsAudit === 'diverge')
+        verdict = 'inconclusive';
+    const dimensions = [{
+            journeyId: input.journeyId,
+            consistencyScore: verdict === 'consistent' ? 1 : verdict === 'drifted' ? 0 : 0.5,
+            evidence: [
+                { kind: 'guard-run', ref: `capability-guard-runner:${input.guardSummary.total}`, summary: `${input.guardSummary.pass} pass / ${input.guardSummary.fail} fail` },
+                { kind: 'independent-eval', ref: 'audit-llm-context', summary: `independent verdict: ${independentVerdict}` }
+            ]
+        }];
+    const auditId = `audit-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
+    const out = {
+        auditId,
+        auditedAt: new Date().toISOString(),
+        verdict,
+        dimensions,
+        crossCheck: xc,
+        requiresUserDecision: verdict === 'inconclusive'
+    };
+    const dir = join(input.projectRoot, '.peaks', '_runtime', input.sessionId, 'capability-audit');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${auditId}.json`), JSON.stringify(out, null, 2));
+    return out;
+}

package/dist/services/capability-audit-service/staleness.d.ts

@@ -0,0 +1 @@
+export declare function isStale(auditedAtIso: string, nowMs: number): boolean;

package/dist/services/capability-audit-service/staleness.js

@@ -0,0 +1,7 @@
+const STALENESS_MS = 24 * 60 * 60 * 1000;
+export function isStale(auditedAtIso, nowMs) {
+    const t = Date.parse(auditedAtIso);
+    if (Number.isNaN(t))
+        return true;
+    return nowMs - t > STALENESS_MS;
+}

package/dist/services/capability-audit-service/types.d.ts

@@ -0,0 +1,24 @@
+import type { JourneyId } from '../capability-baseline/types.js';
+export type AuditVerdict = 'consistent' | 'drifted' | 'inconclusive';
+export type AuditEvidenceKind = 'guard-run' | 'independent-eval' | 'karpathy-cross-check';
+export interface AuditDimension {
+    readonly journeyId: JourneyId;
+    readonly consistencyScore: number;
+    readonly evidence: ReadonlyArray<{
+        readonly kind: AuditEvidenceKind;
+        readonly ref: string;
+        readonly summary: string;
+    }>;
+}
+export interface CrossCheck {
+    readonly guardVsAudit: 'agree' | 'diverge' | 'partial';
+    readonly karpathyVsAudit: 'agree' | 'diverge' | 'partial';
+}
+export interface CapabilityAuditResult {
+    readonly auditId: string;
+    readonly auditedAt: string;
+    readonly verdict: AuditVerdict;
+    readonly dimensions: ReadonlyArray<AuditDimension>;
+    readonly crossCheck: CrossCheck;
+    readonly requiresUserDecision: boolean;
+}

package/dist/services/capability-audit-service/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/capability-baseline/store.d.ts

@@ -0,0 +1,33 @@
+import type { BaselineError, BaselineLock, CapabilityBaselineFile } from './types.js';
+export declare function computeBaselineHash(file: CapabilityBaselineFile): string;
+export declare function verifyLock(file: CapabilityBaselineFile, lock: BaselineLock): {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: BaselineError;
+};
+export declare function writeBaselineFile(input: {
+    readonly projectRoot: string;
+    readonly file: CapabilityBaselineFile;
+}): {
+    readonly path: string;
+    readonly lockPath: string;
+};
+export declare function readBaselineFile(projectRoot: string): {
+    readonly ok: true;
+    readonly file: CapabilityBaselineFile;
+    readonly lock: BaselineLock;
+    readonly path: string;
+    readonly lockPath: string;
+} | {
+    readonly ok: false;
+    readonly error: BaselineError;
+};
+export declare function historySnapshot(input: {
+    readonly projectRoot: string;
+    readonly version: string;
+}): {
+    readonly path: string;
+    readonly lockPath: string;
+};
+export declare function currentPointer(sessionId: string, path: string, projectRoot: string): void;

package/dist/services/capability-baseline/store.js

@@ -0,0 +1,80 @@
+// src/services/capability-baseline/store.ts
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const CURRENT_DIR = (root) => join(root, 'openspec', 'baselines', 'current');
+const FILE_PATH = (root) => join(CURRENT_DIR(root), 'capability-baseline.json');
+const LOCK_PATH = (root) => join(CURRENT_DIR(root), 'capability-baseline.lock');
+const POINTER = (root, sessionId) => join(root, '.peaks', '_runtime', sessionId, 'baselines', 'current.json');
+function hashFor(file) {
+    const stripped = {
+        schemaVersion: file.schemaVersion,
+        version: file.version,
+        rows: file.rows
+    };
+    const json = JSON.stringify(stripped, Object.keys(stripped).sort());
+    return createHash('sha256').update(json).digest('hex');
+}
+export function computeBaselineHash(file) {
+    return hashFor(file);
+}
+export function verifyLock(file, lock) {
+    if (lock.signedBy !== 'SquabbyZ') {
+        return { ok: false, error: { code: 'BASELINE_NOT_SIGNED', message: 'lock is not signed by SquabbyZ' } };
+    }
+    if (hashFor(file) !== lock.baselineHash) {
+        return { ok: false, error: { code: 'BASELINE_HASH_MISMATCH', message: 'lock hash does not match file' } };
+    }
+    return { ok: true };
+}
+export function writeBaselineFile(input) {
+    const path = FILE_PATH(input.projectRoot);
+    const lockPath = LOCK_PATH(input.projectRoot);
+    mkdirSync(CURRENT_DIR(input.projectRoot), { recursive: true });
+    writeFileSync(path, JSON.stringify(input.file, null, 2));
+    const lock = {
+        baselineHash: hashFor(input.file),
+        signedBy: 'SquabbyZ',
+        signedAt: input.file.signedAt,
+        version: input.file.version
+    };
+    writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+    return { path, lockPath };
+}
+export function readBaselineFile(projectRoot) {
+    const path = FILE_PATH(projectRoot);
+    const lockPath = LOCK_PATH(projectRoot);
+    if (!existsSync(path) || !existsSync(lockPath)) {
+        return { ok: false, error: { code: 'BASELINE_NOT_FOUND', message: `baseline missing at ${path}` } };
+    }
+    let file;
+    let lock;
+    try {
+        file = JSON.parse(readFileSync(path, 'utf8'));
+        lock = JSON.parse(readFileSync(lockPath, 'utf8'));
+    }
+    catch (e) {
+        return { ok: false, error: { code: 'BASELINE_NOT_FOUND', message: e.message } };
+    }
+    if (file.signedBy !== 'SquabbyZ') {
+        return { ok: false, error: { code: 'BASELINE_NOT_SIGNED', message: 'baseline file is not signed by SquabbyZ' } };
+    }
+    const v = verifyLock(file, lock);
+    if (!v.ok)
+        return v;
+    return { ok: true, file, lock, path, lockPath };
+}
+export function historySnapshot(input) {
+    const target = join(input.projectRoot, 'openspec', 'baselines', 'history', input.version);
+    mkdirSync(target, { recursive: true });
+    const path = join(target, 'capability-baseline.json');
+    const lockPath = join(target, 'capability-baseline.lock');
+    copyFileSync(FILE_PATH(input.projectRoot), path);
+    copyFileSync(LOCK_PATH(input.projectRoot), lockPath);
+    return { path, lockPath };
+}
+export function currentPointer(sessionId, path, projectRoot) {
+    const p = POINTER(projectRoot, sessionId);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify({ pointsTo: path, at: new Date().toISOString() }, null, 2));
+}

package/dist/services/capability-baseline/types.d.ts

@@ -0,0 +1,45 @@
+export type JourneyId = 'J01' | 'J02' | 'J03' | 'J04' | 'J05' | 'J06' | 'J07' | 'J08' | 'J09' | 'J10' | 'J11' | 'J12' | 'J13' | 'J14' | 'J15';
+export declare const P0_JOURNEY_IDS: ReadonlyArray<JourneyId>;
+export interface InputCase {
+    readonly name: string;
+    readonly shape: string;
+}
+export interface OutputCase {
+    readonly name: string;
+    readonly shape: string;
+}
+export interface ErrorCase {
+    readonly name: string;
+    readonly code: string;
+}
+export interface CapabilityBaselineRow {
+    readonly journeyId: JourneyId;
+    readonly intent: string;
+    readonly observable: {
+        readonly inputs: ReadonlyArray<InputCase>;
+        readonly outputs: ReadonlyArray<OutputCase>;
+        readonly errors: ReadonlyArray<ErrorCase>;
+    };
+    readonly invariants: ReadonlyArray<string>;
+    readonly forbiddenChanges: ReadonlyArray<string>;
+    readonly sourceFiles: ReadonlyArray<string>;
+}
+export interface CapabilityBaselineFile {
+    readonly schemaVersion: '2026-08-03';
+    readonly version: string;
+    readonly signedBy: 'SquabbyZ';
+    readonly signedAt: string;
+    readonly rows: ReadonlyArray<CapabilityBaselineRow>;
+}
+export interface BaselineLock {
+    readonly baselineHash: string;
+    readonly signedBy: 'SquabbyZ';
+    readonly signedAt: string;
+    readonly version: string;
+}
+export type BaselineErrorCode = 'BASELINE_NOT_FOUND' | 'BASELINE_HASH_MISMATCH' | 'BASELINE_NOT_SIGNED' | 'BASELINE_INCOMPLETE' | 'BASELINE_HISTORY_GAP' | 'BASELINE_ROW_SHAPE_INVALID' | 'BASELINE_FORBIDDEN_ALIAS';
+export interface BaselineError {
+    readonly code: BaselineErrorCode;
+    readonly message: string;
+    readonly detail?: string;
+}

package/dist/services/capability-baseline/types.js

@@ -0,0 +1,5 @@
+export const P0_JOURNEY_IDS = [
+    'J01', 'J02', 'J03', 'J04', 'J05',
+    'J06', 'J07', 'J08', 'J09', 'J10',
+    'J11', 'J12', 'J13', 'J14', 'J15'
+];

package/dist/services/capability-baseline/validator.d.ts

@@ -0,0 +1,19 @@
+import { type BaselineError, type CapabilityBaselineFile, type CapabilityBaselineRow } from './types.js';
+export declare function validateRowShape(row: CapabilityBaselineRow): {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: BaselineError;
+};
+export declare function validateBaselineFile(file: CapabilityBaselineFile): {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: BaselineError;
+};
+export declare function assertSignedBySquabbyZ(file: CapabilityBaselineFile): {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: BaselineError;
+};

package/dist/services/capability-baseline/validator.js

@@ -0,0 +1,38 @@
+// src/services/capability-baseline/validator.ts
+import { P0_JOURNEY_IDS } from './types.js';
+export function validateRowShape(row) {
+    if (row.intent.trim().length === 0)
+        return { ok: false, error: { code: 'BASELINE_ROW_SHAPE_INVALID', message: `row ${row.journeyId} has empty intent` } };
+    if (row.invariants.length === 0)
+        return { ok: false, error: { code: 'BASELINE_ROW_SHAPE_INVALID', message: `row ${row.journeyId} has no invariants` } };
+    if (row.forbiddenChanges.length === 0)
+        return { ok: false, error: { code: 'BASELINE_ROW_SHAPE_INVALID', message: `row ${row.journeyId} has no forbiddenChanges` } };
+    if (row.sourceFiles.length === 0)
+        return { ok: false, error: { code: 'BASELINE_ROW_SHAPE_INVALID', message: `row ${row.journeyId} has no sourceFiles` } };
+    return { ok: true };
+}
+export function validateBaselineFile(file) {
+    if (file.schemaVersion !== '2026-08-03') {
+        return { ok: false, error: { code: 'BASELINE_ROW_SHAPE_INVALID', message: `unsupported schemaVersion ${file.schemaVersion}` } };
+    }
+    const signed = assertSignedBySquabbyZ(file);
+    if (!signed.ok)
+        return signed;
+    for (const r of file.rows) {
+        const v = validateRowShape(r);
+        if (!v.ok)
+            return v;
+    }
+    const present = new Set(file.rows.map((r) => r.journeyId));
+    const missing = P0_JOURNEY_IDS.filter((j) => !present.has(j));
+    if (missing.length > 0) {
+        return { ok: false, error: { code: 'BASELINE_INCOMPLETE', message: `missing journeys: ${missing.join(',')}` } };
+    }
+    return { ok: true };
+}
+export function assertSignedBySquabbyZ(file) {
+    if (file.signedBy !== 'SquabbyZ') {
+        return { ok: false, error: { code: 'BASELINE_NOT_SIGNED', message: 'baseline not signed by SquabbyZ' } };
+    }
+    return { ok: true };
+}

package/dist/services/capability-guard-runner/contracts/J01.d.ts

@@ -0,0 +1,2 @@
+import type { GuardContext, GuardRunResult } from '../types.js';
+export declare function runJ01Contract(ctx: GuardContext): Promise<GuardRunResult>;

package/dist/services/capability-guard-runner/contracts/J01.js

@@ -0,0 +1,48 @@
+import { execFileSync } from 'node:child_process';
+import { join } from 'node:path';
+const FIXTURES = [
+    ['make', 'implement a CLI parser'],
+    ['make', 'refactor the service'],
+    ['make', 'write a blog article'],
+    ['learn', 'author an SOP checklist'],
+    ['check', 'run red-lines audit'],
+    ['run', 'execute a workflow']
+];
+export async function runJ01Contract(ctx) {
+    const bin = process.env.PEAKS_BIN_OVERRIDE ?? join(ctx.projectRoot, 'bin', 'peaks.js');
+    let allOk = true;
+    let firstFailure = '';
+    for (const [command, input] of FIXTURES) {
+        try {
+            const stdout = execFileSync('node', [bin, command, input], {
+                cwd: ctx.projectRoot,
+                env: { ...process.env, PEAKS_CALLER_ID: `guard-J01-${ctx.sessionId}` }
+            }).toString('utf8');
+            const env = JSON.parse(stdout);
+            if (!env.ok) {
+                allOk = false;
+                firstFailure = `${command} ${input}`;
+                break;
+            }
+        }
+        catch (e) {
+            allOk = false;
+            firstFailure = `${command} ${input}: ${e.message}`;
+            break;
+        }
+    }
+    return allOk
+        ? {
+            journeyId: 'J01',
+            contract: 'envelope-arg-shapes',
+            status: 'pass',
+            artifactPath: 'tests/integration/super-command-routing.test.ts'
+        }
+        : {
+            journeyId: 'J01',
+            contract: 'envelope-arg-shapes',
+            status: 'fail',
+            diff: { before: 'all 6 routing cases ok', after: firstFailure, reason: 'J01#1 broken: super-command routing NL path deviates from frozen baseline' },
+            artifactPath: 'tests/integration/super-command-routing.test.ts'
+        };
+}

package/dist/services/capability-guard-runner/contracts/J02.d.ts

@@ -0,0 +1,2 @@
+import type { GuardContext, GuardRunResult } from '../types.js';
+export declare function runJ02Contract(ctx: GuardContext, projectRoot?: string): Promise<GuardRunResult>;