@planu/cli 4.10.6 → 4.10.8

package/dist/tools/update-status/evidence-gate.js

@@ -7,6 +7,7 @@ import { buildSpecEvidenceIndex } from '../../engine/evidence-index/index-builde
 import { checkDoneDriftContract } from '../../engine/evidence-index/done-drift.js';
 import { parseTechnicalReferenceGroundingRecords } from '../../engine/spec-grounding/contract.js';
 import { extractAcceptanceCriteriaTexts } from '../../engine/spec-format/acceptance-criteria.js';
+import { formatKeyValue } from '../output-formatter.js';
 /** SPEC-1054: BDD/SDD lifecycle evidence gate. */
 export async function checkLifecycleEvidenceTransitionGate(args) {
     const [criteriaResult, artifacts] = await Promise.all([
@@ -69,15 +70,16 @@ function evidenceGateError(args) {
         content: [
             {
                 type: 'text',
-                text: JSON.stringify({
+                text: formatKeyValue({
                     error: 'lifecycle_evidence_gate_failed',
                     message: `BDD/SDD evidence gate blocked ${args.transition}.`,
                     specId: args.specId,
                     transition: args.transition,
-                    issues: args.issues,
-                    requiredContractKinds: args.requiredContractKinds,
+                    issues: args.issues.length,
+                    firstIssue: args.issues[0]?.message,
+                    requiredContractKinds: args.requiredContractKinds.length,
                     fixHint: 'Add the missing evidence artifact to the external Planu project data handoff store, then retry the transition. Do not create JSON files under planu/specs/<spec>/.',
-                }, null, 2),
+                }),
             },
         ],
         isError: true,

package/dist/tools/update-status/index.js

@@ -26,6 +26,7 @@ import { updateFrontmatterField } from '../../engine/frontmatter-parser.js';
 import { atomicWriteFile } from '../../engine/safety/atomic-write-file.js';
 import { recordForceUsage } from '../../storage/force-analytics-store.js';
 import { maybeSafePushOnDone, runCascadeForResponse } from './side-effects.js';
+import { formatKeyValue } from '../output-formatter.js';
 import { checkCodeReality } from '../../engine/code-scanner/index.js';
 import { scanCrashRisks } from '../../engine/crash-shield/index.js';
 import { shouldSkipCrashScan, recordCrashScanRun, } from '../../engine/autopilot/crash-shield-rate-limiter.js';
@@ -341,11 +342,11 @@ export async function handleUpdateStatus(params, server) {
                             content: [
                                 {
                                     type: 'text',
-                                    text: JSON.stringify({
+                                    text: formatKeyValue({
                                         error: 'invalid_input',
                                         message: reverseValidation.error,
                                         fixHint: reverseValidation.fixHint,
-                                    }, null, 2),
+                                    }),
                                 },
                             ],
                             isError: true,

package/dist/tools/update-status/transition-guard.js

@@ -8,6 +8,7 @@ import { checkReadinessInternal } from '../../engine/readiness-checker.js';
 import { validateEnglishOnlySpecText } from '../../engine/spec-language/english-only.js';
 import { checkGroundedSpecContract } from '../../engine/spec-grounding/contract.js';
 import { checkGenericSpecOutput } from '../../engine/spec-quality/generic-output-gate.js';
+import { formatKeyValue } from '../output-formatter.js';
 /**
  * Valid state transitions for spec lifecycle.
  * draft -> review -> approved -> implementing -> done
@@ -133,16 +134,29 @@ export function checkDorGate(spec, specId, projectId, newStatus) {
             content: [
                 {
                     type: 'text',
-                    text: JSON.stringify({
-                        error: 'DoR gate failed',
-                        message: dorResult.humanMessage,
-                        expertSummary: dorResult.expertSummary,
-                        blockingItems: dorResult.blockingItems,
-                        warningItems: dorResult.warningItems,
-                    }, null, 2),
+                    text: [
+                        dorResult.humanMessage,
+                        dorResult.expertSummary,
+                        ...dorResult.blockingItems.slice(0, 3).map((item) => `Blocker: ${item}`),
+                        dorResult.blockingItems.length > 3
+                            ? `More blockers: ${String(dorResult.blockingItems.length - 3)}`
+                            : undefined,
+                        dorResult.warningItems.length > 0
+                            ? `Warnings: ${String(dorResult.warningItems.length)}`
+                            : undefined,
+                    ]
+                        .filter(Boolean)
+                        .join('\n'),
                 },
             ],
             isError: true,
+            structuredContent: {
+                error: 'DoR gate failed',
+                message: dorResult.humanMessage,
+                expertSummary: dorResult.expertSummary,
+                blockingItems: dorResult.blockingItems,
+                warningItems: dorResult.warningItems,
+            },
         };
     }
     return null;
@@ -163,16 +177,24 @@ export async function checkAmbiguityGate(spec, newStatus) {
         content: [
             {
                 type: 'text',
-                text: JSON.stringify({
+                text: formatKeyValue({
                     error: 'Ambiguity gate failed',
                     message: `Ambiguity score ${String(report.score)}/100 — below 70. Fix vague terms in criteria before approving.`,
                     ambiguityScore: report.score,
-                    violations: report.violations.slice(0, 5),
-                    blockers: report.blockers.slice(0, 5),
-                }, null, 2),
+                    violations: report.violations.length,
+                    blockers: report.blockers.length,
+                    firstBlocker: report.blockers[0],
+                }, 'Ambiguity gate failed'),
             },
         ],
         isError: true,
+        structuredContent: {
+            error: 'Ambiguity gate failed',
+            message: `Ambiguity score ${String(report.score)}/100 — below 70. Fix vague terms in criteria before approving.`,
+            ambiguityScore: report.score,
+            violations: report.violations.slice(0, 5),
+            blockers: report.blockers.slice(0, 5),
+        },
     };
 }
 /**

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

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

package/dist/tools/validate-lint.js

@@ -1,7 +1,13 @@
+// tools/validate-lint.ts — Lint gate for validate.
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 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;
+const DEFAULT_LINT_CHECK_TIMEOUT_MS = 10_000;
+const LINT_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 function isSafeCommand(cmd) {
     return SAFE_COMMAND_RE.test(cmd);
 }
@@ -33,7 +39,7 @@ function parseLintIssueCount(output) {
     }
     return output.split('\n').filter((l) => l.trim().length > 0).length;
 }
-export function runLintCheck(projectPath, lintCommand) {
+export function runLintCheck(projectPath, lintCommand, _context = {}) {
     if (lintCommand !== null && !isSafeCommand(lintCommand)) {
         console.warn(`[Planu] validate: lintCommand contains unsafe characters — skipping execution`);
         return {
@@ -45,16 +51,23 @@ export function runLintCheck(projectPath, lintCommand) {
     }
     const command = lintCommand ?? 'pnpm lint';
     const plan = resolveProjectCommandPlan(projectPath, command);
+    const fingerprint = calculateLintFingerprint(projectPath);
+    const cached = readPassedLintCache(projectPath, command, fingerprint);
+    if (cached !== null) {
+        return cached;
+    }
+    const timeoutMs = lintCheckTimeoutMs();
     try {
-        runProjectCommandPlan(plan, projectPath, LINT_CHECK_TIMEOUT_MS);
+        runProjectCommandPlan(plan, projectPath, timeoutMs);
+        writePassedLintCache(projectPath, command, fingerprint);
         return { passed: true, command, issueCount: 0, output: '' };
     }
     catch (err) {
         if (isCommandTimeout(err)) {
-            const seconds = Math.round(LINT_CHECK_TIMEOUT_MS / 1000);
+            const seconds = Math.round(timeoutMs / 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)}`);
+                `Run \`${plan.executedCommand}\` manually before marking the spec done, or set PLANU_VALIDATE_LINT_TIMEOUT_MS for an explicit full lint pass.`;
+            console.warn(`[Planu] lintCheck timed out: command="${plan.executedCommand}" cwd="${projectPath}" timeoutMs=${String(timeoutMs)}`);
             return { passed: false, command, issueCount: 1, output };
         }
         const raw = commandOutput(err);
@@ -64,4 +77,124 @@ export function runLintCheck(projectPath, lintCommand) {
         return { passed: false, command, issueCount, output };
     }
 }
+function lintCheckTimeoutMs() {
+    const raw = process.env.PLANU_VALIDATE_LINT_TIMEOUT_MS;
+    if (raw === undefined || raw.trim() === '') {
+        return DEFAULT_LINT_CHECK_TIMEOUT_MS;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed)) {
+        return DEFAULT_LINT_CHECK_TIMEOUT_MS;
+    }
+    return Math.min(300_000, Math.max(1_000, parsed));
+}
+function lintCachePath(projectPath) {
+    return join(projectPath, 'planu', 'state', 'lint-evidence.json');
+}
+function readPassedLintCache(projectPath, command, fingerprint) {
+    try {
+        const path = lintCachePath(projectPath);
+        if (!existsSync(path)) {
+            return null;
+        }
+        const cache = JSON.parse(readFileSync(path, 'utf-8'));
+        if (cache.schemaVersion !== '1.0.0' ||
+            cache.command !== command ||
+            cache.fingerprint !== fingerprint ||
+            typeof cache.checkedAt !== 'string') {
+            return null;
+        }
+        const ageMs = Date.now() - Date.parse(cache.checkedAt);
+        if (!Number.isFinite(ageMs) || ageMs < 0 || ageMs > LINT_CACHE_MAX_AGE_MS) {
+            return null;
+        }
+        return {
+            passed: true,
+            command,
+            issueCount: 0,
+            output: `(reused local lint evidence from ${cache.checkedAt})`,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function writePassedLintCache(projectPath, command, fingerprint) {
+    try {
+        const path = lintCachePath(projectPath);
+        mkdirSync(dirname(path), { recursive: true });
+        const cache = {
+            schemaVersion: '1.0.0',
+            command,
+            fingerprint,
+            checkedAt: new Date().toISOString(),
+        };
+        writeFileSync(path, `${JSON.stringify(cache, null, 2)}\n`, 'utf-8');
+    }
+    catch {
+        // Cache is a performance optimization only; lint result remains authoritative.
+    }
+}
+function calculateLintFingerprint(projectPath) {
+    const hash = createHash('sha256');
+    hash.update(gitOutput(projectPath, ['rev-parse', 'HEAD']));
+    hash.update('\0');
+    hash.update(gitOutput(projectPath, [
+        'diff',
+        '--binary',
+        'HEAD',
+        '--',
+        'src',
+        'tests',
+        'package.json',
+        'pnpm-lock.yaml',
+        'eslint.config.js',
+        'eslint.config.mjs',
+        'eslint.config.cjs',
+        'tsconfig.json',
+        'tsconfig.build.json',
+    ]));
+    hash.update('\0');
+    const untracked = gitOutput(projectPath, [
+        'ls-files',
+        '--others',
+        '--exclude-standard',
+        '--',
+        'src',
+        'tests',
+    ])
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .sort();
+    for (const file of untracked) {
+        hash.update(file);
+        hash.update('\0');
+        try {
+            hash.update(readFileSync(join(projectPath, file)));
+        }
+        catch {
+            hash.update('unreadable');
+        }
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function gitOutput(projectPath, args) {
+    try {
+        const output = execFileSync('git', args, {
+            cwd: projectPath,
+            encoding: 'utf-8',
+            timeout: 5_000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        if (Buffer.isBuffer(output)) {
+            return output.toString('utf-8');
+        }
+        return typeof output === 'string' ? output : String(output);
+    }
+    catch {
+        return '';
+    }
+}
 //# sourceMappingURL=validate-lint.js.map

package/dist/tools/validate-team-results.js

@@ -1,11 +1,33 @@
 import { specStore } from '../storage/index.js';
 import { validateTeamResults } from '../engine/team-planner/index.js';
 import { readFile } from 'node:fs/promises';
+import { formatKeyValue } from './output-formatter.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 function text(content) {
-    return { content: [{ type: 'text', text: JSON.stringify(content, null, 2) }] };
+    const conflicts = Array.isArray(content.conflicts) ? content.conflicts.length : undefined;
+    const mergeOrder = Array.isArray(content.mergeOrder) ? content.mergeOrder.length : undefined;
+    const mergeOrderPreview = Array.isArray(content.mergeOrder)
+        ? content.mergeOrder.slice(0, 5).join(', ')
+        : undefined;
+    const warnings = Array.isArray(content.warnings) ? content.warnings.length : undefined;
+    return {
+        content: [
+            {
+                type: 'text',
+                text: formatKeyValue({
+                    passed: content.passed,
+                    conflicts,
+                    mergeOrder,
+                    mergeOrderPreview,
+                    warnings,
+                    summary: content.summary,
+                }) + '\nVerification commands: pnpm typecheck; pnpm lint; pnpm test',
+            },
+        ],
+        structuredContent: content,
+    };
 }
 function err(message) {
     return { content: [{ type: 'text', text: message }], isError: true };

package/dist/tools/validate.js

@@ -72,7 +72,10 @@ export async function handleValidate(args, server) {
     const implementationQualityScore = calcQualityScore(result.qualityIssues);
     const auditedFiles = [...new Set(result.qualityIssues.map((i) => i.file))];
     const { conventionViolations, regressionDetected } = await scanProjectConventions(projectId, projectPath);
-    const lintCheck = runLintCheck(projectPath, knowledge.lintCommand ?? null);
+    const lintCheck = runLintCheck(projectPath, knowledge.lintCommand ?? null, {
+        projectId,
+        specId,
+    });
     const assuranceGates = runAssuranceGates(projectPath);
     const minimalityReport = await buildMinimalityReport({
         projectPath,

package/dist/transports/http-transport.js

@@ -6,6 +6,7 @@ import { PLANU_VERSION } from '../config/version.js';
 import { runWithSessionContext } from './session-context.js';
 import { checkHttpRateLimit } from './http-rate-limiter.js';
 import { loadOAuthConfig, extractBearerToken, validateToken } from './oauth-validator.js';
+import { compactToolsListMessage, isToolsListResponse, } from '../engine/compact/tool-list-compactor.js';
 const MAX_BODY_BYTES = 5 * 1024 * 1024; // 5MB
 const SHUTDOWN_GRACE_MS = 5_000;
 const sessions = new Map();
@@ -95,6 +96,7 @@ async function handlePost(req, res, sessionId, serverFactory) {
     const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: () => randomUUID(),
     });
+    installToolsListCompaction(transport);
     transport.onclose = () => {
         const sid = transport.sessionId;
         if (sid) {
@@ -177,6 +179,17 @@ async function handleMcpRequest(req, res, serverFactory, corsOrigin) {
     res.writeHead(405, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ error: 'Method not allowed' }));
 }
+function installToolsListCompaction(transport) {
+    const originalSend = transport.send.bind(transport);
+    const compactingSend = (message) => {
+        const outgoing = isToolsListResponse(message)
+            ? compactToolsListMessage(message)
+            : message;
+        return originalSend(outgoing);
+    };
+    const wrappedTransport = transport;
+    wrappedTransport.send = compactingSend;
+}
 export async function createHttpTransport(serverFactory, config) {
     const httpServer = createServer((req, res) => {
         void (async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.10.6",
+  "version": "4.10.8",
   "description": "Planu — MCP Server for Spec Driven Development with native Rust acceleration for hot paths. Cross-platform (Linux/macOS/Windows, x64/arm64, glibc/musl).",
   "type": "module",
   "main": "dist/index.js",
@@ -34,14 +34,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "4.10.5",
-    "@planu/core-darwin-x64": "4.10.5",
-    "@planu/core-linux-arm64-gnu": "4.10.5",
-    "@planu/core-linux-arm64-musl": "4.10.5",
-    "@planu/core-linux-x64-gnu": "4.10.5",
-    "@planu/core-linux-x64-musl": "4.10.5",
-    "@planu/core-win32-arm64-msvc": "4.10.5",
-    "@planu/core-win32-x64-msvc": "4.10.5"
+    "@planu/core-darwin-arm64": "4.10.8",
+    "@planu/core-darwin-x64": "4.10.8",
+    "@planu/core-linux-arm64-gnu": "4.10.8",
+    "@planu/core-linux-arm64-musl": "4.10.8",
+    "@planu/core-linux-x64-gnu": "4.10.8",
+    "@planu/core-linux-x64-musl": "4.10.8",
+    "@planu/core-win32-arm64-msvc": "4.10.8",
+    "@planu/core-win32-x64-msvc": "4.10.8"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -164,7 +164,7 @@
     "tsc-alias": "^1.9.0",
     "type-coverage": "^2.29.7",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.62.1",
+    "typescript-eslint": "^8.63.0",
     "vite": "^8.1.3",
     "vitest": "^4.1.10",
     "vue": "^3.5.39"

package/planu-native.json

@@ -1,20 +1,26 @@
 {
   "name": "dev.planu.native",
   "displayName": "Planu Native Lightweight Surface",
-  "version": "4.10.6",
+  "version": "4.10.8",
   "packageName": "@planu/cli",
   "modes": {
     "lightweight": {
       "requiresMcp": false,
       "requiresDaemon": false,
-      "hosts": ["codex", "claude-code"],
+      "hosts": [
+        "codex",
+        "claude-code"
+      ],
       "commands": [
         {
           "id": "planu.status",
           "title": "Project status",
           "description": "Show the compact Planu project snapshot without loading the MCP tool graph.",
           "invocation": "planu status",
-          "hosts": ["codex", "claude-code"],
+          "hosts": [
+            "codex",
+            "claude-code"
+          ],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "handlePlanStatus"
@@ -24,7 +30,10 @@
           "title": "Create spec",
           "description": "Create a new spec through the CLI-backed SDD contract.",
           "invocation": "planu spec create \"<title>\"",
-          "hosts": ["codex", "claude-code"],
+          "hosts": [
+            "codex",
+            "claude-code"
+          ],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "handleCreateSpec"
@@ -34,7 +43,10 @@
           "title": "List specs",
           "description": "List specs in the current project with optional status/type filters.",
           "invocation": "planu spec list",
-          "hosts": ["codex", "claude-code"],
+          "hosts": [
+            "codex",
+            "claude-code"
+          ],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "handleListSpecs"
@@ -44,7 +56,10 @@
           "title": "Validate spec",
           "description": "Validate a spec against the current codebase from the native CLI surface.",
           "invocation": "planu spec validate SPEC-001",
-          "hosts": ["codex", "claude-code"],
+          "hosts": [
+            "codex",
+            "claude-code"
+          ],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "handleValidate"
@@ -54,7 +69,10 @@
           "title": "Audit technical debt",
           "description": "Run the read-only project audit path for lightweight debt checks.",
           "invocation": "planu audit debt",
-          "hosts": ["codex", "claude-code"],
+          "hosts": [
+            "codex",
+            "claude-code"
+          ],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "handleAudit"
@@ -64,7 +82,10 @@
           "title": "Check release readiness",
           "description": "Check local-first release readiness, branch cleanliness, and optional gitflow drift.",
           "invocation": "planu release check",
-          "hosts": ["codex", "claude-code"],
+          "hosts": [
+            "codex",
+            "claude-code"
+          ],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "releaseCommand"

package/planu-plugin.json

@@ -2,9 +2,12 @@
   "name": "dev.planu.cli",
   "displayName": "Planu — Spec Driven Development",
   "description": "Manage software specs, estimations, and autonomous SDD workflows. Language-agnostic MCP server for Claude Code.",
-  "version": "4.10.6",
+  "version": "4.10.8",
   "icon": "assets/plugin/icon.svg",
-  "command": ["npx", "@planu/cli@latest"],
+  "command": [
+    "npx",
+    "@planu/cli@latest"
+  ],
   "packageName": "@planu/cli",
   "capabilities": {
     "tools": [
@@ -23,17 +26,42 @@
       "create_skill",
       "skill_search"
     ],
-    "resources": ["planu://specs/list", "planu://specs/{id}", "planu://project/status", "planu://roadmap"],
-    "prompts": ["create-spec-from-idea", "review-spec-readiness", "generate-implementation-plan"],
-    "subagents": ["sdd-orchestrator", "spec-challenger", "test-generator"]
+    "resources": [
+      "planu://specs/list",
+      "planu://specs/{id}",
+      "planu://project/status",
+      "planu://roadmap"
+    ],
+    "prompts": [
+      "create-spec-from-idea",
+      "review-spec-readiness",
+      "generate-implementation-plan"
+    ],
+    "subagents": [
+      "sdd-orchestrator",
+      "spec-challenger",
+      "test-generator"
+    ]
   },
   "compatibility": {
     "minimumHostVersion": "1.0.0",
-    "requiredFeatures": ["mcp-tools", "file-editing"]
+    "requiredFeatures": [
+      "mcp-tools",
+      "file-editing"
+    ]
   },
   "repository": "https://github.com/planu-dev/planu",
   "author": "Planu",
   "license": "MIT",
   "homepage": "https://planu.dev",
-  "keywords": ["sdd", "spec-driven-development", "mcp", "specs", "planning", "ai", "bdd", "tdd"]
+  "keywords": [
+    "sdd",
+    "spec-driven-development",
+    "mcp",
+    "specs",
+    "planning",
+    "ai",
+    "bdd",
+    "tdd"
+  ]
 }