@njeybe/nativ 2.8.0 → 2.9.1

package/dist/commands/task/task-add.js

@@ -1,6 +1,9 @@
 import pc from 'picocolors';
 import { isSubagentType, SUBAGENT_TYPES, validateMasterPlanTask, } from '../../scanner/types.js';
+import { configuredInvocation } from '../../core/setup/setup-planner.js';
+import { cliString, resolveCliInvocation } from '../../core/setup/types.js';
 import { withPlanLock } from '../../core/lock-manager.js';
+import { archivedTaskIds } from '../../core/milestone-archive.js';
 import { getPlanPath, getRoleGuide, } from './task-common.js';
 export const FAST_PATH_MILESTONE_NAME = 'Fast-Path Tasks';
 /** Next `<prefix><n>` after the highest existing number, keeping that ID's zero-padding. */
@@ -23,7 +26,8 @@ function nextNumberedId(ids, prefix, defaultWidth) {
     return candidate;
 }
 export function generateNextTaskId(plan) {
-    return nextNumberedId(plan.milestones.flatMap((m) => m.tasks.map((t) => t.id)), 'task-', 2);
+    const live = plan.milestones.flatMap((m) => m.tasks.map((t) => t.id));
+    return nextNumberedId([...live, ...archivedTaskIds(plan)], 'task-', 2);
 }
 export function generateNextMilestoneId(plan) {
     return nextNumberedId(plan.milestones.map((m) => m.id), 'm', 1);
@@ -43,6 +47,15 @@ function failTaskAdd(code, message, json) {
     process.exitCode = 1;
     return null;
 }
+/** Default check for a docs task: `nativ check docs` on its markdown files, or '' without any. */
+function defaultDocsCheck(targetFiles) {
+    const docs = targetFiles.filter((f) => /\.md$/i.test(f));
+    if (!docs.length)
+        return '';
+    const root = process.cwd();
+    const cli = cliString(configuredInvocation(root) ?? resolveCliInvocation({}));
+    return `${cli} check docs ${docs.join(' ')}`;
+}
 /** Resolves a milestone by exact ID, exact name, or a unique partial name (all case-insensitive). */
 function findMilestone(plan, query) {
     const q = query.trim().toLowerCase();
@@ -76,7 +89,10 @@ export async function runTaskAdd(title, targetDirArg, options = {}) {
             ctx.abort();
             return failTaskAdd('INVALID_AGENT', `Unknown sub-agent "${agent}". Expected one of: ${SUBAGENT_TYPES.join(', ')}`, options.json);
         }
-        const existingIds = new Set(plan.milestones.flatMap((m) => m.tasks.map((t) => t.id)));
+        const existingIds = new Set([
+            ...plan.milestones.flatMap((m) => m.tasks.map((t) => t.id)),
+            ...archivedTaskIds(plan),
+        ]);
         const deps = [...new Set(splitList(options.deps))];
         const unknownDeps = deps.filter((d) => !existingIds.has(d));
         if (unknownDeps.length) {
@@ -86,7 +102,29 @@ export async function runTaskAdd(title, targetDirArg, options = {}) {
         const fastPath = options.fastPath === true;
         let milestone;
         let createdMilestone = false;
-        if (options.milestone) {
+        const newName = options.newMilestone?.trim();
+        if (options.newMilestone !== undefined && !newName) {
+            ctx.abort();
+            return failTaskAdd('INVALID_MILESTONE_NAME', 'A new milestone needs a name', options.json);
+        }
+        if (newName && (options.milestone || fastPath)) {
+            ctx.abort();
+            return failTaskAdd('CONFLICTING_OPTIONS', '--new-milestone cannot be used with --milestone or --fast-path', options.json);
+        }
+        const stillOpen = plan.milestones.filter((m) => !m.fastPath && m.status !== 'completed');
+        if (newName && stillOpen.length && !options.force) {
+            ctx.abort();
+            const ids = stillOpen.map((m) => m.id).join(', ');
+            return failTaskAdd('MILESTONE_STILL_OPEN', `Milestone ${ids} is not completed yet. Finish it first, or pass --force`, options.json);
+        }
+        if (newName) {
+            milestone = { id: generateNextMilestoneId(plan), name: newName, status: 'in_progress', tasks: [] };
+            plan.milestones.push(milestone);
+            plan.activeMilestoneId = milestone.id;
+            plan.overallStatus = 'in_progress';
+            createdMilestone = true;
+        }
+        else if (options.milestone) {
             const found = findMilestone(plan, options.milestone);
             if (Array.isArray(found)) {
                 ctx.abort();
@@ -99,7 +137,7 @@ export async function runTaskAdd(title, targetDirArg, options = {}) {
             milestone = found;
         }
         else if (fastPath) {
-            milestone = plan.milestones.find((m) => m.fastPath === true);
+            milestone = plan.milestones.find((m) => m.fastPath === true && !m.archived);
             if (!milestone) {
                 milestone = { id: generateNextMilestoneId(plan), name: FAST_PATH_MILESTONE_NAME, status: 'pending', fastPath: true, tasks: [] };
                 plan.milestones.push(milestone);
@@ -114,25 +152,40 @@ export async function runTaskAdd(title, targetDirArg, options = {}) {
                 return failTaskAdd('NO_OPEN_MILESTONE', 'Every milestone is completed. Pass --milestone <id> to reopen one, or --fast-path', options.json);
             }
         }
+        if (milestone.archived) {
+            ctx.abort();
+            const how = `Restore it first with: nativ milestone restore ${milestone.id}`;
+            return failTaskAdd('MILESTONE_ARCHIVED', `Milestone ${milestone.id} is archived. ${how}`, options.json);
+        }
         const specRefs = [...new Set(splitList(options.specRefs))];
         const acceptanceCriteria = (Array.isArray(options.accept) ? options.accept : options.accept ? [options.accept] : [])
-            .flatMap((item) => item.split('|'))
             .map((item) => item.trim())
             .filter(Boolean);
         const complexity = options.complexity?.trim().toLowerCase();
+        const kind = options.kind?.trim().toLowerCase();
+        const notes = (options.notes ?? '').trim();
+        if (kind === 'manual' && !notes) {
+            ctx.abort();
+            return failTaskAdd('MANUAL_NEEDS_NOTES', 'A manual check needs --notes saying what the person must confirm', options.json);
+        }
+        const files = splitList(options.files);
+        let verify = (options.verify ?? '').trim();
+        if (kind === 'docs' && !verify)
+            verify = defaultDocsCheck(files);
         const task = {
             id: generateNextTaskId(plan),
             title: cleanTitle,
             description: (options.description ?? '').trim(),
             assignedSubagent: agent,
             dependencies: deps,
-            targetFiles: splitList(options.files),
+            targetFiles: files,
             status: 'pending',
-            verificationCommand: (options.verify ?? '').trim(),
-            notes: (options.notes ?? '').trim(),
+            verificationCommand: verify,
+            notes,
             ...(fastPath ? { fastPath: true } : {}),
             ...(specRefs.length ? { specRefs } : {}),
             ...(complexity ? { complexity: complexity } : {}),
+            ...(kind ? { verificationKind: kind } : {}),
             ...(acceptanceCriteria.length ? { acceptanceCriteria } : {}),
         };
         const problems = validateMasterPlanTask(task);
@@ -154,7 +207,7 @@ export async function runTaskAdd(title, targetDirArg, options = {}) {
         const track = fastPath ? pc.magenta(' [fast path]') : '';
         console.log(pc.green(`\n✔ Task [${pc.bold(task.id)}] added to [${milestone.id}] ${milestone.name}`) + track);
         if (createdMilestone)
-            console.log(pc.cyan(`  Created fast-path milestone [${milestone.id}]`));
+            console.log(pc.cyan(`  Created ${fastPath ? 'fast-path ' : ''}milestone [${milestone.id}]`));
         if (reopenedMilestone)
             console.log(pc.yellow(`  Reopened completed milestone [${milestone.id}]`));
         console.log(pc.dim('  Title:    ') + task.title);

package/dist/commands/task/task-common.d.ts

@@ -34,8 +34,14 @@ export interface TaskAddOptions {
     specRefs?: string | string[];
     /** simple | standard | complex. */
     complexity?: string;
+    /** unit | integration | static-config | docs | probe | manual. */
+    kind?: string;
     /** "Done when" lines: an array, or one string with "|" separators. */
     accept?: string | string[];
+    /** Create the next milestone with this name and add the task to it. */
+    newMilestone?: string;
+    /** With newMilestone, allow it while a planned milestone is still open (CLI only). */
+    force?: boolean;
     json?: boolean;
 }
 export interface TaskAddResult {

package/dist/commands/task/task-lifecycle.d.ts

@@ -7,5 +7,7 @@ export interface TaskStartOptions {
 }
 export declare function runTaskStart(taskId: string, targetDirArg?: string, options?: TaskStartOptions): Promise<void | null>;
 export declare function runTaskUnlock(taskId: string, targetDirArg?: string, options?: TaskUnlockOptions): Promise<void>;
-export declare function runTaskComplete(taskId: string, targetDirArg?: string, options?: TaskCompleteOptions): Promise<void>;
+export declare function runTaskComplete(taskId: string, targetDirArg?: string, options?: TaskCompleteOptions & {
+    isolation?: string;
+}): Promise<void>;
 export declare function runTaskBlock(taskId: string, reason: string, targetDirArg?: string): Promise<void | null>;

package/dist/commands/task/task-lifecycle.js

@@ -1,5 +1,12 @@
+import path from 'node:path';
+import { withArchivedAsDone } from '../../core/milestone-archive.js';
 import pc from 'picocolors';
+import { archivedTaskMessage, findArchivedMilestoneId } from './task-show.js';
+import { parseIsolation } from '../verify.js';
+import { resolveActiveProfileSettings } from '../../core/profiles.js';
+import { resolveMainRoot } from '../../core/root-resolver.js';
 import { runTaskVerification } from '../../core/verifier.js';
+import { evaluateSkip } from '../../core/verifier/skip-policy.js';
 import { digestFailure } from '../../core/verifier/output-digest.js';
 import { CircuitBreaker, TestIntegrityGuard, resolveGitHead, closeEscalationsForTask, } from '../../governor/index.js';
 import { loadPlan, withPlanLock } from '../../core/lock-manager.js';
@@ -26,11 +33,15 @@ export async function runTaskStart(taskId, targetDirArg, options = {}) {
         }
         if (!foundTask) {
             ctx.abort();
-            console.error(pc.red(`\n✖ Task [${taskId}] not found in .ai/master_plan.json\n`));
+            const archivedIn = findArchivedMilestoneId(plan, taskId);
+            const why = archivedIn
+                ? archivedTaskMessage(taskId, archivedIn)
+                : `Task [${taskId}] not found in .ai/master_plan.json`;
+            console.error(pc.red(`\n✖ ${why}\n`));
             process.exitCode = 1;
             return;
         }
-        const refusal = options.force ? null : startRefusal(plan, foundTask, agent);
+        const refusal = options.force ? null : startRefusal(withArchivedAsDone(plan), foundTask, agent);
         if (refusal) {
             ctx.abort();
             console.error(pc.red(`\n✖ ${refusal}\n`));
@@ -91,6 +102,23 @@ export async function runTaskUnlock(taskId, targetDirArg, options = {}) {
 export async function runTaskComplete(taskId, targetDirArg, options = {}) {
     if (options.skipVerify && refuseHeadless('nativ task complete --no-verify'))
         return;
+    let isolation;
+    try {
+        isolation = parseIsolation(options);
+    }
+    catch (e) {
+        console.error(pc.red(`
+✖ ${e.message}
+`));
+        process.exitCode = 1;
+        return;
+    }
+    const root = resolveMainRoot(path.resolve(targetDirArg || process.cwd()));
+    const profile = resolveActiveProfileSettings(root);
+    if (isolation === 'none' &&
+        profile.verifyIsolationFailure === 'block' &&
+        refuseHeadless('nativ task complete --isolation none'))
+        return;
     const { targetDir, planPath } = getPlanPath(targetDirArg);
     const plan = loadPlan(planPath);
     if (!plan) {
@@ -145,7 +173,7 @@ export async function runTaskComplete(taskId, targetDirArg, options = {}) {
     // ── Verification Gatekeeper ────────────────────────────────────────────────
     let vResult = null;
     if (!options.skipVerify) {
-        vResult = await runTaskVerification(foundTask, { cwd: targetDir, timeout: options.timeout });
+        vResult = await runTaskVerification(foundTask, { cwd: targetDir, timeout: options.timeout, isolation });
         if (!vResult.success) {
             console.error(pc.red(`\n✖ Task [${pc.bold(taskId)}] verification FAILED with exit code ${vResult.exitCode}:`));
             const failedPhase = vResult.phases?.find((p) => !p.success);
@@ -173,11 +201,27 @@ export async function runTaskComplete(taskId, targetDirArg, options = {}) {
             return;
         }
         if (vResult.skipped) {
+            const skip = evaluateSkip(foundTask, profile.skippedCheck);
+            if (skip.action === 'block') {
+                console.error(pc.red(`
+✖ Task [${pc.bold(taskId)}] cannot complete: ${skip.message}`));
+                console.error(pc.yellow(`  Task remains '${foundTask.status}'.
+`));
+                process.exitCode = 1;
+                return;
+            }
+            if (skip.action === 'warn')
+                console.log(pc.yellow(`
+⚠ ${skip.message}`));
             console.log(pc.dim(`\n○ Verification skipped: no verification command specified for [${taskId}]`));
         }
         else {
             const elapsed = (vResult.durationMs / 1000).toFixed(2);
-            console.log(pc.green(`\n✔ Verification passed (${elapsed}s): `) + pc.yellow(`\`${foundTask.verificationCommand}\``));
+            const used = vResult.isolation ?? 'none';
+            console.log(pc.green(`\n✔ Verification passed (${elapsed}s, isolation: ${used}): `) +
+                pc.yellow(`\`${foundTask.verificationCommand}\``));
+            for (const w of vResult.warnings ?? [])
+                console.log(pc.yellow(`  ⚠ ${w}`));
         }
     }
     else {

package/dist/commands/task/task-query.js

@@ -5,6 +5,7 @@ import { resolveSpecSlices } from '../../core/spec-slices.js';
 import { resolveWorkerModel } from '../../core/model-routing.js';
 import { learningsForTask } from '../../core/learnings.js';
 import { taskEscalationHistory } from '../../governor/index.js';
+import { archivedTaskIds } from '../../core/milestone-archive.js';
 import { getPlanPath, getRoleGuide, getRecommendedContractSlice } from './task-common.js';
 export async function runTaskList(targetDirArg, options = {}) {
     const { planPath } = getPlanPath(targetDirArg);
@@ -13,7 +14,7 @@ export async function runTaskList(targetDirArg, options = {}) {
         process.exitCode = 1;
         return;
     }
-    const completedTaskIds = new Set();
+    const completedTaskIds = new Set(archivedTaskIds(plan));
     for (const m of plan.milestones) {
         for (const t of m.tasks) {
             if (t.status === 'completed') {
@@ -120,6 +121,7 @@ function briefTask(t, milestoneId, isAvailable) {
         isAvailable,
         ...(t.dependencies?.length ? { dependencies: t.dependencies } : {}),
         ...(t.targetFiles?.length ? { targetFiles: t.targetFiles } : {}),
+        ...(t.fastPath ? { fastPath: true } : {}),
         ...(t.status === 'blocked' && t.notes ? { notes: t.notes } : {}),
     };
 }
@@ -134,7 +136,7 @@ export async function runTaskNext(targetDirArg, options = {}) {
         process.exitCode = 1;
         return;
     }
-    const completedTaskIds = new Set();
+    const completedTaskIds = new Set(archivedTaskIds(plan));
     for (const m of plan.milestones) {
         for (const t of m.tasks) {
             if (t.status === 'completed') {

package/dist/commands/task/task-show.d.ts

@@ -0,0 +1,9 @@
+import { MasterPlan } from '../../scanner/types.js';
+export interface TaskShowOptions {
+    json?: boolean;
+}
+/** The sentence shown when someone acts on a task that moved to an archive file. */
+export declare function archivedTaskMessage(taskId: string, milestoneId: string): string;
+export declare function findArchivedMilestoneId(plan: MasterPlan, taskId: string): string | undefined;
+/** Prints one task from the plan or, when archived, from its archive file. */
+export declare function runTaskShow(taskId: string, targetDirArg?: string, options?: TaskShowOptions): Promise<void>;

package/dist/commands/task/task-show.js

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+import { loadPlan } from '../../core/lock-manager.js';
+import { getPlanPath } from './task-common.js';
+/** The sentence shown when someone acts on a task that moved to an archive file. */
+export function archivedTaskMessage(taskId, milestoneId) {
+    return `Task [${taskId}] is archived (milestone ${milestoneId}). `
+        + `Run \`nativ milestone restore ${milestoneId}\` to bring its tasks back first.`;
+}
+export function findArchivedMilestoneId(plan, taskId) {
+    return plan.milestones.find((m) => m.archived?.taskIds.includes(taskId))?.id;
+}
+function readFromArchive(targetDir, plan, taskId) {
+    const milestone = plan.milestones.find((m) => m.archived?.taskIds.includes(taskId));
+    if (!milestone?.archived)
+        return null;
+    const file = path.join(targetDir, milestone.archived.file);
+    const saved = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const task = saved.tasks.find((t) => t.id === taskId);
+    if (!task)
+        throw new Error(`${milestone.archived.file} has no task ${taskId}`);
+    return { task, milestoneId: milestone.id };
+}
+function findTask(targetDir, plan, taskId) {
+    for (const m of plan.milestones) {
+        const task = m.tasks.find((t) => t.id === taskId);
+        if (task)
+            return { task, milestoneId: m.id, archived: false };
+    }
+    const found = readFromArchive(targetDir, plan, taskId);
+    return found && { ...found, archived: true };
+}
+/** Prints one task from the plan or, when archived, from its archive file. */
+export async function runTaskShow(taskId, targetDirArg, options = {}) {
+    const { targetDir, planPath } = getPlanPath(targetDirArg);
+    const plan = loadPlan(planPath);
+    if (!plan) {
+        process.exitCode = 1;
+        return;
+    }
+    let found;
+    try {
+        found = findTask(targetDir, plan, taskId);
+    }
+    catch (err) {
+        console.error(pc.red(`\n✖ The archive of task [${taskId}] cannot be read: ${err.message}\n`));
+        process.exitCode = 1;
+        return;
+    }
+    if (!found) {
+        console.error(pc.red(`\n✖ Task [${taskId}] not found in .ai/master_plan.json\n`));
+        process.exitCode = 1;
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify({ ...found.task, milestoneId: found.milestoneId, archived: found.archived }, null, 2));
+        return;
+    }
+    const { task } = found;
+    const where = found.archived ? `${found.milestoneId}, archived` : found.milestoneId;
+    console.log(pc.bold(pc.cyan(`\n[${task.id}] ${task.title}`)) + pc.dim(` (${where})`));
+    console.log(`  Status: ${task.status} | Agent: ${task.assignedSubagent}`);
+    console.log(`  Verify: \`${task.verificationCommand || 'none'}\``);
+    if (task.dependencies?.length)
+        console.log(`  Depends on: ${task.dependencies.join(', ')}`);
+    if (task.targetFiles?.length)
+        console.log(`  Files: ${task.targetFiles.join(', ')}`);
+    if (task.description)
+        console.log(`\n${task.description}`);
+    if (task.notes)
+        console.log(pc.dim(`\nNotes: ${task.notes}`));
+    console.log('');
+}

package/dist/commands/update.d.ts

@@ -1,6 +1,7 @@
 export interface UpdateOptions {
     /** Also replace directive and role-guide files that were edited by hand. */
     force?: boolean;
+    gitVisibility?: 'hidden' | 'shared';
 }
 /**
  * `nativ update`: brings a project up to the current templates without destroying its own work.

package/dist/commands/update.js

@@ -110,7 +110,7 @@ export async function runUpdate(targetDirArg, options = {}) {
     kept += syncTasteBundle(templatesDir, aiDir, options.force);
     // 2. Everything `nativ setup` manages: AGENTS.md, .claude/agents/, settings, MCP server
     console.log(pc.bold('\nClaude Code configuration'));
-    const setup = applySetup(targetDir, { force: options.force });
+    const setup = applySetup(targetDir, { force: options.force, gitVisibility: options.gitVisibility });
     printSetupResult(setup);
     // 3. Backfill missing core contracts safely (NEVER overwrite existing project state)
     console.log(pc.bold('\nContracts'));

package/dist/commands/validate.js

@@ -33,6 +33,24 @@ export async function runValidate(targetDirArg) {
         console.log(pc.green(`  ✔ Present: ${relPath}`));
         return content;
     }
+    function checkArchive(m) {
+        const rel = `.ai/archive/${m.id}.json`;
+        let saved;
+        try {
+            saved = JSON.parse(fs.readFileSync(path.join(targetDir, rel), 'utf8'));
+        }
+        catch (err) {
+            console.log(pc.red(`  ✖ Archive file of ${m.id} is missing or unreadable: ${rel} (${err.message})`));
+            return false;
+        }
+        const ids = Array.isArray(saved?.tasks) ? saved.tasks.map((t) => t.id) : null;
+        if (saved?.id !== m.id || JSON.stringify(ids) !== JSON.stringify(m.archived.taskIds)) {
+            console.log(pc.red(`  ✖ ${rel} does not match the archived stub of ${m.id}`));
+            return false;
+        }
+        console.log(pc.green(`  ✔ Archive matches: ${rel}`));
+        return true;
+    }
     // Directives tell agents how to work; they are guidance, not contracts, and GEMINI.md is only an optional adapter guide.
     console.log(pc.bold('1. Directives:'));
     const directives = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'].filter((f) => fs.existsSync(path.join(targetDir, f)));
@@ -66,6 +84,12 @@ export async function runValidate(targetDirArg) {
         for (const w of specWarnings)
             console.log(pc.yellow(`  ⚠ ${w}`));
     }
+    if (plan && Array.isArray(plan.milestones)) {
+        for (const m of plan.milestones) {
+            if (m?.archived && !checkArchive(m))
+                hasErrors = true;
+        }
+    }
     const escalationPath = path.join(targetDir, '.ai/escalation.json');
     if (fs.existsSync(escalationPath)) {
         const escData = checkFile('.ai/escalation.json', true);

package/dist/commands/verify.d.ts

@@ -4,5 +4,12 @@ export interface VerifyOptions {
     milestone?: string;
     json?: boolean;
     timeout?: number;
+    isolation?: string;
+    clean?: boolean;
 }
+/** Reads --isolation / --clean; undefined means use the profile. */
+export declare function parseIsolation(o: {
+    isolation?: string;
+    clean?: boolean;
+}): 'none' | 'clean' | undefined;
 export declare function runVerify(taskId?: string, targetDirArg?: string, options?: VerifyOptions): Promise<BatchVerificationResult>;

package/dist/commands/verify.js

@@ -1,6 +1,9 @@
 import path from 'node:path';
 import pc from 'picocolors';
 import { verifyBatch } from '../core/verifier.js';
+import { loadPlan } from '../core/lock-manager.js';
+import { evaluateSkip } from '../core/verifier/skip-policy.js';
+import { resolveActiveProfileSettings } from '../core/profiles.js';
 import { digestFailure } from '../core/verifier/output-digest.js';
 /** Passing runs need no output; failing ones get a digest and the path to the full log. */
 function compactBatch(batch, root) {
@@ -14,6 +17,15 @@ function compactBatch(batch, root) {
         }),
     };
 }
+/** Reads --isolation / --clean; undefined means use the profile. */
+export function parseIsolation(o) {
+    const v = o.clean ? 'clean' : o.isolation;
+    if (v === undefined)
+        return undefined;
+    if (v !== 'none' && v !== 'clean')
+        throw new Error(`--isolation must be none or clean, got "${v}"`);
+    return v;
+}
 export async function runVerify(taskId, targetDirArg, options = {}) {
     const targetDir = path.resolve(targetDirArg || process.cwd());
     const batch = await verifyBatch(targetDir, {
@@ -21,6 +33,7 @@ export async function runVerify(taskId, targetDirArg, options = {}) {
         milestoneId: options.milestone,
         all: options.all,
         timeout: options.timeout,
+        isolation: parseIsolation(options),
     });
     if (options.json) {
         console.log(JSON.stringify(compactBatch(batch, targetDir)));
@@ -35,24 +48,35 @@ export async function runVerify(taskId, targetDirArg, options = {}) {
         console.log(pc.yellow('No candidate tasks found to verify. Specify a taskId, --milestone, or --all.\n'));
         return batch;
     }
+    const skipMode = resolveActiveProfileSettings(targetDir).skippedCheck;
+    const plan = loadPlan(path.join(targetDir, '.ai', 'master_plan.json'), { silent: true });
+    const planTasks = plan?.milestones.flatMap((m) => m.tasks) ?? [];
     for (const t of batch.tasks) {
         const elapsed = (t.result.durationMs / 1000).toFixed(2);
         if (t.result.skipped) {
             console.log(pc.dim(`  ○ [${t.taskId}] ${t.title} — no verification command (skipped)`));
+            const pt = planTasks.find((x) => x.id === t.taskId);
+            const skip = pt && evaluateSkip(pt, skipMode);
+            if (skip?.message)
+                console.log(pc.yellow(`    ⚠ ${skip.message}`));
             continue;
         }
         if (t.result.success) {
             console.log(pc.green(`  ✔ [${pc.bold(t.taskId)}] ${t.title}`) +
-                pc.dim(` (${elapsed}s)`) +
+                pc.dim(` (${elapsed}s, isolation: ${t.result.isolation ?? 'none'})`) +
                 pc.yellow(` \`${t.result.command}\``));
+            for (const w of t.result.warnings ?? [])
+                console.log(pc.yellow(`    ⚠ ${w}`));
             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.dim(` (${elapsed}s, exit ${t.result.exitCode}, isolation: ${t.result.isolation ?? 'none'})`) +
                 pc.yellow(` \`${t.result.command}\``));
+            for (const w of t.result.warnings ?? [])
+                console.log(pc.yellow(`    ⚠ ${w}`));
             const failedPhase = t.result.phases?.find((p) => !p.success);
             if (failedPhase)
                 console.log(pc.red(`    Failed in phase "${failedPhase.name}"`));

package/dist/core/checks/docs-check.d.ts

@@ -0,0 +1,18 @@
+/** One nativ command: its own flags and its subcommands. */
+export interface CommandSpec {
+    flags: string[];
+    subs: Record<string, CommandSpec>;
+}
+export interface DocFinding {
+    file: string;
+    line: number;
+    kind: 'path' | 'placeholder' | 'setting' | 'flag';
+    token: string;
+    message: string;
+}
+export interface DocsContext {
+    root: string;
+    envNames: Set<string>;
+    program: CommandSpec;
+}
+export declare function checkDocText(text: string, docFile: string, ctx: DocsContext): DocFinding[];