@njeybe/nativ 2.5.1 → 2.7.0

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

@@ -24,22 +24,22 @@ export function getRoleGuide(assignedSubagent) {
 export function getRecommendedContractSlice(assignedSubagent) {
     const sub = assignedSubagent.toLowerCase();
     if (sub.includes('frontend') || sub.includes('flutter')) {
-        return '.ai/ui_specs.md (UI tokens & hierarchy) + .ai/api_contracts.json (Client endpoint integration)';
+        return '.ai/ui_specs.md + .ai/api_contracts.json';
     }
     if (sub.includes('backend')) {
-        return '.ai/api_contracts.json (Endpoint routes, request/response schemas) + .ai/db_schema.json (Models)';
+        return '.ai/api_contracts.json + .ai/db_schema.json';
     }
     if (sub.includes('database') || sub.includes('db-migration')) {
-        return '.ai/db_schema.json (Database schema contract & models)';
+        return '.ai/db_schema.json';
     }
     if (sub.includes('devops')) {
-        return '.ai/context.md (Infrastructure, runtime & deployment guardrails)';
+        return '.ai/context.md';
     }
     if (sub.includes('security')) {
-        return 'Target files & dependency manifests (.ai/context.md security guardrails)';
+        return 'targetFiles + dependency manifests + .ai/context.md';
     }
     if (sub.includes('qa')) {
-        return 'Target files, .ai/api_contracts.json, and verification test suite';
+        return 'targetFiles + .ai/api_contracts.json';
     }
     return '.ai/context.md';
 }

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

@@ -1,9 +1,17 @@
 import path from 'node:path';
 import pc from 'picocolors';
+import { ESCALATION_TYPES, } from '../../scanner/types.js';
 import { ContractGovernor, appendEscalation, } from '../../governor/index.js';
 import { withPlanLock } from '../../core/lock-manager.js';
 import { getPlanPath } from './task-common.js';
 export async function runTaskEscalate(taskId, targetDirArg, options = {}) {
+    const requestedType = options.type?.trim();
+    if (requestedType && !ESCALATION_TYPES.includes(requestedType)) {
+        console.error(pc.red(`\n✖ Unknown escalation type "${requestedType}". Use one of: ${ESCALATION_TYPES.join(', ')}\n`));
+        process.exitCode = 1;
+        return;
+    }
+    const escType = (requestedType || 'architectural_ambiguity');
     const { targetDir, planPath } = getPlanPath(targetDirArg);
     return withPlanLock(planPath, (plan, ctx) => {
         let foundTask = null;
@@ -20,16 +28,6 @@ export async function runTaskEscalate(taskId, targetDirArg, options = {}) {
             process.exitCode = 1;
             return;
         }
-        const validTypes = [
-            'contract_drift',
-            'schema_flaw',
-            'missing_credential',
-            'dependency_conflict',
-            'architectural_ambiguity',
-        ];
-        const escType = (options.type && validTypes.includes(options.type))
-            ? options.type
-            : 'architectural_ambiguity';
         const affectedContracts = options.affected
             ? options.affected.split(',').map((s) => s.trim())
             : ['.ai/db_schema.json', '.ai/api_contracts.json'];

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

@@ -1,5 +1,11 @@
 import { TaskUnlockOptions, TaskCompleteOptions } from './task-common.js';
-export declare function runTaskStart(taskId: string, targetDirArg?: string): Promise<void | null>;
+export interface TaskStartOptions {
+    /** Who claims the task; defaults to NATIV_AGENT_ID. */
+    agent?: string;
+    /** Human override: start a blocked task or one whose dependencies are unfinished. */
+    force?: boolean;
+}
+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 runTaskBlock(taskId: string, reason: string, targetDirArg?: string): Promise<void | null>;

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

@@ -1,13 +1,18 @@
 import pc from 'picocolors';
 import { runTaskVerification } from '../../core/verifier.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';
 import { recordTaskStart, recordTaskComplete } from '../../core/telemetry.js';
 import { addTaskUnlock, removeTaskUnlock } from '../../core/enforcement.js';
 import { refuseHeadless } from '../../core/human-gate.js';
+import { resolveAgentId, startRefusal } from '../../core/task-claims.js';
 import { getPlanPath, } from './task-common.js';
-export async function runTaskStart(taskId, targetDirArg) {
+export async function runTaskStart(taskId, targetDirArg, options = {}) {
+    if (options.force && refuseHeadless('nativ task start --force'))
+        return;
     const { targetDir, planPath } = getPlanPath(targetDirArg);
+    const agent = resolveAgentId(options.agent);
     return withPlanLock(planPath, async (plan, ctx) => {
         let foundTask = null;
         let foundMilestone = null;
@@ -25,7 +30,20 @@ export async function runTaskStart(taskId, targetDirArg) {
             process.exitCode = 1;
             return;
         }
+        const refusal = options.force ? null : startRefusal(plan, foundTask, agent);
+        if (refusal) {
+            ctx.abort();
+            console.error(pc.red(`\n✖ ${refusal}\n`));
+            process.exitCode = 1;
+            return;
+        }
+        const resumed = foundTask.status === 'in_progress';
         foundTask.status = 'in_progress';
+        foundTask.claimedAt = new Date().toISOString();
+        if (agent)
+            foundTask.claimedBy = agent;
+        else if (!resumed)
+            delete foundTask.claimedBy;
         if (foundMilestone.status === 'pending') {
             foundMilestone.status = 'in_progress';
         }
@@ -134,17 +152,20 @@ export async function runTaskComplete(taskId, targetDirArg, options = {}) {
             if (failedPhase)
                 console.error(pc.yellow(`  Phase:   ${failedPhase.name}`));
             console.error(pc.yellow(`  Command: \`${vResult.command}\``));
-            if (vResult.stderr && vResult.stderr.trim()) {
+            const digest = digestFailure(targetDir, taskId, vResult);
+            if (digest.stderr) {
                 console.error(pc.red('\n--- stderr ---'));
-                console.error(pc.red(vResult.stderr.trim()));
+                console.error(pc.red(digest.stderr));
             }
-            if (vResult.stdout && vResult.stdout.trim() && !vResult.stderr?.trim()) {
+            if (digest.stdout) {
                 console.error(pc.dim('\n--- stdout ---'));
-                console.error(pc.dim(vResult.stdout.trim()));
+                console.error(pc.dim(digest.stdout));
             }
             if (vResult.error && !vResult.stderr?.includes(vResult.error)) {
                 console.error(pc.red(`\nError: ${vResult.error}`));
             }
+            if (digest.logFile)
+                console.error(pc.dim(`\n  Full output: ${digest.logFile}`));
             console.error(pc.yellow(`\n⚠ Task remains '${foundTask.status}'. Fix the issue and retry:`));
             console.error(pc.white(`  nativ task complete ${taskId}`));
             console.error(pc.dim('  (or pass --no-verify to bypass verification check)\n'));
@@ -189,6 +210,8 @@ export async function runTaskComplete(taskId, targetDirArg, options = {}) {
             return;
         }
         taskToComplete.status = 'completed';
+        delete taskToComplete.claimedBy;
+        delete taskToComplete.claimedAt;
         if (options.notes) {
             taskToComplete.notes = options.notes;
         }
@@ -246,6 +269,8 @@ export async function runTaskBlock(taskId, reason, targetDirArg) {
         }
         foundTask.status = 'blocked';
         foundTask.notes = reason.trim();
+        delete foundTask.claimedBy;
+        delete foundTask.claimedAt;
         console.log(pc.yellow(`\n⚠ Task [${pc.bold(taskId)}] marked as `) + pc.red('✖ blocked'));
         console.log(pc.dim(`  Reason: ${foundTask.notes}\n`));
     });

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

@@ -4,6 +4,8 @@ export declare function runTaskList(targetDirArg?: string, options?: {
     milestone?: string;
     fastPath?: boolean;
     json?: boolean;
+    /** JSON only: id, title, status, role, dependencies and files; leaves out long prose fields. */
+    brief?: boolean;
 }): Promise<void>;
 export declare function runTaskNext(targetDirArg?: string, options?: {
     json?: boolean;

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

@@ -48,15 +48,17 @@ export async function runTaskList(targetDirArg, options = {}) {
         }
     }
     if (options.json) {
-        const jsonOutput = results.map(({ task, milestoneId, milestoneName, isAvailable }) => ({
-            ...task,
-            milestoneId,
-            milestoneName,
-            isAvailable,
-            roleGuide: getRoleGuide(task.assignedSubagent),
-            contractSlice: getRecommendedContractSlice(task.assignedSubagent),
-        }));
-        console.log(JSON.stringify(jsonOutput, null, 2));
+        const jsonOutput = results.map(({ task, milestoneId, milestoneName, isAvailable }) => options.brief
+            ? briefTask(task, milestoneId, isAvailable)
+            : {
+                ...task,
+                milestoneId,
+                milestoneName,
+                isAvailable,
+                roleGuide: getRoleGuide(task.assignedSubagent),
+                contractSlice: getRecommendedContractSlice(task.assignedSubagent),
+            });
+        console.log(JSON.stringify(jsonOutput));
         return;
     }
     console.log(pc.bold(pc.cyan(`\n📋 nativ Tasks: ${plan.projectName}`)));
@@ -108,6 +110,19 @@ export async function runTaskList(targetDirArg, options = {}) {
         pc.gray(`${pendingCount} pending`) + pc.dim(', ') +
         pc.red(`${blockedCount} blocked`) + '\n');
 }
+function briefTask(t, milestoneId, isAvailable) {
+    return {
+        id: t.id,
+        title: t.title,
+        status: t.status,
+        role: t.assignedSubagent,
+        milestoneId,
+        isAvailable,
+        ...(t.dependencies?.length ? { dependencies: t.dependencies } : {}),
+        ...(t.targetFiles?.length ? { targetFiles: t.targetFiles } : {}),
+        ...(t.status === 'blocked' && t.notes ? { notes: t.notes } : {}),
+    };
+}
 /** 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 } : {}) };
@@ -168,7 +183,7 @@ export async function runTaskNext(targetDirArg, options = {}) {
         }
         if (!activeMilestone) {
             if (options.json) {
-                console.log(JSON.stringify({ status: 'all_milestones_completed', activeTask: null }, null, 2));
+                console.log(JSON.stringify({ status: 'all_milestones_completed', activeTask: null }));
             }
             else {
                 console.log(pc.bold(pc.green('\n🎉 All milestones and tasks are completed!\n')));
@@ -196,7 +211,7 @@ export async function runTaskNext(targetDirArg, options = {}) {
                     milestoneId: activeMilestone.id,
                     milestoneName: activeMilestone.name,
                     activeTask: null,
-                }, null, 2));
+                }));
             }
             else {
                 if (hasBlocked) {
@@ -233,7 +248,7 @@ export async function runTaskNext(targetDirArg, options = {}) {
                 ...(learnings.length ? { learnings: learnings.map(toTaskLearning) } : {}),
                 ...(priorEscalations.length ? { priorEscalations } : {}),
             }
-        }, null, 2));
+        }));
         return;
     }
     const fastTag = targetTask.fastPath ? pc.cyan(' [FAST-PATH PRIORITY]') : '';

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

@@ -0,0 +1,20 @@
+export interface TaskReclaimOptions {
+    /** Claims at least this many hours old are abandoned (default 4). */
+    olderThan?: number;
+    dryRun?: boolean;
+    json?: boolean;
+    /** Human override: reclaim a named task even though its claim is fresh. */
+    force?: boolean;
+}
+export interface ReclaimedTask {
+    id: string;
+    claimedBy?: string;
+    ageHours: number | null;
+}
+export interface TaskReclaimResult {
+    reclaimed: ReclaimedTask[];
+    /** in_progress tasks with no claim time (started before claims existed): reclaim them by id. */
+    unknownAge: string[];
+}
+/** Puts in_progress tasks whose agent stopped (crash, closed session) back to pending so another agent can take them. */
+export declare function runTaskReclaim(taskId?: string, targetDirArg?: string, options?: TaskReclaimOptions): Promise<TaskReclaimResult | null>;

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

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import pc from 'picocolors';
+import { withPlanLock } from '../../core/lock-manager.js';
+import { refuseHeadless } from '../../core/human-gate.js';
+import { DEFAULT_STALE_HOURS, claimAgeHours } from '../../core/task-claims.js';
+import { getPlanPath } from './task-common.js';
+const round = (h) => (h === null ? null : Math.round(h * 10) / 10);
+/** Puts in_progress tasks whose agent stopped (crash, closed session) back to pending so another agent can take them. */
+export async function runTaskReclaim(taskId, targetDirArg, options = {}) {
+    const hours = options.olderThan ?? DEFAULT_STALE_HOURS;
+    const fail = (message) => {
+        if (options.json)
+            console.log(JSON.stringify({ ok: false, error: message }));
+        else
+            console.error(pc.red(`\n✖ ${message}\n`));
+        process.exitCode = 1;
+        return null;
+    };
+    if (!Number.isFinite(hours) || hours <= 0)
+        return fail('--older-than must be a positive number of hours');
+    if (options.force && refuseHeadless('nativ task reclaim --force'))
+        return null;
+    // `nativ task reclaim <dir>` reads naturally, so a lone existing directory is the target, not a task id.
+    if (taskId && !targetDirArg && fs.existsSync(taskId) && fs.statSync(taskId).isDirectory()) {
+        targetDirArg = taskId;
+        taskId = undefined;
+    }
+    const { planPath } = getPlanPath(targetDirArg);
+    const result = { reclaimed: [], unknownAge: [] };
+    let error = null;
+    let planRead = false;
+    await withPlanLock(planPath, (plan, ctx) => {
+        planRead = true;
+        const now = Date.now();
+        const inProgress = plan.milestones.flatMap((m) => m.tasks).filter((t) => t.status === 'in_progress');
+        if (taskId && !inProgress.some((t) => t.id === taskId)) {
+            error = `Task [${taskId}] is not in_progress, so there is nothing to reclaim.`;
+        }
+        for (const t of inProgress) {
+            if (error || (taskId && t.id !== taskId))
+                continue;
+            const age = claimAgeHours(t, now);
+            const stale = age !== null && age >= hours;
+            if (!taskId && age === null) {
+                result.unknownAge.push(t.id);
+                continue;
+            }
+            if (!stale && !(taskId && age === null) && !options.force) {
+                if (taskId)
+                    error = `Task [${t.id}] was claimed${t.claimedBy ? ` by ${t.claimedBy}` : ''} ${round(age)}h ago; its agent may still be working. A human can pass --force.`;
+                continue;
+            }
+            result.reclaimed.push({ id: t.id, ...(t.claimedBy ? { claimedBy: t.claimedBy } : {}), ageHours: round(age) });
+            if (options.dryRun)
+                continue;
+            t.status = 'pending';
+            delete t.claimedBy;
+            delete t.claimedAt;
+        }
+        if (error || options.dryRun || !result.reclaimed.length)
+            ctx.abort();
+    });
+    if (!planRead)
+        return fail(`No readable plan at ${planPath}`);
+    if (error)
+        return fail(error);
+    if (options.json) {
+        console.log(JSON.stringify({ ok: true, dryRun: Boolean(options.dryRun), olderThanHours: hours, ...result }));
+        return result;
+    }
+    const verb = options.dryRun ? 'Would reclaim' : 'Reclaimed';
+    if (!result.reclaimed.length)
+        console.log(pc.dim(`\nNo in_progress task has a claim older than ${hours}h.`));
+    for (const r of result.reclaimed) {
+        const who = r.claimedBy ? ` from ${r.claimedBy}` : '';
+        const age = r.ageHours === null ? '' : ` (${r.ageHours}h old)`;
+        console.log(pc.yellow(`\n↺ ${verb} [${pc.bold(r.id)}]${who}${age}: back to pending.`));
+    }
+    if (result.reclaimed.length && !options.dryRun) {
+        console.log(pc.dim('  The previous agent may have left partial changes in the working tree; review them before restarting.'));
+    }
+    if (result.unknownAge.length) {
+        console.log(pc.dim(`  No claim time on: ${result.unknownAge.join(', ')}. Reclaim one by id: nativ task reclaim <taskId>`));
+    }
+    console.log();
+    return result;
+}

package/dist/commands/task.d.ts

@@ -7,5 +7,7 @@ export { getRoleGuide, getRecommendedContractSlice, } from './task/task-common.j
 export type { TaskUnlockOptions, TaskCompleteOptions, TaskAddOptions, TaskAddResult, ProposePatchOptions, } from './task/task-common.js';
 export { runTaskList, runTaskNext } from './task/task-query.js';
 export { runTaskStart, runTaskComplete, runTaskBlock, runTaskUnlock, } from './task/task-lifecycle.js';
+export { runTaskReclaim } from './task/task-reclaim.js';
+export type { TaskReclaimOptions, TaskReclaimResult } from './task/task-reclaim.js';
 export { FAST_PATH_MILESTONE_NAME, generateNextTaskId, generateNextMilestoneId, runTaskAdd, } from './task/task-add.js';
 export { runTaskEscalate, runTaskProposePatch, } from './task/task-escalate.js';

package/dist/commands/task.js

@@ -6,5 +6,6 @@ export { loadPlan, savePlan, withPlanLock } from '../core/lock-manager.js';
 export { getRoleGuide, getRecommendedContractSlice, } from './task/task-common.js';
 export { runTaskList, runTaskNext } from './task/task-query.js';
 export { runTaskStart, runTaskComplete, runTaskBlock, runTaskUnlock, } from './task/task-lifecycle.js';
+export { runTaskReclaim } from './task/task-reclaim.js';
 export { FAST_PATH_MILESTONE_NAME, generateNextTaskId, generateNextMilestoneId, runTaskAdd, } from './task/task-add.js';
 export { runTaskEscalate, runTaskProposePatch, } from './task/task-escalate.js';

package/dist/commands/triage.js

@@ -18,7 +18,7 @@ export async function runTriage(escalationIdArg, targetDirArg, options = {}) {
     };
     const fail = (message) => {
         if (options.json)
-            print(JSON.stringify({ ok: false, error: message }, null, 2));
+            print(JSON.stringify({ ok: false, error: message }));
         else
             print(pc.red(`\nTriage failed: ${message}\n`));
         process.exitCode = 1;
@@ -76,7 +76,7 @@ export async function runTriage(escalationIdArg, targetDirArg, options = {}) {
         }
         if (!targets.length) {
             if (options.json)
-                print(JSON.stringify({ ok: true, evaluations: [] }, null, 2));
+                print(JSON.stringify({ ok: true, evaluations: [] }));
             else if (!pending.length)
                 print(pc.green('\nNo pending escalations. Nothing to triage.\n'));
             return [];
@@ -119,7 +119,7 @@ export async function runTriage(escalationIdArg, targetDirArg, options = {}) {
             }
         }
         if (options.json) {
-            print(JSON.stringify({ ok: results.every((r) => r.evaluation.ok), evaluations: results }, null, 2));
+            print(JSON.stringify({ ok: results.every((r) => r.evaluation.ok), evaluations: results }));
         }
         else {
             const evaluated = results.filter((r) => r.evaluation.ok).map((r) => r.evaluation);

package/dist/commands/update.js

@@ -1,10 +1,54 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 import pc from 'picocolors';
 import { detectProject } from '../scanner/detector.js';
 import { applySetup, getTemplatesDir, planTemplateFile } from '../core/setup-assets.js';
 import { printSetupResult } from './setup.js';
 import { runValidate } from './validate.js';
+const noCr = (text) => text.replace(/\r/g, '');
+function walkFiles(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir, { withFileTypes: true })
+        .flatMap((e) => (e.isDirectory() ? walkFiles(path.join(dir, e.name)) : [path.join(dir, e.name)]));
+}
+// Plain copies (no stamp) so doctor can compare them; edited files are kept unless forced.
+function syncTasteBundle(templatesDir, aiDir, force) {
+    const src = path.join(templatesDir, 'design', 'taste');
+    let kept = 0;
+    const manifestPath = path.join(aiDir, 'design', 'taste', '.manifest.json');
+    let manifest = {};
+    try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    }
+    catch { /* installed before manifests */ }
+    const hash = (t) => createHash('sha256').update(noCr(t)).digest('hex');
+    for (const file of walkFiles(src)) {
+        const rel = path.relative(src, file).split(path.sep).join('/');
+        const dest = path.join(aiDir, 'design', 'taste', ...rel.split('/'));
+        const text = fs.readFileSync(file, 'utf8');
+        const existing = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8') : null;
+        const shown = `.ai/design/taste/${rel}`;
+        if (existing !== null && noCr(existing) === noCr(text)) {
+            printChange({ path: shown, action: 'unchanged' });
+            manifest[rel] ??= hash(text);
+        }
+        else if (existing !== null && !force && manifest[rel] !== hash(existing)) {
+            kept++;
+            printChange({ path: shown, action: 'skipped', detail: 'differs from the template' });
+        }
+        else {
+            fs.mkdirSync(path.dirname(dest), { recursive: true });
+            fs.writeFileSync(dest, text, 'utf8');
+            manifest[rel] = hash(text);
+            printChange({ path: shown, action: existing === null ? 'created' : 'updated' });
+        }
+    }
+    fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n', 'utf8');
+    return kept;
+}
 const ICON = { created: '+', updated: '~', unchanged: '=', skipped: '!' };
 function printChange(change) {
     const paint = change.action === 'created' ? pc.green : change.action === 'updated' ? pc.cyan : change.action === 'skipped' ? pc.yellow : pc.dim;
@@ -62,6 +106,8 @@ export async function runUpdate(targetDirArg, options = {}) {
             kept++;
         printChange({ path: item.rel, action: plan.action, detail: plan.detail });
     }
+    console.log(pc.bold('\nDesign bundle'));
+    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 });

package/dist/commands/validate.js

@@ -82,6 +82,7 @@ export async function runValidate(targetDirArg) {
     checkFile('.ai/subagents/qa-tester.md');
     console.log(pc.dim('  Specialized Units:'));
     const specializedProfiles = [
+        'architect.md',
         'flutter-developer.md',
         'devops-agent.md',
         'security-auditor.md',

package/dist/commands/verify.js

@@ -1,6 +1,19 @@
 import path from 'node:path';
 import pc from 'picocolors';
 import { verifyBatch } from '../core/verifier.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) {
+    return {
+        ...batch,
+        tasks: batch.tasks.map((t) => {
+            if (t.result.success)
+                return { ...t, result: { ...t.result, stdout: '', stderr: '' } };
+            const { stdout, stderr, logFile } = digestFailure(root, t.taskId, t.result);
+            return { ...t, result: { ...t.result, stdout, stderr, logFile } };
+        }),
+    };
+}
 export async function runVerify(taskId, targetDirArg, options = {}) {
     const targetDir = path.resolve(targetDirArg || process.cwd());
     const batch = await verifyBatch(targetDir, {
@@ -10,7 +23,7 @@ export async function runVerify(taskId, targetDirArg, options = {}) {
         timeout: options.timeout,
     });
     if (options.json) {
-        console.log(JSON.stringify(batch, null, 2));
+        console.log(JSON.stringify(compactBatch(batch, targetDir)));
         if (batch.failed > 0) {
             process.exitCode = 1;
         }
@@ -43,17 +56,20 @@ export async function runVerify(taskId, targetDirArg, options = {}) {
             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()) {
+            const digest = digestFailure(targetDir, t.taskId, t.result);
+            if (digest.stderr) {
                 console.log(pc.red(`\n--- [${t.taskId}] stderr ---`));
-                console.log(pc.red(t.result.stderr.trim()));
+                console.log(pc.red(digest.stderr));
             }
-            if (t.result.stdout && t.result.stdout.trim() && !t.result.stderr?.trim()) {
+            if (digest.stdout) {
                 console.log(pc.dim(`\n--- [${t.taskId}] stdout ---`));
-                console.log(pc.dim(t.result.stdout.trim()));
+                console.log(pc.dim(digest.stdout));
             }
             if (t.result.error && !t.result.stderr?.includes(t.result.error)) {
                 console.log(pc.red(`\nError: ${t.result.error}`));
             }
+            if (digest.logFile)
+                console.log(pc.dim(`  Full output: ${digest.logFile}`));
             console.log('');
         }
     }

package/dist/core/design-rules.d.ts

@@ -0,0 +1,23 @@
+export declare const DESIGN_PROFILES: readonly ["taste-v1", "taste-v2"];
+export type DesignProfile = (typeof DESIGN_PROFILES)[number];
+export interface DesignFinding {
+    line: number;
+    column: number;
+    rule: string;
+    severity: 'error' | 'warning';
+    message: string;
+}
+interface Rule {
+    id: string;
+    profiles: readonly DesignProfile[];
+    severity: 'error' | 'warning';
+    message: string;
+    pattern?: RegExp;
+    exts?: readonly string[];
+}
+export declare const DESIGN_RULES: readonly Rule[];
+export declare const SCAN_EXTENSIONS: string[];
+export declare function readProfile(uiSpecsText: string): DesignProfile | null;
+export declare function isCommentLine(line: string): boolean;
+export declare function checkText(text: string, ext: string, profile: DesignProfile): DesignFinding[];
+export {};