@njeybe/nativ 2.3.1 → 2.4.0

package/dist/commands/db.js

@@ -7,6 +7,7 @@ import { disconnectedStatus, introspectDatabase } from '../db/introspector.js';
 import { diffSchemas, loadContractTables } from '../db/diff.js';
 import { DEFAULT_STUDIO_PORT, startStudioServer, writeContractSchema } from '../server/studio-server.js';
 import { renderStudioHtml } from '../server/studio-ui.js';
+import { refuseHeadless } from '../core/human-gate.js';
 /**
  * `nativ db` command handlers.
  * Air-gap: raw connection URLs are resolved in-process and never printed; all output
@@ -343,6 +344,8 @@ export async function runDbSync(targetDirArg, options = {}) {
         console.log(pc.yellow('Dry run: no files were changed. Re-run with --yes to write .ai/db_schema.json.\n'));
         return;
     }
+    if (refuseHeadless('nativ db sync --yes'))
+        return;
     const filePath = writeContractSchema(targetDir, result.status, result.tables);
     const count = result.tables.length;
     const isCollection = result.status.entityType === 'collection';

package/dist/commands/doctor.d.ts

@@ -1,6 +1,7 @@
 import { type SetupOptions } from '../core/setup-assets.js';
 import type { ProviderDeps } from '../providers/index.js';
-export type CheckStatus = 'ok' | 'warn' | 'fail' | 'info';
+export type { CheckStatus } from '../core/harness-integrity.js';
+import type { CheckStatus } from '../core/harness-integrity.js';
 export interface DoctorCheck {
     id: string;
     status: CheckStatus;

package/dist/commands/doctor.js

@@ -6,6 +6,7 @@ import { loadEnforcementMode, parseJsonLoose } from '../core/enforcement.js';
 import { resolveProjectRoot } from '../core/root-resolver.js';
 import { applySetup, defaultHasBinary, planSetup } from '../core/setup-assets.js';
 import { createProviders, providerCooldownRemaining } from '../providers/index.js';
+import { checkHarnessIntegrity } from '../core/harness-integrity.js';
 function defaultRunVersion(command, args) {
     try {
         // The Windows shims (nativ.cmd, npx.cmd) only start through a shell.
@@ -124,6 +125,9 @@ export function collectChecks(root, options = {}) {
     // Enforcement
     const mode = loadEnforcementMode(root);
     add('enforcement', mode === 'off' ? 'warn' : 'ok', mode === 'off' ? 'Role enforcement is off: nothing stops an agent editing outside its task.' : `Role enforcement is ${mode}`);
+    // The harness itself: guardrail overrides, secrets in agent-read files, role guides, waiting lessons
+    for (const f of checkHarnessIntegrity(root, { templatesDir: options.templatesDir }))
+        add(f.id, f.status, f.message);
     // Providers
     const providers = createProviders(options.providerDeps);
     const usable = [];

package/dist/commands/init.js

@@ -140,5 +140,6 @@ export async function runInit(targetDirArg, options = {}) {
     console.log(pc.white(` 1. Run ${pc.green('claude')} in this directory and ask the ${pc.magenta('architect')} agent to design your contracts (database, API, UI). You approve each step.`));
     console.log(pc.white(` 2. The architect writes ${pc.cyan('.ai/db_schema.json')}, ${pc.cyan('.ai/api_contracts.json')}, ${pc.cyan('.ai/ui_specs.md')}, and ${pc.cyan('.ai/master_plan.json')}.`));
     console.log(pc.white(` 3. Ask Claude to run ${pc.green('nativ task next')} and delegate each task to a ${pc.magenta('worker')} agent; use ${pc.magenta('verifier')} for an independent check.`));
+    console.log(pc.white(` On existing code, ask for the ${pc.magenta('explorer')} agent first: it maps the code for the architect.`));
     console.log(pc.dim(` Run ${pc.white('nativ doctor')} any time, and after updating Claude Code, to confirm the integration is intact.\n`));
 }

package/dist/commands/learn.d.ts

@@ -0,0 +1,19 @@
+import { type LearningDecision } from '../core/learnings.js';
+export interface LearnProposeOptions {
+    role?: string;
+    files?: string;
+    task?: string;
+    details?: string;
+    by?: string;
+    json?: boolean;
+}
+export declare function runLearnPropose(insight: string, targetDirArg?: string, options?: LearnProposeOptions): Promise<void>;
+export declare function runLearnDecide(id: string, decision: LearningDecision, targetDirArg?: string, options?: {
+    note?: string;
+    yes?: boolean;
+}): Promise<void>;
+export declare function runLearnList(targetDirArg?: string, options?: {
+    status?: string;
+    role?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/learn.js

@@ -0,0 +1,121 @@
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import pc from 'picocolors';
+import { resolveMainRoot } from '../core/root-resolver.js';
+import { refuseHeadless } from '../core/human-gate.js';
+import { LEARNING_STATUSES, proposeLearning, decideLearning, listLearnings, loadLearnings, lessonContent, } from '../core/learnings.js';
+function rootOf(targetDirArg) {
+    return resolveMainRoot(path.resolve(targetDirArg || process.cwd()));
+}
+function fail(message) {
+    console.error(pc.red(`✖ ${message}`));
+    process.exitCode = 1;
+}
+function headline(item) {
+    return `${pc.bold(item.id)} ${pc.dim(`[${item.status}]`)} ${item.insight}`;
+}
+/** Everything a worker would receive, so the human approves exactly that. */
+function fullText(item) {
+    const lines = [headline(item)];
+    if (item.details)
+        lines.push(...item.details.split('\n').map((l) => pc.white(`    ${l}`)));
+    const scope = [
+        item.role ? `role ${item.role}` : 'every role',
+        item.files?.length ? `files ${item.files.join(', ')}` : 'any file',
+    ];
+    lines.push(pc.dim(`    for ${scope.join('; ')}${item.proposedBy ? `; proposed by ${item.proposedBy}` : ''}`));
+    return lines;
+}
+export async function runLearnPropose(insight, targetDirArg, options = {}) {
+    let item;
+    try {
+        item = proposeLearning(rootOf(targetDirArg), {
+            insight,
+            details: options.details,
+            role: options.role,
+            files: options.files?.split(','),
+            taskId: options.task,
+            proposedBy: options.by ?? process.env.NATIV_ROLE,
+        });
+    }
+    catch (err) {
+        fail(err.message);
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify(item, null, 2));
+        return;
+    }
+    console.log(pc.green('\n✔ Proposed'));
+    for (const line of fullText(item))
+        console.log(`  ${line}`);
+    console.log(pc.dim(`  A human approves it in a terminal: nativ learn approve ${item.id}\n`));
+}
+async function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return /^y(es)?$/i.test((await rl.question(question)).trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runLearnDecide(id, decision, targetDirArg, options = {}) {
+    if (refuseHeadless(`nativ learn ${decision === 'approved' ? 'approve' : 'reject'}`))
+        return;
+    const root = rootOf(targetDirArg);
+    const current = loadLearnings(root).learnings.find((l) => l.id === id);
+    if (!current) {
+        fail(`No learning ${id}.`);
+        return;
+    }
+    console.log('');
+    for (const line of fullText(current))
+        console.log(`  ${line}`);
+    const verb = decision === 'approved' ? 'Approve' : 'Reject';
+    if (!options.yes && !(await confirm(`\n  ${verb} ${id}? [y/N] `))) {
+        console.log(pc.dim('  Nothing changed.\n'));
+        return;
+    }
+    let result;
+    try {
+        result = decideLearning(root, id, decision, options.note, lessonContent(current));
+    }
+    catch (err) {
+        fail(err.message);
+        return;
+    }
+    if (typeof result === 'string') {
+        fail(result);
+        return;
+    }
+    const after = decision === 'approved'
+        ? 'Workers whose task matches its scope will now see it.'
+        : 'It stays on record.';
+    console.log(pc.green(`\n✔ ${headline(result)}`));
+    console.log(pc.dim(`  ${after}\n`));
+}
+export async function runLearnList(targetDirArg, options = {}) {
+    if (options.status && !LEARNING_STATUSES.includes(options.status)) {
+        fail(`Unknown status "${options.status}". Use one of: ${LEARNING_STATUSES.join(', ')}.`);
+        return;
+    }
+    const status = options.status;
+    const items = listLearnings(rootOf(targetDirArg), { status, role: options.role });
+    if (options.json) {
+        console.log(JSON.stringify(items, null, 2));
+        return;
+    }
+    if (!items.length) {
+        console.log(pc.dim('\nNo learnings match.\n'));
+        return;
+    }
+    console.log('');
+    for (const item of items)
+        for (const line of fullText(item))
+            console.log(`  ${line}`);
+    const waiting = items.filter((i) => i.status === 'proposed').length;
+    if (waiting)
+        console.log(pc.yellow(`\n  ${waiting} waiting for approval: nativ learn approve <id> or reject <id>`));
+    console.log('');
+}

package/dist/commands/session.d.ts

@@ -0,0 +1,22 @@
+import { SessionCheckpoint, SessionSummaryEntry } from '../core/session-memory.js';
+export interface SessionSaveOptions {
+    summary: string;
+    decision?: string[];
+    obstacle?: string[];
+    next?: string[];
+    activeFiles?: string;
+    task?: string;
+    role?: string;
+    sessionId?: string;
+    json?: boolean;
+}
+export interface SessionListOptions {
+    limit?: number;
+    json?: boolean;
+}
+export interface SessionGetOptions {
+    json?: boolean;
+}
+export declare function runSessionSave(targetDirArg?: string, options?: SessionSaveOptions): Promise<SessionCheckpoint>;
+export declare function runSessionList(targetDirArg?: string, options?: SessionListOptions): Promise<SessionSummaryEntry[]>;
+export declare function runSessionGet(sessionId?: string, targetDirArg?: string, options?: SessionGetOptions): Promise<SessionCheckpoint | null>;

package/dist/commands/session.js

@@ -0,0 +1,106 @@
+import path from 'node:path';
+import pc from 'picocolors';
+import { saveSessionCheckpoint, getLatestSession, getSession, listSessions, } from '../core/session-memory.js';
+export async function runSessionSave(targetDirArg, options = { summary: '' }) {
+    const targetDir = path.resolve(targetDirArg || process.cwd());
+    const files = options.activeFiles
+        ? options.activeFiles.split(',').map((f) => f.trim()).filter(Boolean)
+        : undefined;
+    const checkpoint = saveSessionCheckpoint(targetDir, {
+        sessionId: options.sessionId,
+        summary: options.summary,
+        decisions: options.decision,
+        obstacles: options.obstacle,
+        nextSteps: options.next,
+        activeFiles: files,
+        taskId: options.task,
+        role: options.role,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(checkpoint, null, 2));
+        return checkpoint;
+    }
+    console.log(pc.bold(pc.green(`\n✔ Saved Session Checkpoint: `)) + pc.yellow(`[${checkpoint.sessionId}]`));
+    console.log(pc.bold('  Summary:    ') + pc.white(checkpoint.summary));
+    if (checkpoint.taskId) {
+        console.log(pc.bold('  Task:       ') + pc.yellow(checkpoint.taskId));
+    }
+    if (checkpoint.role) {
+        console.log(pc.bold('  Role:       ') + pc.magenta(checkpoint.role));
+    }
+    if (checkpoint.decisions && checkpoint.decisions.length > 0) {
+        console.log(pc.bold('  Decisions:  ') + pc.dim(checkpoint.decisions.join(' | ')));
+    }
+    if (checkpoint.obstacles && checkpoint.obstacles.length > 0) {
+        console.log(pc.bold('  Obstacles:  ') + pc.red(checkpoint.obstacles.join(' | ')));
+    }
+    if (checkpoint.nextSteps && checkpoint.nextSteps.length > 0) {
+        console.log(pc.bold('  Next Steps: ') + pc.cyan(checkpoint.nextSteps.join(' | ')));
+    }
+    if (checkpoint.activeFiles && checkpoint.activeFiles.length > 0) {
+        console.log(pc.bold('  Files:      ') + pc.dim(checkpoint.activeFiles.join(', ')));
+    }
+    console.log();
+    return checkpoint;
+}
+export async function runSessionList(targetDirArg, options = {}) {
+    const targetDir = path.resolve(targetDirArg || process.cwd());
+    const sessions = listSessions(targetDir, options.limit || 10);
+    if (options.json) {
+        console.log(JSON.stringify(sessions, null, 2));
+        return sessions;
+    }
+    console.log(pc.bold(pc.cyan('\nSession Memory Checkpoints (.ai/memory/sessions/)')));
+    console.log(pc.dim(`Workspace: ${targetDir}\n`));
+    if (sessions.length === 0) {
+        console.log(pc.dim('  No saved sessions found.\n'));
+        console.log(pc.dim('  Save current progress with: ') + pc.white('nativ session save --summary "..."\n'));
+        return sessions;
+    }
+    for (const s of sessions) {
+        const roleTag = s.role ? pc.magenta(`[${s.role}] `) : '';
+        const taskTag = s.taskId ? pc.yellow(`[${s.taskId}] `) : '';
+        console.log(`  ${pc.bold(pc.yellow(s.sessionId))} ${pc.dim(s.timestamp)} ${roleTag}${taskTag}\n    ${pc.white(s.summary)}`);
+    }
+    console.log();
+    return sessions;
+}
+export async function runSessionGet(sessionId, targetDirArg, options = {}) {
+    const targetDir = path.resolve(targetDirArg || process.cwd());
+    const session = sessionId ? getSession(targetDir, sessionId) : getLatestSession(targetDir);
+    if (options.json) {
+        console.log(JSON.stringify(session, null, 2));
+        return session;
+    }
+    if (!session) {
+        console.log(pc.yellow(`\nNo session found${sessionId ? ` matching [${sessionId}]` : ''}.\n`));
+        return null;
+    }
+    console.log(pc.bold(pc.cyan(`\nSession Details: `)) + pc.yellow(`[${session.sessionId}]`));
+    console.log(pc.bold('  Timestamp:  ') + pc.dim(session.timestamp));
+    if (session.taskId)
+        console.log(pc.bold('  Task ID:    ') + pc.yellow(session.taskId));
+    if (session.role)
+        console.log(pc.bold('  Role:       ') + pc.magenta(session.role));
+    console.log(pc.bold('  Summary:    ') + pc.white(session.summary));
+    if (session.decisions && session.decisions.length > 0) {
+        console.log(pc.bold('\n  Key Decisions:'));
+        for (const d of session.decisions)
+            console.log(pc.dim('   • ') + pc.white(d));
+    }
+    if (session.obstacles && session.obstacles.length > 0) {
+        console.log(pc.bold('\n  Obstacles / Blockers:'));
+        for (const o of session.obstacles)
+            console.log(pc.red('   ✖ ') + pc.white(o));
+    }
+    if (session.nextSteps && session.nextSteps.length > 0) {
+        console.log(pc.bold('\n  Next Steps:'));
+        for (const n of session.nextSteps)
+            console.log(pc.cyan('   → ') + pc.white(n));
+    }
+    if (session.activeFiles && session.activeFiles.length > 0) {
+        console.log(pc.bold('\n  Active Files: ') + pc.dim(session.activeFiles.join(', ')));
+    }
+    console.log();
+    return session;
+}

package/dist/commands/task.js

@@ -1,13 +1,15 @@
 import path from 'node:path';
 import pc from 'picocolors';
 import { isSubagentType, SUBAGENT_TYPES, validateMasterPlanTask, } from '../scanner/types.js';
-import { applyCodeShape, executeVerification } from '../core/verifier.js';
-import { ContractGovernor, CircuitBreaker, TestIntegrityGuard, resolveGitHead, appendEscalation, } from '../governor/index.js';
+import { runTaskVerification } from '../core/verifier.js';
+import { ContractGovernor, CircuitBreaker, TestIntegrityGuard, resolveGitHead, appendEscalation, taskEscalationHistory, closeEscalationsForTask, } from '../governor/index.js';
 import { loadPlan, savePlan, withPlanLock } from '../core/lock-manager.js';
 import { recordTaskStart, recordTaskComplete } from '../core/telemetry.js';
 import { resolveSpecSlices } from '../core/spec-slices.js';
 import { resolveWorkerModel } from '../core/model-routing.js';
 import { addTaskUnlock, removeTaskUnlock } from '../core/enforcement.js';
+import { refuseHeadless } from '../core/human-gate.js';
+import { learningsForTask } from '../core/learnings.js';
 export { loadPlan, savePlan, withPlanLock };
 function getPlanPath(targetDirArg) {
     const targetDir = path.resolve(targetDirArg || process.cwd());
@@ -257,11 +259,14 @@ export async function runTaskNext(targetDirArg, options = {}) {
     }
     const roleGuide = getRoleGuide(targetTask.assignedSubagent);
     const contractSlice = getRecommendedContractSlice(targetTask.assignedSubagent);
+    const projectRoot = path.dirname(path.dirname(planPath));
+    const learnings = learningsForTask(projectRoot, targetTask);
+    const priorEscalations = taskEscalationHistory(projectRoot, targetTask.id);
     if (options.json) {
         const specResult = targetTask.specRefs?.length
-            ? resolveSpecSlices(path.dirname(path.dirname(planPath)), targetTask.specRefs)
+            ? resolveSpecSlices(projectRoot, targetTask.specRefs)
             : null;
-        const recommendedModel = resolveWorkerModel(path.dirname(path.dirname(planPath)), targetTask);
+        const recommendedModel = resolveWorkerModel(projectRoot, targetTask);
         console.log(JSON.stringify({
             status: 'ready',
             milestoneId: activeMilestone.id,
@@ -272,6 +277,8 @@ export async function runTaskNext(targetDirArg, options = {}) {
                 recommendedContractSlice: contractSlice,
                 ...(recommendedModel ? { recommendedModel } : {}),
                 ...(specResult ? { specSlices: specResult.slices, ...(specResult.warnings.length ? { specWarnings: specResult.warnings } : {}) } : {}),
+                ...(learnings.length ? { learnings: learnings.map(toTaskLearning) } : {}),
+                ...(priorEscalations.length ? { priorEscalations } : {}),
             }
         }, null, 2));
         return;
@@ -294,12 +301,23 @@ export async function runTaskNext(targetDirArg, options = {}) {
     if (targetTask.notes) {
         console.log(pc.bold(`  Notes:             `) + pc.red(targetTask.notes));
     }
+    for (const l of learnings) {
+        console.log(pc.bold(`  Learning:          `) + pc.white(`${l.id} ${l.insight}`));
+    }
+    for (const e of priorEscalations) {
+        const outcome = e.resolutionNotes ? ` -> ${e.resolutionNotes}` : '';
+        console.log(pc.bold(`  Past escalation:   `) + pc.white(`${e.id} ${e.status}: ${e.summary}${outcome}`));
+    }
     console.log(pc.dim('\n─── Quick CLI Actions ──────────────────────────────────────────'));
     console.log(pc.dim('  Start task:   ') + pc.white(`nativ task start ${targetTask.id}`));
     console.log(pc.dim('  Complete task:') + pc.white(`nativ task complete ${targetTask.id}`));
     console.log(pc.dim('  Block task:   ') + pc.white(`nativ task block ${targetTask.id} --reason "..."`));
     console.log(pc.dim('  Escalate task:') + pc.white(`nativ task escalate ${targetTask.id} --type schema_flaw --details "..."\n`));
 }
+/** What a worker needs from a lesson; status and audit fields stay in .ai/learnings.json. */
+function toTaskLearning({ id, insight, details, files }) {
+    return { id, insight, ...(details ? { details } : {}), ...(files ? { files } : {}) };
+}
 export async function runTaskStart(taskId, targetDirArg) {
     const { targetDir, planPath } = getPlanPath(targetDirArg);
     return withPlanLock(planPath, async (plan, ctx) => {
@@ -347,6 +365,8 @@ export async function runTaskStart(taskId, targetDirArg) {
  * tool: an agent must not be able to remove its own guardrail.
  */
 export async function runTaskUnlock(taskId, targetDirArg, options = {}) {
+    if (!options.revoke && refuseHeadless('nativ task unlock'))
+        return;
     const { targetDir, planPath } = getPlanPath(targetDirArg);
     const plan = loadPlan(planPath);
     if (!plan) {
@@ -368,6 +388,8 @@ export async function runTaskUnlock(taskId, targetDirArg, options = {}) {
     console.log(pc.dim('  .ai/ contracts and secret files stay protected. Re-lock with `nativ task unlock ' + taskId + ' --revoke`.\n'));
 }
 export async function runTaskComplete(taskId, targetDirArg, options = {}) {
+    if (options.skipVerify && refuseHeadless('nativ task complete --no-verify'))
+        return;
     const { targetDir, planPath } = getPlanPath(targetDirArg);
     const plan = loadPlan(planPath);
     if (!plan) {
@@ -425,11 +447,13 @@ export async function runTaskComplete(taskId, targetDirArg, options = {}) {
     // ── Verification Gatekeeper ────────────────────────────────────────────────
     let vResult = null;
     if (!options.skipVerify) {
-        const rawResult = await executeVerification(foundTask.verificationCommand, targetDir, options.timeout);
-        vResult = applyCodeShape(rawResult, targetDir, foundTask);
+        vResult = await runTaskVerification(foundTask, { cwd: targetDir, timeout: options.timeout });
         if (!vResult.success) {
             console.error(pc.red(`\n✖ Task [${pc.bold(taskId)}] verification FAILED with exit code ${vResult.exitCode}:`));
-            console.error(pc.yellow(`  Command: \`${foundTask.verificationCommand}\``));
+            const failedPhase = vResult.phases?.find((p) => !p.success);
+            if (failedPhase)
+                console.error(pc.yellow(`  Phase:   ${failedPhase.name}`));
+            console.error(pc.yellow(`  Command: \`${vResult.command}\``));
             if (vResult.stderr && vResult.stderr.trim()) {
                 console.error(pc.red('\n--- stderr ---'));
                 console.error(pc.red(vResult.stderr.trim()));
@@ -507,6 +531,9 @@ export async function runTaskComplete(taskId, targetDirArg, options = {}) {
     });
     CircuitBreaker.recordSuccess(targetDir, taskId);
     CircuitBreaker.clearBaseline(targetDir, taskId);
+    const closed = closeEscalationsForTask(targetDir, taskId, 'Closed automatically: the task was completed.');
+    if (closed.length)
+        console.log(pc.dim(`  Closed its open escalations: ${closed.join(', ')}`));
     try {
         await recordTaskComplete(targetDir, foundTask, vResult, options.notes);
     }

package/dist/commands/verify.js

@@ -32,11 +32,17 @@ export async function runVerify(taskId, targetDirArg, options = {}) {
             console.log(pc.green(`  ✔ [${pc.bold(t.taskId)}] ${t.title}`) +
                 pc.dim(` (${elapsed}s)`) +
                 pc.yellow(` \`${t.result.command}\``));
+            if (t.result.phases?.length) {
+                console.log(pc.dim(`    Phases passed: ${t.result.phases.map((p) => p.name).join(', ')}`));
+            }
         }
         else {
             console.log(pc.red(`  ✖ [${pc.bold(t.taskId)}] ${t.title}`) +
                 pc.dim(` (${elapsed}s, exit code: ${t.result.exitCode})`) +
                 pc.yellow(` \`${t.result.command}\``));
+            const failedPhase = t.result.phases?.find((p) => !p.success);
+            if (failedPhase)
+                console.log(pc.red(`    Failed in phase "${failedPhase.name}"`));
             if (t.result.stderr && t.result.stderr.trim()) {
                 console.log(pc.red(`\n--- [${t.taskId}] stderr ---`));
                 console.log(pc.red(t.result.stderr.trim()));

package/dist/core/code-shape.js

@@ -1,5 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { parseJsonLoose } from './enforcement.js';
+import { resolveMainRoot } from './root-resolver.js';
 const DEFAULTS = { mode: 'warn', maxLineLength: 120, maxCommentLines: 2 };
 const SOURCE_EXTENSIONS = new Set([
     '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rs', '.java', '.kt', '.dart',
@@ -10,8 +12,8 @@ const MAX_SHOWN = 10;
 export function loadCodeShapeSettings(targetDir) {
     const settings = { ...DEFAULTS };
     try {
-        const raw = fs.readFileSync(path.join(targetDir, '.nativ', 'config.json'), 'utf8');
-        const style = JSON.parse(raw)?.codeStyle;
+        const raw = fs.readFileSync(path.join(resolveMainRoot(targetDir), '.nativ', 'config.json'), 'utf8');
+        const style = parseJsonLoose(raw)?.codeStyle;
         if (!style || typeof style !== 'object')
             return settings;
         if (['warn', 'block', 'off'].includes(style.mode))

package/dist/core/enforcement.d.ts

@@ -55,6 +55,7 @@ export declare function toProjectRelative(root: string, filePath: string, cwd: s
 /** A target entry matches an exact file, a directory prefix (`src/x` or `src/x/`), or a glob. */
 export declare function matchesTarget(relPath: string, target: string): boolean;
 export declare function isSecretPath(relPath: string): boolean;
+export declare function isNativSettingsPath(relPath: string): boolean;
 /** Everything under `.ai/` is written by nativ commands or the architect, never by a worker's file tools. */
 export declare function isProtectedContractPath(relPath: string): boolean;
 /**

package/dist/core/enforcement.js

@@ -12,7 +12,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { EXAMPLE_ENV_FILES } from '../db/env-parser.js';
-import { resolveProjectRoot } from './root-resolver.js';
+import { resolveMainRoot, resolveProjectRoot } from './root-resolver.js';
 export const DEFAULT_ENFORCEMENT_MODE = 'warn';
 /** Roles other than these are treated as ordinary workers. The architect is the only role that may edit contracts. */
 export const ARCHITECT_ROLE = 'architect';
@@ -151,6 +151,9 @@ export function isSecretPath(relPath) {
         return true;
     return base.endsWith('.pem') || base.endsWith('.key');
 }
+export function isNativSettingsPath(relPath) {
+    return relPath === '.nativ' || relPath.toLowerCase().startsWith('.nativ/');
+}
 /** Everything under `.ai/` is written by nativ commands or the architect, never by a worker's file tools. */
 export function isProtectedContractPath(relPath) {
     return relPath === '.ai' || relPath.toLowerCase().startsWith('.ai/');
@@ -185,8 +188,18 @@ function verdict(mode, root, relPath, taskIds, rule, reason) {
  */
 export function checkWrite(input) {
     const root = resolveProjectRoot(input.cwd);
-    const mode = input.mode ?? loadEnforcementMode(root);
-    const relPath = toProjectRelative(root, input.filePath, input.cwd);
+    // Settings and unlocks live in the main checkout; a worktree's own copy must not decide them.
+    const mainRoot = resolveMainRoot(input.cwd);
+    const mode = input.mode ?? loadEnforcementMode(mainRoot);
+    let relPath = toProjectRelative(root, input.filePath, input.cwd);
+    if (relPath === null && mainRoot !== root) {
+        // A worktree session can reach the main checkout through ../..; judge those paths as its own.
+        const mainRel = toProjectRelative(mainRoot, input.filePath, input.cwd);
+        const guarded = (p) => isSecretPath(p) || isNativSettingsPath(p) || isProtectedContractPath(p);
+        if (mainRel !== null && guarded(mainRel)) {
+            relPath = mainRel;
+        }
+    }
     const allow = { decision: 'allow', mode, root, relPath, taskIds: [] };
     if (mode === 'off' || relPath === null)
         return allow;
@@ -195,6 +208,11 @@ export function checkWrite(input) {
     }
     const role = (input.role ?? process.env[ROLE_ENV] ?? '').toLowerCase();
     const isArchitect = ARCHITECT_ROLES.has(role);
+    // The settings decide what the gate runs and how strict the hook is, so no agent edits them.
+    if (isNativSettingsPath(relPath)) {
+        const reason = `${relPath} holds nativ settings, which only the operator changes. Ask the human to edit it.`;
+        return verdict(mode, root, relPath, [], 'protected_path', reason);
+    }
     if (isProtectedContractPath(relPath)) {
         if (isArchitect)
             return allow;
@@ -212,7 +230,7 @@ export function checkWrite(input) {
             tasks = own;
     }
     const taskIds = tasks.map((t) => t.id);
-    if (tasks.some((t) => isTaskUnlocked(root, t.id)))
+    if (tasks.some((t) => isTaskUnlocked(mainRoot, t.id)))
         return { ...allow, taskIds };
     if (tasks.some((t) => t.targetFiles.some((target) => matchesTarget(relPath, target))))
         return { ...allow, taskIds };

package/dist/core/harness-integrity.d.ts

@@ -0,0 +1,15 @@
+/**
+ * nativ · Checks that the harness itself is intact: nothing switches the guardrails off, no secret
+ * sits in a file agents read, every role a task names has a guide. Findings never include a secret.
+ */
+export type CheckStatus = 'ok' | 'warn' | 'fail' | 'info';
+export interface IntegrityFinding {
+    id: string;
+    status: CheckStatus;
+    message: string;
+    /** `guardrail` and `secret` findings decide whether doctor may report the harness as clean. */
+    category: 'guardrail' | 'secret' | 'roles' | 'learnings' | 'specs';
+}
+export declare function checkHarnessIntegrity(root: string, options?: {
+    templatesDir?: string;
+}): IntegrityFinding[];