@njeybe/nativ 2.4.1 → 2.5.1

package/dist/commands/triage/triage-store.d.ts

@@ -0,0 +1,56 @@
+import type { CandidatePatch, SelfHealingEscalationRecord } from '../../governor/circuit-breaker.js';
+import type { HumanDecisionCard, TriageClassification, TriageEvaluation, TriageSource } from '../../core/tier1-liaison.js';
+export declare const ESCALATION_ID: RegExp;
+/** Latest Tier 1 verdict, stored on the escalation so Studio and the architect can show it after a reload. */
+export interface TriageSnapshot {
+    evaluatedAt: string;
+    provider: string;
+    model: string;
+    source: TriageSource;
+    latencyMs: number;
+    classification: TriageClassification;
+    reasoning: string;
+    autoPatchApplied: boolean;
+    unblockedTaskId: string | null;
+    guardrails: string[];
+    resolution?: {
+        summary: string;
+        patch: CandidatePatch;
+        proofPassed: boolean;
+        proposalId?: string;
+    };
+    humanCard?: HumanDecisionCard;
+}
+/** The product owner's pick from a decision card. Acting on it stays with the approve/reject gate. */
+export interface HumanDecision {
+    optionId: string;
+    label: string;
+    outcome?: string;
+    instructions?: string;
+    decidedAt: string;
+    decidedVia: 'cli';
+}
+export type TriagedEscalationRecord = SelfHealingEscalationRecord & {
+    triage?: TriageSnapshot;
+    humanDecision?: HumanDecision;
+};
+export interface TriageFinalization {
+    taskId: string | null;
+    unblockedTaskId: string | null;
+    persisted: boolean;
+}
+export declare function mutateEscalation(root: string, escalationId: string, mutate: (record: TriagedEscalationRecord) => void): boolean;
+/** Moves a blocked task back to pending so it can be dispatched again. False when it was not blocked. */
+export declare function unblockTask(root: string, taskId: string, note: string): Promise<boolean>;
+/**
+ * Only pending escalations may be triaged: re-running a resolved one could re-apply its proposal.
+ * Returns an error message, or null when the escalation can be evaluated.
+ */
+export declare function triageBlocker(root: string, escalationId: string): string | null;
+/**
+ * After an evaluation: unblocks the task and closes the escalation when a patch was auto-applied,
+ * then stores the verdict on the escalation. Never throws; a bookkeeping failure must not hide an
+ * applied patch.
+ */
+export declare function finalizeTriage(root: string, evaluation: TriageEvaluation): Promise<TriageFinalization>;
+export declare function recordHumanDecision(root: string, escalationId: string, decision: HumanDecision): boolean;

package/dist/commands/triage/triage-store.js

@@ -0,0 +1,108 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { withFileLockSync, withPlanLock, writeJsonAtomicSync } from '../../core/lock-manager.js';
+import { escalationPath, loadEscalationFile } from '../../governor/store.js';
+export const ESCALATION_ID = /^[A-Za-z0-9_-]{1,64}$/;
+export function mutateEscalation(root, escalationId, mutate) {
+    const file = escalationPath(root);
+    return withFileLockSync(file, () => {
+        const data = loadEscalationFile(root, path.basename(root));
+        const record = data.escalations.find((e) => e?.id === escalationId);
+        if (!record)
+            return false;
+        mutate(record);
+        data.lastUpdated = new Date().toISOString();
+        writeJsonAtomicSync(file, data);
+        return true;
+    });
+}
+/** Moves a blocked task back to pending so it can be dispatched again. False when it was not blocked. */
+export async function unblockTask(root, taskId, note) {
+    const planPath = path.join(root, '.ai', 'master_plan.json');
+    if (!fs.existsSync(planPath))
+        return false;
+    const result = await withPlanLock(planPath, (plan, ctx) => {
+        const task = plan.milestones.flatMap((m) => m.tasks ?? []).find((t) => t.id === taskId);
+        if (!task || task.status !== 'blocked') {
+            ctx.abort();
+            return false;
+        }
+        task.status = 'pending';
+        task.notes = note;
+        return true;
+    });
+    return result === true;
+}
+/**
+ * Only pending escalations may be triaged: re-running a resolved one could re-apply its proposal.
+ * Returns an error message, or null when the escalation can be evaluated.
+ */
+export function triageBlocker(root, escalationId) {
+    const record = loadEscalationFile(root, path.basename(root)).escalations.find((e) => e?.id === escalationId);
+    if (!record)
+        return `Escalation "${escalationId}" not found in .ai/escalation.json`;
+    if (record.status !== 'pending_review')
+        return `Escalation "${escalationId}" is already ${record.status}`;
+    return null;
+}
+/**
+ * After an evaluation: unblocks the task and closes the escalation when a patch was auto-applied,
+ * then stores the verdict on the escalation. Never throws; a bookkeeping failure must not hide an
+ * applied patch.
+ */
+export async function finalizeTriage(root, evaluation) {
+    let taskId = null;
+    let unblockedTaskId = null;
+    let persisted = false;
+    try {
+        taskId = loadEscalationFile(root, path.basename(root)).escalations.find((e) => e?.id === evaluation.escalationId)?.taskId ?? null;
+        if (evaluation.autoPatchApplied && taskId) {
+            const reason = evaluation.resolution?.summary ?? 'contract patch applied';
+            if (await unblockTask(root, taskId, `Unblocked by Tier 1 auto-resolution of ${evaluation.escalationId}: ${reason}`)) {
+                unblockedTaskId = taskId;
+            }
+        }
+        const snapshot = {
+            evaluatedAt: new Date().toISOString(),
+            provider: evaluation.provider,
+            model: evaluation.model,
+            source: evaluation.source,
+            latencyMs: evaluation.latencyMs,
+            classification: evaluation.classification,
+            reasoning: evaluation.reasoning,
+            autoPatchApplied: evaluation.autoPatchApplied,
+            unblockedTaskId,
+            guardrails: evaluation.guardrails,
+            ...(evaluation.resolution
+                ? {
+                    resolution: {
+                        summary: evaluation.resolution.summary,
+                        patch: evaluation.resolution.patch,
+                        proofPassed: evaluation.resolution.proof.passed,
+                        ...(evaluation.resolution.proposalId ? { proposalId: evaluation.resolution.proposalId } : {}),
+                    },
+                }
+                : {}),
+            ...(evaluation.humanCard ? { humanCard: evaluation.humanCard } : {}),
+        };
+        persisted = mutateEscalation(root, evaluation.escalationId, (record) => {
+            record.triage = snapshot;
+            if (evaluation.autoPatchApplied && record.status === 'pending_review') {
+                const closed = record;
+                closed.status = 'resolved';
+                closed.resolutionNotes = `Auto-resolved by Tier 1 (${evaluation.model}): ${evaluation.resolution?.summary ?? 'contract patch applied'}`;
+                closed.resolvedAt = snapshot.evaluatedAt;
+                closed.resolution = { decision: 'approve', proposalApplied: true, ruleId: 'TIER1_AUTO_RESOLVED', unblockedTaskId };
+            }
+        });
+    }
+    catch {
+        // Reported through `persisted: false`.
+    }
+    return { taskId, unblockedTaskId, persisted };
+}
+export function recordHumanDecision(root, escalationId, decision) {
+    return mutateEscalation(root, escalationId, (record) => {
+        record.humanDecision = decision;
+    });
+}

package/dist/commands/triage/triage-ui.d.ts

@@ -0,0 +1,14 @@
+import type { HumanDecisionCard, TriageEvaluation } from '../../core/tier1-liaison.js';
+import type { HumanDecision } from './triage-store.js';
+export declare const MAX_INSTRUCTIONS = 1000;
+export declare const MAX_PROMPT_ATTEMPTS = 3;
+export interface LineReader {
+    ask(prompt: string): Promise<string | null>;
+    close(): void;
+}
+/** Queues lines so answers typed (or piped) before the prompt appears are not lost. */
+export declare function createLineReader(input: NodeJS.ReadableStream, output: NodeJS.WritableStream): LineReader;
+/** Asks for a number in 1..max; null on Enter, end of input, or repeated invalid answers. */
+export declare function askChoice(reader: LineReader, prompt: string, max: number, print: (line?: string) => void): Promise<number | null>;
+export declare function printEvaluation(print: (line?: string) => void, result: TriageEvaluation, taskId: string | null, unblockedTaskId: string | null): void;
+export declare function askDecision(reader: LineReader, card: HumanDecisionCard, print: (line?: string) => void): Promise<Omit<HumanDecision, 'decidedAt' | 'decidedVia'> | null>;

package/dist/commands/triage/triage-ui.js

@@ -0,0 +1,104 @@
+import pc from 'picocolors';
+import readline from 'node:readline';
+export const MAX_INSTRUCTIONS = 1000;
+export const MAX_PROMPT_ATTEMPTS = 3;
+/** Queues lines so answers typed (or piped) before the prompt appears are not lost. */
+export function createLineReader(input, output) {
+    const rl = readline.createInterface({ input, terminal: false });
+    const queue = [];
+    const waiters = [];
+    let closed = false;
+    rl.on('line', (line) => {
+        const waiter = waiters.shift();
+        if (waiter)
+            waiter(line);
+        else
+            queue.push(line);
+    });
+    rl.on('close', () => {
+        closed = true;
+        while (waiters.length)
+            waiters.shift()(null);
+    });
+    return {
+        ask(prompt) {
+            output.write(prompt);
+            if (queue.length)
+                return Promise.resolve(queue.shift());
+            if (closed)
+                return Promise.resolve(null);
+            return new Promise((resolve) => waiters.push(resolve));
+        },
+        close: () => rl.close(),
+    };
+}
+/** Asks for a number in 1..max; null on Enter, end of input, or repeated invalid answers. */
+export async function askChoice(reader, prompt, max, print) {
+    for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS; attempt++) {
+        const answer = await reader.ask(prompt);
+        if (answer === null || !answer.trim())
+            return null;
+        const n = Number(answer.trim());
+        if (Number.isInteger(n) && n >= 1 && n <= max)
+            return n;
+        print(pc.yellow(`  Enter a number from 1 to ${max}, or press Enter to skip.`));
+    }
+    return null;
+}
+export function printEvaluation(print, result, taskId, unblockedTaskId) {
+    print('');
+    print(pc.bold(`Tier 1 AI Strategist`) + pc.dim(`  ${result.escalationId}${taskId ? ` / ${taskId}` : ''}  (${result.provider === 'deterministic' ? 'offline rules' : `${result.provider}: ${result.model}`}, ${result.latencyMs}ms)`));
+    if (result.classification === 'AUTO_RESOLVE' && !result.resolution) {
+        print(pc.green(pc.bold('Safe to proceed')) + pc.green('  No contract change is needed and nothing was written.'));
+    }
+    else if (result.classification === 'AUTO_RESOLVE' && result.resolution) {
+        const { patch, summary } = result.resolution;
+        print(pc.green(pc.bold(result.autoPatchApplied ? 'Auto-resolved' : 'Safe fix found')) + pc.green(`  ${summary}`));
+        print(pc.dim(`  ${patch.operation} ${patch.target} ${patch.path}`));
+        if (result.autoPatchApplied) {
+            print(pc.green(`  Patch written to .ai/${patch.target === 'db_schema' ? 'db_schema.json' : 'api_contracts.json'}.`));
+            if (unblockedTaskId)
+                print(pc.green(`  Task ${unblockedTaskId} is unblocked and pending.`));
+        }
+        else {
+            print(pc.white('  Proven in a sandbox copy of the contract. Re-run with --apply to write it.'));
+        }
+    }
+    else if (result.humanCard) {
+        const card = result.humanCard;
+        print(pc.yellow(pc.bold('Human Decision Required')));
+        print('');
+        print(pc.bold('1. What is happening?'));
+        print(`   ${card.symptom}`);
+        print(pc.bold('2. Why is this happening?'));
+        print(`   ${card.rootCause}`);
+        print(pc.bold('3. Who and what is affected?'));
+        print(`   ${card.blastRadius}`);
+        print(pc.bold('4. Your options'));
+        card.options.forEach((option, i) => {
+            const tag = option.recommended && !/recommended/i.test(option.label) ? pc.cyan(' (Recommended)') : '';
+            print(`   [${i + 1}] ${option.label}${tag}`);
+            print(pc.dim(`       ${option.outcome}`));
+        });
+        print(`   [${card.options.length + 1}] Give custom instructions`);
+    }
+    if (result.reasoning)
+        print(pc.dim(`\n  Reasoning: ${result.reasoning}`));
+    for (const note of result.guardrails)
+        print(pc.dim(`  Guardrail: ${note}`));
+}
+export async function askDecision(reader, card, print) {
+    const count = card.options.length + 1;
+    const keys = Array.from({ length: count }, (_, i) => i + 1).join('/');
+    const choice = await askChoice(reader, `\nChoose [${keys}] (Enter to decide later): `, count, print);
+    if (choice === null)
+        return null;
+    if (choice <= card.options.length) {
+        const option = card.options[choice - 1];
+        return { optionId: option.id, label: option.label, outcome: option.outcome };
+    }
+    const text = (await reader.ask('Instructions for the team: '))?.trim() ?? '';
+    if (!text)
+        return null;
+    return { optionId: 'custom', label: 'Custom instructions', instructions: text.slice(0, MAX_INSTRUCTIONS) };
+}

package/dist/commands/triage.d.ts

@@ -1,55 +1,6 @@
-import type { CandidatePatch, SelfHealingEscalationRecord } from '../governor/circuit-breaker.js';
-import { type HumanDecisionCard, type Tier1LiaisonOptions, type TriageClassification, type TriageEvaluation, type TriageFailure, type TriageSource } from '../core/tier1-liaison.js';
-/** Latest Tier 1 verdict, stored on the escalation so Studio and the architect can show it after a reload. */
-export interface TriageSnapshot {
-    evaluatedAt: string;
-    provider: string;
-    model: string;
-    source: TriageSource;
-    latencyMs: number;
-    classification: TriageClassification;
-    reasoning: string;
-    autoPatchApplied: boolean;
-    unblockedTaskId: string | null;
-    guardrails: string[];
-    resolution?: {
-        summary: string;
-        patch: CandidatePatch;
-        proofPassed: boolean;
-        proposalId?: string;
-    };
-    humanCard?: HumanDecisionCard;
-}
-/** The product owner's pick from a decision card. Acting on it stays with the approve/reject gate. */
-export interface HumanDecision {
-    optionId: string;
-    label: string;
-    outcome?: string;
-    instructions?: string;
-    decidedAt: string;
-    decidedVia: 'cli';
-}
-export type TriagedEscalationRecord = SelfHealingEscalationRecord & {
-    triage?: TriageSnapshot;
-    humanDecision?: HumanDecision;
-};
-export interface TriageFinalization {
-    taskId: string | null;
-    unblockedTaskId: string | null;
-    persisted: boolean;
-}
-/**
- * Only pending escalations may be triaged: re-running a resolved one could re-apply its proposal.
- * Returns an error message, or null when the escalation can be evaluated.
- */
-export declare function triageBlocker(root: string, escalationId: string): string | null;
-/**
- * After an evaluation: unblocks the task and closes the escalation when a patch was auto-applied,
- * then stores the verdict on the escalation. Never throws; a bookkeeping failure must not hide an
- * applied patch.
- */
-export declare function finalizeTriage(root: string, evaluation: TriageEvaluation): Promise<TriageFinalization>;
-export declare function recordHumanDecision(root: string, escalationId: string, decision: HumanDecision): boolean;
+import { type Tier1LiaisonOptions, type TriageEvaluation, type TriageFailure } from '../core/tier1-liaison.js';
+import { type HumanDecision } from './triage/triage-store.js';
+export * from './triage/triage-store.js';
 export interface RunTriageOptions {
     all?: boolean;
     apply?: boolean;

package/dist/commands/triage.js

@@ -1,227 +1,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import readline from 'node:readline';
 import pc from 'picocolors';
 import { resolveProjectRoot } from '../core/root-resolver.js';
-import { withFileLockSync, withPlanLock, writeJsonAtomicSync } from '../core/lock-manager.js';
-import { escalationPath, loadEscalationFile } from '../governor/store.js';
+import { loadEscalationFile } from '../governor/store.js';
 import { Tier1Liaison, } from '../core/tier1-liaison.js';
-/**
- * `nativ triage`: runs the Tier 1 AI Strategist on pending escalations from the terminal and
- * presents human decision cards with numbered choices. Also home of the helpers that persist a
- * verdict onto its escalation record, shared with the Studio triage endpoints.
- */
-const ESCALATION_ID = /^[A-Za-z0-9_-]{1,64}$/;
-const MAX_INSTRUCTIONS = 1000;
-const MAX_PROMPT_ATTEMPTS = 3;
-function mutateEscalation(root, escalationId, mutate) {
-    const file = escalationPath(root);
-    return withFileLockSync(file, () => {
-        const data = loadEscalationFile(root, path.basename(root));
-        const record = data.escalations.find((e) => e?.id === escalationId);
-        if (!record)
-            return false;
-        mutate(record);
-        data.lastUpdated = new Date().toISOString();
-        writeJsonAtomicSync(file, data);
-        return true;
-    });
-}
-/** Moves a blocked task back to pending so it can be dispatched again. False when it was not blocked. */
-async function unblockTask(root, taskId, note) {
-    const planPath = path.join(root, '.ai', 'master_plan.json');
-    if (!fs.existsSync(planPath))
-        return false;
-    const result = await withPlanLock(planPath, (plan, ctx) => {
-        const task = plan.milestones.flatMap((m) => m.tasks ?? []).find((t) => t.id === taskId);
-        if (!task || task.status !== 'blocked') {
-            ctx.abort();
-            return false;
-        }
-        task.status = 'pending';
-        task.notes = note;
-        return true;
-    });
-    return result === true;
-}
-/**
- * Only pending escalations may be triaged: re-running a resolved one could re-apply its proposal.
- * Returns an error message, or null when the escalation can be evaluated.
- */
-export function triageBlocker(root, escalationId) {
-    const record = loadEscalationFile(root, path.basename(root)).escalations.find((e) => e?.id === escalationId);
-    if (!record)
-        return `Escalation "${escalationId}" not found in .ai/escalation.json`;
-    if (record.status !== 'pending_review')
-        return `Escalation "${escalationId}" is already ${record.status}`;
-    return null;
-}
-/**
- * After an evaluation: unblocks the task and closes the escalation when a patch was auto-applied,
- * then stores the verdict on the escalation. Never throws; a bookkeeping failure must not hide an
- * applied patch.
- */
-export async function finalizeTriage(root, evaluation) {
-    let taskId = null;
-    let unblockedTaskId = null;
-    let persisted = false;
-    try {
-        taskId = loadEscalationFile(root, path.basename(root)).escalations.find((e) => e?.id === evaluation.escalationId)?.taskId ?? null;
-        if (evaluation.autoPatchApplied && taskId) {
-            const reason = evaluation.resolution?.summary ?? 'contract patch applied';
-            if (await unblockTask(root, taskId, `Unblocked by Tier 1 auto-resolution of ${evaluation.escalationId}: ${reason}`)) {
-                unblockedTaskId = taskId;
-            }
-        }
-        const snapshot = {
-            evaluatedAt: new Date().toISOString(),
-            provider: evaluation.provider,
-            model: evaluation.model,
-            source: evaluation.source,
-            latencyMs: evaluation.latencyMs,
-            classification: evaluation.classification,
-            reasoning: evaluation.reasoning,
-            autoPatchApplied: evaluation.autoPatchApplied,
-            unblockedTaskId,
-            guardrails: evaluation.guardrails,
-            ...(evaluation.resolution
-                ? {
-                    resolution: {
-                        summary: evaluation.resolution.summary,
-                        patch: evaluation.resolution.patch,
-                        proofPassed: evaluation.resolution.proof.passed,
-                        ...(evaluation.resolution.proposalId ? { proposalId: evaluation.resolution.proposalId } : {}),
-                    },
-                }
-                : {}),
-            ...(evaluation.humanCard ? { humanCard: evaluation.humanCard } : {}),
-        };
-        persisted = mutateEscalation(root, evaluation.escalationId, (record) => {
-            record.triage = snapshot;
-            if (evaluation.autoPatchApplied && record.status === 'pending_review') {
-                // Same closing fields the Studio approve/reject endpoint writes.
-                const closed = record;
-                closed.status = 'resolved';
-                closed.resolutionNotes = `Auto-resolved by Tier 1 (${evaluation.model}): ${evaluation.resolution?.summary ?? 'contract patch applied'}`;
-                closed.resolvedAt = snapshot.evaluatedAt;
-                closed.resolution = { decision: 'approve', proposalApplied: true, ruleId: 'TIER1_AUTO_RESOLVED', unblockedTaskId };
-            }
-        });
-    }
-    catch {
-        // Reported through `persisted: false`.
-    }
-    return { taskId, unblockedTaskId, persisted };
-}
-export function recordHumanDecision(root, escalationId, decision) {
-    return mutateEscalation(root, escalationId, (record) => {
-        record.humanDecision = decision;
-    });
-}
-/** Queues lines so answers typed (or piped) before the prompt appears are not lost. */
-function createLineReader(input, output) {
-    const rl = readline.createInterface({ input, terminal: false });
-    const queue = [];
-    const waiters = [];
-    let closed = false;
-    rl.on('line', (line) => {
-        const waiter = waiters.shift();
-        if (waiter)
-            waiter(line);
-        else
-            queue.push(line);
-    });
-    rl.on('close', () => {
-        closed = true;
-        while (waiters.length)
-            waiters.shift()(null);
-    });
-    return {
-        ask(prompt) {
-            output.write(prompt);
-            if (queue.length)
-                return Promise.resolve(queue.shift());
-            if (closed)
-                return Promise.resolve(null);
-            return new Promise((resolve) => waiters.push(resolve));
-        },
-        close: () => rl.close(),
-    };
-}
-/** Asks for a number in 1..max; null on Enter, end of input, or repeated invalid answers. */
-async function askChoice(reader, prompt, max, print) {
-    for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS; attempt++) {
-        const answer = await reader.ask(prompt);
-        if (answer === null || !answer.trim())
-            return null;
-        const n = Number(answer.trim());
-        if (Number.isInteger(n) && n >= 1 && n <= max)
-            return n;
-        print(pc.yellow(`  Enter a number from 1 to ${max}, or press Enter to skip.`));
-    }
-    return null;
-}
+import { ESCALATION_ID, finalizeTriage, recordHumanDecision, triageBlocker, } from './triage/triage-store.js';
+import { askChoice, askDecision, createLineReader, printEvaluation, } from './triage/triage-ui.js';
+export * from './triage/triage-store.js';
 function pendingEscalations(root) {
     return loadEscalationFile(root, path.basename(root))
         .escalations.filter((e) => e && typeof e.id === 'string' && e.status === 'pending_review');
 }
-function printEvaluation(print, result, taskId, unblockedTaskId) {
-    print('');
-    print(pc.bold(`Tier 1 AI Strategist`) + pc.dim(`  ${result.escalationId}${taskId ? ` / ${taskId}` : ''}  (${result.provider === 'deterministic' ? 'offline rules' : `${result.provider}: ${result.model}`}, ${result.latencyMs}ms)`));
-    if (result.classification === 'AUTO_RESOLVE' && !result.resolution) {
-        print(pc.green(pc.bold('Safe to proceed')) + pc.green('  No contract change is needed and nothing was written.'));
-    }
-    else if (result.classification === 'AUTO_RESOLVE' && result.resolution) {
-        const { patch, summary } = result.resolution;
-        print(pc.green(pc.bold(result.autoPatchApplied ? 'Auto-resolved' : 'Safe fix found')) + pc.green(`  ${summary}`));
-        print(pc.dim(`  ${patch.operation} ${patch.target} ${patch.path}`));
-        if (result.autoPatchApplied) {
-            print(pc.green(`  Patch written to .ai/${patch.target === 'db_schema' ? 'db_schema.json' : 'api_contracts.json'}.`));
-            if (unblockedTaskId)
-                print(pc.green(`  Task ${unblockedTaskId} is unblocked and pending.`));
-        }
-        else {
-            print(pc.white('  Proven in a sandbox copy of the contract. Re-run with --apply to write it.'));
-        }
-    }
-    else if (result.humanCard) {
-        const card = result.humanCard;
-        print(pc.yellow(pc.bold('Human Decision Required')));
-        print('');
-        print(pc.bold('1. What is happening?'));
-        print(`   ${card.symptom}`);
-        print(pc.bold('2. Why is this happening?'));
-        print(`   ${card.rootCause}`);
-        print(pc.bold('3. Who and what is affected?'));
-        print(`   ${card.blastRadius}`);
-        print(pc.bold('4. Your options'));
-        card.options.forEach((option, i) => {
-            const tag = option.recommended && !/recommended/i.test(option.label) ? pc.cyan(' (Recommended)') : '';
-            print(`   [${i + 1}] ${option.label}${tag}`);
-            print(pc.dim(`       ${option.outcome}`));
-        });
-        print(`   [${card.options.length + 1}] Give custom instructions`);
-    }
-    if (result.reasoning)
-        print(pc.dim(`\n  Reasoning: ${result.reasoning}`));
-    for (const note of result.guardrails)
-        print(pc.dim(`  Guardrail: ${note}`));
-}
-async function askDecision(reader, card, print) {
-    const count = card.options.length + 1;
-    const keys = Array.from({ length: count }, (_, i) => i + 1).join('/');
-    const choice = await askChoice(reader, `\nChoose [${keys}] (Enter to decide later): `, count, print);
-    if (choice === null)
-        return null;
-    if (choice <= card.options.length) {
-        const option = card.options[choice - 1];
-        return { optionId: option.id, label: option.label, outcome: option.outcome };
-    }
-    const text = (await reader.ask('Instructions for the team: '))?.trim() ?? '';
-    if (!text)
-        return null;
-    return { optionId: 'custom', label: 'Custom instructions', instructions: text.slice(0, MAX_INSTRUCTIONS) };
-}
 export async function runTriage(escalationIdArg, targetDirArg, options = {}) {
     const output = options.output ?? process.stdout;
     const print = (line = '') => {
@@ -252,7 +41,10 @@ export async function runTriage(escalationIdArg, targetDirArg, options = {}) {
     }
     const liaison = new Tier1Liaison(root, {
         ...options.liaison,
-        config: { autoTriageEnabled: Boolean(options.apply), riskThreshold: threshold ?? 'safe_contracts_only' },
+        config: {
+            ...(options.apply !== undefined ? { autoTriageEnabled: Boolean(options.apply) } : {}),
+            ...(threshold ? { riskThreshold: threshold } : {}),
+        },
     });
     const interactive = !options.json && (options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY));
     const reader = interactive ? createLineReader(options.input ?? process.stdin, output) : null;

package/dist/core/enforcement.d.ts

@@ -42,6 +42,7 @@ export interface WriteCheckResult {
     taskIds: string[];
 }
 export declare function loadEnforcementMode(root: string): EnforcementMode;
+export declare function loadSafePeripherals(root: string): string[];
 export declare function isTaskUnlocked(root: string, taskId: string): boolean;
 /** Lifts scope enforcement for one task until it is revoked or the task stops being in progress. */
 export declare function addTaskUnlock(root: string, taskId: string, reason?: string): void;

package/dist/core/enforcement.js

@@ -35,12 +35,28 @@ export function loadEnforcementMode(root) {
         const raw = parseJsonLoose(fs.readFileSync(path.join(root, CONFIG_FILE), 'utf8'));
         if (raw.enforcement === 'off' || raw.enforcement === 'warn' || raw.enforcement === 'block')
             return raw.enforcement;
+        if (raw.profile === 'prototype')
+            return 'off';
+        if (raw.profile === 'solo')
+            return 'warn';
     }
     catch {
         // Missing or corrupt config means the default.
     }
     return DEFAULT_ENFORCEMENT_MODE;
 }
+export function loadSafePeripherals(root) {
+    try {
+        const raw = parseJsonLoose(fs.readFileSync(path.join(root, CONFIG_FILE), 'utf8'));
+        if (Array.isArray(raw.safePeripherals)) {
+            return raw.safePeripherals.filter((p) => typeof p === 'string' && Boolean(p.trim()));
+        }
+    }
+    catch {
+        // Missing or invalid config
+    }
+    return [];
+}
 function readUnlocks(root) {
     try {
         const raw = parseJsonLoose(fs.readFileSync(path.join(root, UNLOCK_FILE), 'utf8'));
@@ -234,6 +250,9 @@ export function checkWrite(input) {
         return { ...allow, taskIds };
     if (tasks.some((t) => t.targetFiles.some((target) => matchesTarget(relPath, target))))
         return { ...allow, taskIds };
+    const safePeripherals = loadSafePeripherals(mainRoot);
+    if (safePeripherals.some((pattern) => matchesTarget(relPath, pattern)))
+        return { ...allow, taskIds };
     const label = taskIds.length === 1 ? `task ${taskIds[0]}` : `tasks ${taskIds.join(', ')}`;
     const scope = tasks.flatMap((t) => t.targetFiles);
     return verdict(mode, root, relPath, taskIds, 'out_of_scope', `${relPath} is outside the target files of ${label}` +

package/dist/core/human-gate.d.ts

@@ -3,5 +3,6 @@
  * where no permission rule is installed. It is one layer, not a sandbox: the hook and ask rules are others.
  */
 export declare function isInteractive(): boolean;
-/** Prints why and sets a failing exit code when there is no terminal. Returns true when refused. */
+export declare function isCiEnvironment(): boolean;
+/** Prints why and sets a failing exit code when there is no terminal, unless in CI or overridden. */
 export declare function refuseHeadless(command: string): boolean;

package/dist/core/human-gate.js

@@ -6,9 +6,16 @@ import pc from 'picocolors';
 export function isInteractive() {
     return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
-/** Prints why and sets a failing exit code when there is no terminal. Returns true when refused. */
+export function isCiEnvironment() {
+    return Boolean(process.env.CI === 'true' ||
+        process.env.GITHUB_ACTIONS === 'true' ||
+        process.env.GITLAB_CI === 'true' ||
+        process.env.NATIV_CI_OVERRIDE ||
+        process.env.NATIV_HEADLESS_OVERRIDE === '1');
+}
+/** Prints why and sets a failing exit code when there is no terminal, unless in CI or overridden. */
 export function refuseHeadless(command) {
-    if (isInteractive())
+    if (isInteractive() || isCiEnvironment())
         return false;
     console.error(pc.red(`✖ ${command} needs an interactive terminal; agents cannot run it.`));
     process.exitCode = 1;