@planu/cli 4.8.0 → 4.10.0

package/dist/storage/feedback-store.js

@@ -2,7 +2,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { withFileLock } from './file-mutex.js';
-import { sendFeedbackRemote } from './feedback-remote.js';
+import { deliverFeedbackRemote } from './feedback-remote.js';
 // ---------------------------------------------------------------------------
 // Path helpers
 // ---------------------------------------------------------------------------
@@ -37,6 +37,54 @@ function writeLedger(filePath, entries) {
     ensureDir(dirname(filePath));
     writeFileSync(filePath, JSON.stringify(entries, null, 2), 'utf-8');
 }
+function getRemoteStatus(entry) {
+    return entry.remoteDelivery?.status ?? 'pending';
+}
+function toRemotePayload(entry) {
+    return {
+        id: entry.id,
+        type: entry.type,
+        title: entry.title,
+        description: entry.description,
+        planuVersion: entry.planuVersion,
+        stack: entry.context?.stack,
+        tags: entry.tags,
+    };
+}
+function toRemoteDelivery(entry, result) {
+    const now = new Date().toISOString();
+    const previousAttempts = entry.remoteDelivery?.attemptCount ?? 0;
+    return {
+        status: result.status,
+        attemptCount: previousAttempts + 1,
+        lastAttemptAt: now,
+        ...(result.ok ? { lastSyncedAt: now } : {}),
+        ...(result.error !== undefined ? { lastError: result.error.slice(0, 300) } : {}),
+        ...(result.endpoint !== undefined ? { endpoint: result.endpoint } : {}),
+    };
+}
+async function updateRemoteDelivery(dataDir, id, result) {
+    const filePath = getFeedbackPath(dataDir);
+    return withFileLock(filePath, () => {
+        const entries = readLedger(filePath);
+        const idx = entries.findIndex((e) => e.id === id);
+        const existing = entries[idx];
+        if (idx === -1 || existing === undefined) {
+            return Promise.resolve(null);
+        }
+        const updated = {
+            ...existing,
+            remoteDelivery: toRemoteDelivery(existing, result),
+        };
+        entries[idx] = updated;
+        writeLedger(filePath, entries);
+        return Promise.resolve(updated);
+    });
+}
+async function deliverAndPersistRemote(dataDir, entry) {
+    const result = await deliverFeedbackRemote(toRemotePayload(entry));
+    return (await updateRemoteDelivery(dataDir, entry.id, result)) ?? entry;
+}
 // ---------------------------------------------------------------------------
 // ID generation
 // ---------------------------------------------------------------------------
@@ -144,18 +192,12 @@ export async function submitFeedback(dataDir, entry) {
             id,
             createdAt: new Date().toISOString(),
             planuVersion: version,
+            remoteDelivery: { status: 'pending', attemptCount: 0 },
         };
         entries.push(newEntry);
         writeLedger(filePath, entries);
-        void sendFeedbackRemote({
-            type: newEntry.type,
-            title: newEntry.title,
-            description: newEntry.description,
-            planuVersion: newEntry.planuVersion,
-            stack: newEntry.context?.stack,
-            tags: newEntry.tags,
-        }).catch((err) => {
-            console.error('[planu] sendFeedbackRemote failed:', err);
+        void deliverAndPersistRemote(dataDir, newEntry).catch((err) => {
+            console.error('[planu] feedback remote delivery failed:', err);
         });
         return Promise.resolve(newEntry);
     });
@@ -259,6 +301,61 @@ export function getSummary(dataDir) {
         topRequests,
     };
 }
+export function getFeedbackRemoteHealth(dataDir) {
+    const entries = readLedger(getFeedbackPath(dataDir));
+    const byRemoteStatus = {
+        pending: 0,
+        synced: 0,
+        failed: 0,
+        skipped: 0,
+    };
+    for (const entry of entries) {
+        byRemoteStatus[getRemoteStatus(entry)]++;
+    }
+    return {
+        byRemoteStatus,
+        retryable: byRemoteStatus.pending + byRemoteStatus.failed,
+    };
+}
+export async function syncFeedbackRemote(dataDir, input = {}) {
+    const limit = input.limit !== undefined && input.limit > 0 ? input.limit : Number.POSITIVE_INFINITY;
+    const entries = readLedger(getFeedbackPath(dataDir));
+    const summary = {
+        total: 0,
+        synced: 0,
+        failed: 0,
+        skipped: 0,
+        alreadySynced: 0,
+        processedIds: [],
+    };
+    for (const entry of entries) {
+        if (summary.total >= limit) {
+            break;
+        }
+        const status = getRemoteStatus(entry);
+        if (status === 'synced' && input.includeSynced !== true) {
+            summary.alreadySynced++;
+            continue;
+        }
+        if (!['pending', 'failed', 'skipped', 'synced'].includes(status)) {
+            continue;
+        }
+        summary.total++;
+        summary.processedIds.push(entry.id);
+        const updated = await deliverAndPersistRemote(dataDir, entry);
+        const updatedStatus = getRemoteStatus(updated);
+        if (updatedStatus === 'synced') {
+            summary.synced++;
+        }
+        else if (updatedStatus === 'skipped') {
+            summary.skipped++;
+        }
+        else {
+            summary.failed++;
+        }
+    }
+    return summary;
+}
 /**
  * Find feedback entries with title similar to the given string.
  * Uses Jaccard word overlap. Threshold defaults to 0.3.

package/dist/tools/feedback-handler.d.ts

@@ -1,5 +1,7 @@
-import type { ToolResult, SubmitFeedbackInput, TriageFeedbackInput, ResolveFeedbackInput } from '../types/index.js';
+import type { ToolResult, SubmitFeedbackInput, TriageFeedbackInput, ResolveFeedbackInput, SyncFeedbackInput, FeedbackStatusInput } from '../types/index.js';
 export declare function handleSubmitFeedback(input: SubmitFeedbackInput): Promise<ToolResult>;
 export declare function handleTriageFeedback(input: TriageFeedbackInput): ToolResult;
 export declare function handleResolveFeedback(input: ResolveFeedbackInput): Promise<ToolResult>;
+export declare function handleSyncFeedback(input: SyncFeedbackInput): Promise<ToolResult>;
+export declare function handleFeedbackStatus(input: FeedbackStatusInput): ToolResult;
 //# sourceMappingURL=feedback-handler.d.ts.map

package/dist/tools/feedback-handler.js

@@ -1,6 +1,6 @@
 // tools/feedback-handler.ts — Feedback Hub tool handlers (SPEC-188)
 import { join } from 'node:path';
-import { submitFeedback, getFeedback, resolveFeedback, findSimilar, } from '../storage/feedback-store.js';
+import { submitFeedback, getFeedback, resolveFeedback, findSimilar, getSummary, getFeedbackRemoteHealth, syncFeedbackRemote, } from '../storage/feedback-store.js';
 import { triageFeedback, formatTriageReport } from '../engine/feedback/triage.js';
 // ---------------------------------------------------------------------------
 // Default data directory
@@ -43,6 +43,7 @@ export async function handleSubmitFeedback(input) {
         `| Type | ${TYPE_EMOJI[feedbackType]} |`,
         `| Title | ${entry.title} |`,
         `| Status | Pending |`,
+        `| Remote Delivery | ${entry.remoteDelivery?.status ?? 'pending'} |`,
     ];
     if (topSimilar !== undefined) {
         lines.push('');
@@ -103,4 +104,49 @@ export async function handleResolveFeedback(input) {
     }
     return { content: [{ type: 'text', text: lines.join('\n') }] };
 }
+// ---------------------------------------------------------------------------
+// sync_feedback handler
+// ---------------------------------------------------------------------------
+export async function handleSyncFeedback(input) {
+    const dataDir = getDataDir(input.projectPath);
+    const summary = await syncFeedbackRemote(dataDir, input);
+    const lines = [
+        'Feedback remote sync complete.',
+        '',
+        '| Field | Value |',
+        '|-------|-------|',
+        `| Processed | ${summary.total} |`,
+        `| Synced | ${summary.synced} |`,
+        `| Failed | ${summary.failed} |`,
+        `| Skipped | ${summary.skipped} |`,
+        `| Already Synced | ${summary.alreadySynced} |`,
+    ];
+    if (summary.processedIds.length > 0) {
+        lines.push(`| Processed IDs | ${summary.processedIds.join(', ')} |`);
+    }
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+// ---------------------------------------------------------------------------
+// feedback_status handler
+// ---------------------------------------------------------------------------
+export function handleFeedbackStatus(input) {
+    const dataDir = getDataDir(input.projectPath);
+    const summary = getSummary(dataDir);
+    const remote = getFeedbackRemoteHealth(dataDir);
+    const lines = [
+        'Feedback status',
+        '',
+        '| Field | Value |',
+        '|-------|-------|',
+        `| Total | ${summary.total} |`,
+        `| Pending Local | ${summary.pending} |`,
+        `| Resolved Local | ${summary.resolved} |`,
+        `| Remote Pending | ${remote.byRemoteStatus.pending} |`,
+        `| Remote Synced | ${remote.byRemoteStatus.synced} |`,
+        `| Remote Failed | ${remote.byRemoteStatus.failed} |`,
+        `| Remote Skipped | ${remote.byRemoteStatus.skipped} |`,
+        `| Retryable | ${remote.retryable} |`,
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
 //# sourceMappingURL=feedback-handler.js.map

package/dist/tools/register-sdd-tools.d.ts

@@ -1,4 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare const OFFICIAL_SDD_TOOL_NAMES: readonly ["planu_status", "facilitate", "init_project", "clarify_requirements", "create_spec", "challenge_spec", "check_readiness", "update_status", "update_status_batch", "package_handoff", "validate", "reconcile_spec", "create_rule", "create_skill", "skill_search", "configure_code_graph", "code_graph_status"];
+export declare const OFFICIAL_SDD_TOOL_NAMES: readonly ["planu_status", "facilitate", "init_project", "clarify_requirements", "create_spec", "challenge_spec", "check_readiness", "update_status", "update_status_batch", "package_handoff", "validate", "reconcile_spec", "create_rule", "create_skill", "skill_search", "configure_code_graph", "code_graph_status", "submit_feedback", "triage_feedback", "resolve_feedback", "sync_feedback", "feedback_status"];
 export declare function registerSddTools(server: McpServer): void;
 //# sourceMappingURL=register-sdd-tools.d.ts.map

package/dist/tools/register-sdd-tools.js

@@ -30,6 +30,11 @@ export const OFFICIAL_SDD_TOOL_NAMES = [
     'skill_search',
     'configure_code_graph',
     'code_graph_status',
+    'submit_feedback',
+    'triage_feedback',
+    'resolve_feedback',
+    'sync_feedback',
+    'feedback_status',
 ];
 const OFFICIAL_SDD_TOOL_SET = new Set(OFFICIAL_SDD_TOOL_NAMES);
 const noop = () => undefined;

package/dist/tools/status-handler.js

@@ -27,19 +27,13 @@ const execFile = promisify(execFileCb);
 // ---------------------------------------------------------------------------
 async function getGitState(projectPath) {
     try {
-        const [statusResult, branchResult] = await Promise.all([
-            execFile('git', ['status', '--short'], { cwd: projectPath }),
+        const [stagedResult, modifiedResult, branchResult] = await Promise.all([
+            execFile('git', ['diff', '--cached', '--name-only'], { cwd: projectPath }),
+            execFile('git', ['diff', '--name-only'], { cwd: projectPath }),
             execFile('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: projectPath }),
         ]);
-        const lines = statusResult.stdout.trim().split('\n').filter(Boolean);
-        const staged = lines.filter((l) => {
-            const ch = l[0];
-            return ch !== ' ' && ch !== '?';
-        }).length;
-        const modified = lines.filter((l) => {
-            const ch = l[1];
-            return ch !== ' ' && ch !== '?';
-        }).length;
+        const staged = countGitPathLines(stagedResult.stdout);
+        const modified = countGitPathLines(modifiedResult.stdout);
         const branch = branchResult.stdout.trim();
         return { staged, modified, branch };
     }
@@ -47,6 +41,12 @@ async function getGitState(projectPath) {
         return null;
     }
 }
+function countGitPathLines(stdout) {
+    return stdout
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean).length;
+}
 // ---------------------------------------------------------------------------
 // CI state helpers
 // ---------------------------------------------------------------------------

package/dist/tools/tool-registry/core-tools.js

@@ -37,6 +37,7 @@ import { handleIdeConfig } from '../ide-config-handler.js';
 import { IdeTargetEnum, IdeConfigScopeEnum } from '../schemas/ide-config.js';
 import { handleReconcileSpecLiving } from '../reconcile-spec-living-handler.js';
 import { handleSecurityReport } from '../security-report-handler.js';
+import { handleFeedbackStatus, handleResolveFeedback, handleSubmitFeedback, handleSyncFeedback, handleTriageFeedback, } from '../feedback-handler.js';
 import { SecurityReportTimeRangeEnum, SecurityReportFormatEnum, } from '../schemas/runtime-security.js';
 import { RenderSpecForProviderInputSchema, handleRenderSpecForProvider, } from '../render-spec-for-provider.js';
 import { handleTriageRequest, TriageRequestInputSchema } from '../triage-request.js';
@@ -750,6 +751,102 @@ const coreToolsRegistry = [
         wrap: 'tracked',
         group: 'core',
     },
+    // ── feedback hub (SPEC-188, SPEC-1100) ───────────────────────────────────
+    {
+        name: 'submit_feedback',
+        description: 'Submit user feedback or a bug report to Planu Feedback Hub. Always persists locally first, then attempts privacy-bounded remote registration with the central feedback intake.',
+        schema: {
+            type: z
+                .enum(['bug', 'feature', 'suggestion', 'dx'])
+                .describe('Feedback type: bug | feature | suggestion | dx'),
+            title: z.string().min(1).max(200).describe('Short feedback title'),
+            description: z.string().min(1).max(5000).describe('Detailed feedback description'),
+            context: z
+                .object({
+                projectPath: z.string().max(4096).optional(),
+                currentFile: z.string().max(4096).optional(),
+                errorMessage: z.string().max(2000).optional(),
+                stack: z.string().max(8000).optional(),
+            })
+                .optional()
+                .describe('Optional local-only context; sensitive path fields are not sent remotely.'),
+        },
+        handler: async (args) => handleSubmitFeedback(args),
+        annotations: {
+            title: 'Submit Feedback',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        wrap: 'tracked',
+        group: 'feedback',
+    },
+    {
+        name: 'triage_feedback',
+        description: 'Group pending local feedback by similarity so maintainers can decide whether to create specs, merge duplicates, or dismiss items.',
+        schema: {
+            filter: z
+                .enum(['bug', 'feature', 'suggestion', 'dx'])
+                .optional()
+                .describe('Optional feedback type filter'),
+        },
+        handler: async (args) => Promise.resolve(handleTriageFeedback(args)),
+        annotations: { title: 'Triage Feedback', readOnlyHint: true },
+        wrap: 'tracked',
+        group: 'feedback',
+    },
+    {
+        name: 'resolve_feedback',
+        description: 'Mark a local feedback item as resolved and optionally link it to a Planu spec, PR URL, and resolution notes.',
+        schema: {
+            feedbackId: z.string().min(1).max(50).describe('Local feedback ID, e.g. FB-001'),
+            specId: z.string().max(50).optional().describe('Optional linked Planu spec ID'),
+            prUrl: z.url().optional().describe('Optional pull request URL'),
+            notes: z.string().max(2000).optional().describe('Optional resolution notes'),
+        },
+        handler: async (args) => handleResolveFeedback(args),
+        annotations: { title: 'Resolve Feedback', readOnlyHint: false, destructiveHint: false },
+        wrap: 'tracked',
+        group: 'feedback',
+    },
+    {
+        name: 'sync_feedback',
+        description: 'Retry remote Supabase registration for local feedback entries whose delivery is pending or failed. Does not accept remote row IDs or perform direct SQL/Data API writes.',
+        schema: {
+            projectPath: z.string().max(4096).optional().describe('Absolute path to project root'),
+            includeSynced: z
+                .boolean()
+                .optional()
+                .describe('When true, also reprocess entries already marked synced. Default false.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .max(500)
+                .optional()
+                .describe('Maximum number of local entries to process.'),
+        },
+        handler: async (args) => handleSyncFeedback(args),
+        annotations: {
+            title: 'Sync Feedback',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        wrap: 'tracked',
+        group: 'feedback',
+    },
+    {
+        name: 'feedback_status',
+        description: 'Show aggregate local feedback totals and remote delivery health without exposing descriptions, file paths, user identifiers, or secrets.',
+        schema: {
+            projectPath: z.string().max(4096).optional().describe('Absolute path to project root'),
+        },
+        handler: async (args) => Promise.resolve(handleFeedbackStatus(args)),
+        annotations: { title: 'Feedback Status', readOnlyHint: true },
+        wrap: 'tracked',
+        group: 'feedback',
+    },
 ];
 export default coreToolsRegistry;
 //# sourceMappingURL=core-tools.js.map

package/dist/tools/tool-registry.js

@@ -22,6 +22,9 @@ export function withToolTracking(server) {
                 // Return a wrapper function that calls the original method and captures the result
                 return (...args) => {
                     const name = args[0];
+                    if (registeredTools.has(name)) {
+                        throw new Error(`Duplicate MCP tool registration: ${name}`);
+                    }
                     const originalMethod = Reflect.get(target, prop, receiver);
                     const registered = originalMethod.apply(target, args);
                     registeredTools.set(name, registered);

package/dist/tools/validate-assurance.d.ts

@@ -0,0 +1,6 @@
+import { type NewCodeGateResult } from '../engine/ai-assurance/index.js';
+export declare function runAssuranceGates(projectPath: string): {
+    newCode: NewCodeGateResult;
+};
+export declare function checkPlanuUncommittedChanges(projectPath: string): boolean;
+//# sourceMappingURL=validate-assurance.d.ts.map

package/dist/tools/validate-assurance.js

@@ -0,0 +1,55 @@
+// tools/validate-assurance.ts — Validate assurance and local git helpers.
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { evaluateNewCodeGate } from '../engine/ai-assurance/index.js';
+export function runAssuranceGates(projectPath) {
+    return {
+        newCode: evaluateNewCodeGate(readChangedSpecLogicFiles(projectPath)),
+    };
+}
+function readChangedSpecLogicFiles(projectPath) {
+    let changedFiles;
+    try {
+        const output = execFileSync('git', [
+            '-C',
+            projectPath,
+            'diff',
+            '--name-only',
+            'HEAD',
+            '--',
+            'src/tools/create-spec',
+            'src/tools/validate.ts',
+            'src/engine',
+        ], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        changedFiles = output
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.endsWith('.ts'));
+    }
+    catch {
+        return [];
+    }
+    return changedFiles.flatMap((path) => {
+        try {
+            return [{ path, content: readFileSync(`${projectPath}/${path}`, 'utf-8') }];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export function checkPlanuUncommittedChanges(projectPath) {
+    try {
+        const output = execFileSync('git', ['status', '--porcelain', 'planu/'], {
+            cwd: projectPath,
+            encoding: 'utf-8',
+            timeout: 5_000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return output.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=validate-assurance.js.map

package/dist/tools/validate-graph-coverage.d.ts

@@ -0,0 +1,8 @@
+import type { GraphCoverageReport } from '../types/project-knowledge-graph.js';
+export declare function buildGraphCoverageReport(args: {
+    projectId: string;
+    projectPath: string;
+    specId: string;
+}): Promise<GraphCoverageReport>;
+export declare function formatGraphCoverageText(report: GraphCoverageReport): string;
+//# sourceMappingURL=validate-graph-coverage.d.ts.map

package/dist/tools/validate-graph-coverage.js

@@ -0,0 +1,30 @@
+// tools/validate-graph-coverage.ts — Graph coverage helpers for validate.
+import { queryProjectGraphSlice } from '../engine/project-graph/index.js';
+function graphCoverageGaps(slice) {
+    if (slice === null) {
+        return [];
+    }
+    const criteria = slice.nodes.filter((node) => node.type === 'criterion');
+    return criteria
+        .filter((criterion) => {
+        const outgoing = slice.edges.filter((edge) => edge.from === criterion.id);
+        return !outgoing.some((edge) => edge.type === 'implements' || edge.type === 'tests');
+    })
+        .map((criterion) => criterion.label)
+        .slice(0, 10);
+}
+export async function buildGraphCoverageReport(args) {
+    const graphSlice = await queryProjectGraphSlice(args).catch(() => null);
+    return {
+        freshness: graphSlice?.freshness,
+        gaps: graphCoverageGaps(graphSlice),
+        compactNodes: graphSlice?.nodes.length ?? 0,
+        compactEdges: graphSlice?.edges.length ?? 0,
+    };
+}
+export function formatGraphCoverageText(report) {
+    return report.gaps.length > 0
+        ? `\nGRAPH     ${String(report.gaps.length)} graph-backed coverage gap(s)`
+        : '';
+}
+//# sourceMappingURL=validate-graph-coverage.js.map

package/dist/tools/validate-helpers.d.ts

@@ -0,0 +1,9 @@
+import type { InteractiveQuestion } from '../types/clarification.js';
+import type { ToolResult } from '../types/index.js';
+export declare function validateStrictLayoutOrError(args: {
+    projectPath: string;
+    specId: string;
+    specPath?: string;
+}): Promise<ToolResult | null>;
+export declare function buildValidateFailureFallback(failedCount: number): InteractiveQuestion;
+//# sourceMappingURL=validate-helpers.d.ts.map

package/dist/tools/validate-helpers.js

@@ -0,0 +1,47 @@
+export async function validateStrictLayoutOrError(args) {
+    try {
+        const { validateStrictPlanuLayout } = await import('../engine/spec-migrator/index.js');
+        const layout = await validateStrictPlanuLayout(args.projectPath, {
+            specPath: args.specPath,
+            includeRoot: false,
+        });
+        if (layout.ok) {
+            return null;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Strict Planu layout validation failed for ${args.specId}.\n\n` +
+                        `Non-canonical paths:\n${layout.offenders.map((p) => `- ${p}`).join('\n')}\n\n` +
+                        `Canonical contract:\n${layout.contract}`,
+                },
+            ],
+            isError: true,
+            structuredContent: {
+                error: 'strict_planu_layout_violation',
+                offenders: layout.offenders,
+                contract: layout.contract,
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function buildValidateFailureFallback(failedCount) {
+    return {
+        header: 'Failures',
+        question: `${failedCount} criteria failed. How do you want to proceed?`,
+        multiSelect: false,
+        options: [
+            {
+                label: 're-implement',
+                description: 'Fix the failing criteria and run validate again (Recommended)',
+            },
+            { label: 'ignore', description: 'Ignore failures and proceed (not recommended)' },
+            { label: 'mark-manual', description: 'Mark as manually reviewed — will bypass auto-check' },
+        ],
+    };
+}
+//# sourceMappingURL=validate-helpers.js.map

package/dist/tools/validate-lint.d.ts

@@ -0,0 +1,3 @@
+import type { LintCheckResult } from '../types/index.js';
+export declare function runLintCheck(projectPath: string, lintCommand: string | null): LintCheckResult;
+//# sourceMappingURL=validate-lint.d.ts.map

package/dist/tools/validate-lint.js

@@ -0,0 +1,67 @@
+import { formatLintFailureDiagnostics, resolveProjectCommandPlan, runProjectCommandPlan, } from './validate-runtime.js';
+/** Allowlist: alphanumerics, spaces, and safe shell chars. Rejects ; | $ ` & < > */
+const SAFE_COMMAND_RE = /^[\w\s./:@~=-]+$/;
+const LINT_CHECK_TIMEOUT_MS = 50_000;
+function isSafeCommand(cmd) {
+    return SAFE_COMMAND_RE.test(cmd);
+}
+function isCommandTimeout(err) {
+    if (!(err instanceof Error)) {
+        return false;
+    }
+    const errorWithProcessFields = err;
+    return (errorWithProcessFields.signal === 'SIGTERM' ||
+        errorWithProcessFields.killed === true ||
+        errorWithProcessFields.code === 'ETIMEDOUT' ||
+        /timed out|timeout/i.test(err.message));
+}
+function commandOutput(err) {
+    if (!(err instanceof Error)) {
+        return String(err);
+    }
+    const errorWithOutput = err;
+    return [errorWithOutput.stdout, errorWithOutput.stderr]
+        .filter((chunk) => chunk !== undefined)
+        .map((chunk) => String(chunk))
+        .join('\n')
+        .trim();
+}
+function parseLintIssueCount(output) {
+    const m = /(\d+)\s+problem/i.exec(output);
+    if (m) {
+        return parseInt(m[1] ?? '0', 10);
+    }
+    return output.split('\n').filter((l) => l.trim().length > 0).length;
+}
+export function runLintCheck(projectPath, lintCommand) {
+    if (lintCommand !== null && !isSafeCommand(lintCommand)) {
+        console.warn(`[Planu] validate: lintCommand contains unsafe characters — skipping execution`);
+        return {
+            passed: true,
+            command: lintCommand,
+            issueCount: 0,
+            output: '(skipped — unsafe command)',
+        };
+    }
+    const command = lintCommand ?? 'pnpm lint';
+    const plan = resolveProjectCommandPlan(projectPath, command);
+    try {
+        runProjectCommandPlan(plan, projectPath, LINT_CHECK_TIMEOUT_MS);
+        return { passed: true, command, issueCount: 0, output: '' };
+    }
+    catch (err) {
+        if (isCommandTimeout(err)) {
+            const seconds = Math.round(LINT_CHECK_TIMEOUT_MS / 1000);
+            const output = `Lint command timed out after ${String(seconds)}s and was skipped so validate can complete within MCP request limits. ` +
+                `Run \`${plan.executedCommand}\` manually before marking the spec done.`;
+            console.warn(`[Planu] lintCheck timed out: command="${plan.executedCommand}" cwd="${projectPath}" timeoutMs=${String(LINT_CHECK_TIMEOUT_MS)}`);
+            return { passed: true, command, issueCount: 0, output };
+        }
+        const raw = commandOutput(err);
+        const output = formatLintFailureDiagnostics(plan, raw);
+        const issueCount = parseLintIssueCount(raw.trim());
+        console.warn(`[Planu] lintCheck failed: command="${plan.executedCommand}" cwd="${projectPath}" issues=${String(issueCount)}`);
+        return { passed: false, command, issueCount, output };
+    }
+}
+//# sourceMappingURL=validate-lint.js.map

package/dist/tools/validate-minimality.d.ts

@@ -0,0 +1,16 @@
+import type { MinimalImplementationReport } from '../types/minimal-implementation-gate.js';
+export declare function buildMinimalityReport(args: {
+    projectPath: string;
+    specId: string;
+    risk?: string;
+    title?: string;
+    missing: string[];
+    extra: string[];
+    qualityIssues: {
+        file: string;
+        rule: string;
+        message: string;
+        suggestion?: string;
+    }[];
+}): Promise<MinimalImplementationReport | null>;
+//# sourceMappingURL=validate-minimality.d.ts.map