@planu/cli 4.7.1 → 4.7.3

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [4.7.3] - 2026-06-19
+
+### Features
+- feat: add reversible context compaction
+
+### Chores
+- chore(deps): update patch and minor dependencies
+
+
+## [4.7.2] - 2026-06-16
+
+### Features
+- feat(SPEC-1088): add policy-driven minimal implementation gate
+
+### Chores
+- chore(deps): update patch/minor dependencies
+
+
 ## [4.7.1] - 2026-06-12
 
 ### Chores

package/dist/config/minimal-implementation-gate.json

@@ -0,0 +1,110 @@
+{
+  "version": 1,
+  "enabled": true,
+  "report": {
+    "maxFindings": 12,
+    "maxMarkdownLines": 12,
+    "maxEvidenceChars": 180
+  },
+  "tags": {
+    "delete": { "description": "Remove avoidable code or files." },
+    "stdlib": { "description": "Use a standard library capability before adding custom code." },
+    "native": { "description": "Use an existing platform or Planu-native capability." },
+    "installed-dependency": { "description": "Use an already-installed dependency instead of adding another." },
+    "yagni": { "description": "Avoid speculative code that is not required by the approved spec." },
+    "shrink": { "description": "Reduce an oversized abstraction or workflow." },
+    "dependency": { "description": "Avoid an unnecessary new package or dependency path." },
+    "file-scope": { "description": "Keep implementation inside the approved file scope." },
+    "debt-marker": { "description": "Record accepted shortcuts as structured debt evidence." }
+  },
+  "rules": [
+    {
+      "id": "minimality.delete.dead-compat",
+      "tag": "delete",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["legacy compatibility", "deprecated fallback", "unused fallback"],
+      "replacementGuidance": "Remove the compatibility path unless the approved spec explicitly requires backward compatibility."
+    },
+    {
+      "id": "minimality.stdlib.custom-parser",
+      "tag": "stdlib",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["custom parser", "manual parser", "hand rolled parser"],
+      "replacementGuidance": "Use an existing parser from the runtime or current dependency set before writing parsing code."
+    },
+    {
+      "id": "minimality.native.existing-planu-surface",
+      "tag": "native",
+      "severity": "warning",
+      "confidence": "high",
+      "patterns": ["new public mcp tool", "new command", "new cli command"],
+      "replacementGuidance": "Prefer existing Planu SDD surfaces unless the spec proves a new public surface is required."
+    },
+    {
+      "id": "minimality.installed-dependency.add-package",
+      "tag": "installed-dependency",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["add dependency", "new dependency", "install package"],
+      "replacementGuidance": "Check package.json first and reuse an already-installed dependency when possible."
+    },
+    {
+      "id": "minimality.yagni.future-proofing",
+      "tag": "yagni",
+      "severity": "blocker",
+      "confidence": "high",
+      "patterns": ["future-proof", "just in case", "might need later", "eventually support"],
+      "replacementGuidance": "Remove speculative scope unless it is directly required by an acceptance criterion.",
+      "blockWhenRiskAtLeast": "medium"
+    },
+    {
+      "id": "minimality.shrink.over-architecture",
+      "tag": "shrink",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["framework", "orchestration layer", "plugin architecture", "abstract factory"],
+      "replacementGuidance": "Shrink the design to the smallest correct module/function that satisfies the spec."
+    },
+    {
+      "id": "minimality.dependency.new-runtime",
+      "tag": "dependency",
+      "severity": "blocker",
+      "confidence": "high",
+      "patterns": ["npm install", "pnpm add", "yarn add"],
+      "replacementGuidance": "Avoid adding runtime dependencies unless the approved spec explicitly requires one.",
+      "blockWhenRiskAtLeast": "low"
+    },
+    {
+      "id": "minimality.file-scope.unapproved-area",
+      "tag": "file-scope",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["touch unrelated", "broad refactor", "repo-wide refactor"],
+      "replacementGuidance": "Keep edits inside the approved technical references and tests."
+    },
+    {
+      "id": "minimality.debt-marker.comment-only",
+      "tag": "debt-marker",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["todo debt", "temporary hack", "shortcut accepted"],
+      "replacementGuidance": "Record accepted shortcuts as structured debt evidence with ceiling and upgrade trigger."
+    }
+  ],
+  "safetyExclusions": [
+    "security",
+    "accessibility",
+    "data-loss",
+    "compliance",
+    "money",
+    "access-control",
+    "explicitly requested",
+    "trust boundary"
+  ],
+  "excludedPathPatterns": ["dist/**", "coverage/**", "node_modules/**", "pnpm-lock.yaml", "*.snap"],
+  "debtEvidence": {
+    "requiredFields": ["specId", "files", "ceiling", "upgradeTrigger", "reviewRationale"]
+  }
+}

package/dist/config/token-waste-autopilot.json

@@ -17,6 +17,22 @@
       "generic": { "maxLines": 60 }
     }
   },
+  "contextArtifacts": {
+    "enabled": true,
+    "ttlMs": 86400000,
+    "minTokens": 200
+  },
+  "contentCompaction": {
+    "strategies": {
+      "json": { "maxLines": 60, "maxSnippetChars": 240 },
+      "test-log": { "maxLines": 80, "keepFailures": true, "maxSnippetChars": 240 },
+      "runtime-log": { "maxLines": 60, "keepFailures": true, "uniqueOnly": true, "maxSnippetChars": 240 },
+      "search-results": { "maxLines": 80, "uniqueOnly": true, "maxSnippetChars": 180 },
+      "code": { "maxLines": 120, "maxSnippetChars": 240 },
+      "spec-or-handoff": { "maxLines": 120, "maxSnippetChars": 240 },
+      "generic-text": { "maxLines": 60, "maxSnippetChars": 240 }
+    }
+  },
   "tools": {
     "groups": {
       "spec": ["create_spec", "check_readiness", "challenge_spec", "update_status"],

package/dist/engine/compact/compact-middleware.d.ts

@@ -1,10 +1,10 @@
 import type { ToolResult } from '../../types/index.js';
-import type { CompactDecision } from '../../types/compact/compact-mode.js';
+import type { CompactDecision, CompactModeOptions } from '../../types/compact/compact-mode.js';
 /**
  * Apply compact mode formatting to a ToolResult.
  * - Truncates text content blocks to tokenBudget
  * - Preserves structuredContent (essential data: status, scores, blockers)
  * - Adds _meta.compactMode and _meta.contextUsed
  */
-export declare function applyCompactMode(result: ToolResult, decision: CompactDecision): ToolResult;
+export declare function applyCompactMode(result: ToolResult, decision: CompactDecision, options?: CompactModeOptions): ToolResult;
 //# sourceMappingURL=compact-middleware.d.ts.map

package/dist/engine/compact/compact-middleware.js

@@ -1,6 +1,47 @@
 // engine/compact/compact-middleware.ts — SPEC-922: Apply compact mode to tool responses
+import { compactContentAware } from '../token-optimizer/content-aware-compactor.js';
 /** Approximate chars per token for English text. */
 const CHARS_PER_TOKEN = 4;
+function defaultCompactPolicy(tokenBudget) {
+    return {
+        contextArtifacts: {
+            enabled: true,
+            ttlMs: 24 * 60 * 60 * 1000,
+            minTokens: tokenBudget,
+        },
+        contentCompaction: {
+            strategies: {
+                json: { maxLines: tokenBudget },
+                'test-log': { maxLines: tokenBudget },
+                'runtime-log': { maxLines: tokenBudget },
+                'search-results': { maxLines: tokenBudget },
+                code: { maxLines: tokenBudget },
+                'spec-or-handoff': { maxLines: tokenBudget },
+                'generic-text': { maxLines: tokenBudget },
+            },
+        },
+        redaction: {
+            maxSnippetChars: 240,
+            redactPatterns: ['secret', 'token', 'password', 'api_key'],
+        },
+    };
+}
+function withCompactionMeta(result, compaction) {
+    if (compaction === undefined) {
+        return result;
+    }
+    return {
+        ...result,
+        structuredContent: {
+            ...(result.structuredContent ?? {}),
+            compaction,
+        },
+        _meta: {
+            ...(typeof result._meta === 'object' && result._meta !== null ? result._meta : {}),
+            compaction,
+        },
+    };
+}
 /** Truncate a single text block to a token budget. */
 function truncateBlock(text, tokenBudget) {
     const maxChars = tokenBudget * CHARS_PER_TOKEN;
@@ -17,7 +58,7 @@ function truncateBlock(text, tokenBudget) {
  * - Preserves structuredContent (essential data: status, scores, blockers)
  * - Adds _meta.compactMode and _meta.contextUsed
  */
-export function applyCompactMode(result, decision) {
+export function applyCompactMode(result, decision, options = {}) {
     if (decision.mode !== 'compact') {
         // Still add _meta even in verbose mode if contextUsed was provided
         if (decision.contextUsed !== undefined) {
@@ -32,11 +73,31 @@ export function applyCompactMode(result, decision) {
         }
         return result;
     }
-    const truncatedContent = result.content.map((block) => ({
-        ...block,
-        text: truncateBlock(block.text, decision.tokenBudget),
-    }));
-    return {
+    let firstCompaction;
+    const truncatedContent = result.content.map((block) => {
+        if (options.projectPath !== undefined) {
+            const compacted = compactContentAware({
+                text: block.text,
+                policy: defaultCompactPolicy(decision.tokenBudget),
+                projectPath: options.projectPath,
+                sourcePath: options.sourcePath,
+                flow: options.flow,
+                kind: options.flow,
+            });
+            firstCompaction ??= compacted.artifact;
+            return {
+                ...block,
+                text: compacted.text.length < block.text.length
+                    ? `${compacted.text}\n\nArtifact: ${compacted.artifact?.artifactRef ?? 'not stored'}`
+                    : truncateBlock(block.text, decision.tokenBudget),
+            };
+        }
+        return {
+            ...block,
+            text: truncateBlock(block.text, decision.tokenBudget),
+        };
+    });
+    return withCompactionMeta({
         ...result,
         content: truncatedContent,
         _meta: {
@@ -45,6 +106,6 @@ export function applyCompactMode(result, decision) {
             contextUsed: decision.contextUsed,
             tokenBudget: decision.tokenBudget,
         },
-    };
+    }, firstCompaction);
 }
 //# sourceMappingURL=compact-middleware.js.map

package/dist/engine/context-artifacts/index.d.ts

@@ -0,0 +1,2 @@
+export { getContextArtifactStats, retrieveContextArtifact, storeContextArtifact } from './store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/context-artifacts/index.js

@@ -0,0 +1,2 @@
+export { getContextArtifactStats, retrieveContextArtifact, storeContextArtifact } from './store.js';
+//# sourceMappingURL=index.js.map

package/dist/engine/context-artifacts/store.d.ts

@@ -0,0 +1,5 @@
+import type { ContextArtifactStats, RetrieveContextArtifactResult, StoreContextArtifactInput, StoreContextArtifactResult } from '../../types/context-artifacts.js';
+export declare function storeContextArtifact(input: StoreContextArtifactInput): StoreContextArtifactResult;
+export declare function retrieveContextArtifact(projectPath: string, ref: string): RetrieveContextArtifactResult;
+export declare function getContextArtifactStats(projectPath: string): ContextArtifactStats;
+//# sourceMappingURL=store.d.ts.map

package/dist/engine/context-artifacts/store.js

@@ -0,0 +1,176 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getSensitivePathRefusal, shouldBypassLeanMode, } from '../context-intelligence/compression-guards.js';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
+const REF_PREFIX = 'ctx_';
+const REF_PATTERN = /^ctx_[a-f0-9]{32}$/;
+const FORBIDDEN_METADATA_KEY = /(?:secret|token|password|credential|api[_-]?key|private[_-]?key)/i;
+function artifactDir(projectPath) {
+    return join(projectDataDir(hashProjectPath(projectPath)), 'context-artifacts');
+}
+function artifactPath(projectPath, ref) {
+    if (!REF_PATTERN.test(ref)) {
+        return null;
+    }
+    return join(artifactDir(projectPath), `${ref}.json`);
+}
+function sha256(value) {
+    return createHash('sha256').update(value, 'utf8').digest('hex');
+}
+function safeMetadata(metadata) {
+    const safe = {};
+    for (const [key, value] of Object.entries(metadata ?? {})) {
+        if (FORBIDDEN_METADATA_KEY.test(key)) {
+            continue;
+        }
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            safe[key] =
+                typeof value === 'string' && FORBIDDEN_METADATA_KEY.test(value) ? '[redacted]' : value;
+        }
+    }
+    return safe;
+}
+function compactionMetadata(artifact) {
+    return {
+        artifactRef: artifact.ref,
+        originalTokens: artifact.originalTokens,
+        compactTokens: artifact.compactTokens,
+        tokensSaved: artifact.tokensSaved,
+        strategy: artifact.strategy,
+        contentType: artifact.contentType,
+        expiresAt: artifact.expiresAt,
+        retrievalHint: `Use artifactRef ${artifact.ref} to retrieve the full local output before ${artifact.expiresAt}.`,
+    };
+}
+function readArtifactFile(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeArtifactFile(path, artifact) {
+    writeFileSync(path, JSON.stringify(artifact, null, 2), 'utf-8');
+}
+export function storeContextArtifact(input) {
+    if (input.sourcePath) {
+        const refusal = getSensitivePathRefusal(input.sourcePath);
+        if (refusal !== null) {
+            return { stored: false, refusedReason: refusal };
+        }
+    }
+    if (input.flow && shouldBypassLeanMode(input.flow)) {
+        return {
+            stored: false,
+            refusedReason: `Refusing recoverable artifact for sensitive flow ${input.flow}`,
+        };
+    }
+    const contentHash = sha256(input.originalContent);
+    const ref = `${REF_PREFIX}${contentHash.slice(0, 32)}`;
+    const path = artifactPath(input.projectPath, ref);
+    if (path === null) {
+        return { stored: false, refusedReason: 'Invalid generated artifact ref' };
+    }
+    const now = Date.now();
+    const createdAt = new Date(now).toISOString();
+    const expiresAt = new Date(now + input.ttlMs).toISOString();
+    const tokensSaved = Math.max(0, input.originalTokens - input.compactTokens);
+    const previous = existsSync(path) ? readArtifactFile(path) : null;
+    const artifact = {
+        ref,
+        contentHash,
+        createdAt: previous?.createdAt ?? createdAt,
+        expiresAt,
+        ttlMs: input.ttlMs,
+        projectId: hashProjectPath(input.projectPath),
+        contentType: input.contentType,
+        strategy: input.strategy,
+        originalTokens: input.originalTokens,
+        compactTokens: input.compactTokens,
+        tokensSaved,
+        retrievalCount: previous?.retrievalCount ?? 0,
+        metadata: safeMetadata(input.metadata),
+        originalContent: input.originalContent,
+        compactContent: input.compactContent,
+    };
+    mkdirSync(artifactDir(input.projectPath), { recursive: true });
+    writeArtifactFile(path, artifact);
+    return { stored: true, artifact, metadata: compactionMetadata(artifact) };
+}
+export function retrieveContextArtifact(projectPath, ref) {
+    const path = artifactPath(projectPath, ref);
+    if (path === null) {
+        return {
+            found: false,
+            reason: 'invalid-ref',
+            hint: 'Artifact refs are opaque ctx_<hash> identifiers.',
+        };
+    }
+    if (!existsSync(path)) {
+        return {
+            found: false,
+            reason: 'missing',
+            hint: 'The artifact is missing or belongs to a different project.',
+        };
+    }
+    const artifact = readArtifactFile(path);
+    if (artifact === null) {
+        return {
+            found: false,
+            reason: 'corrupt',
+            hint: 'The artifact payload is corrupt and cannot be recovered.',
+        };
+    }
+    if (artifact.projectId !== hashProjectPath(projectPath)) {
+        return {
+            found: false,
+            reason: 'unauthorized',
+            hint: 'The artifact does not belong to this project scope.',
+        };
+    }
+    if (Date.parse(artifact.expiresAt) <= Date.now()) {
+        return {
+            found: false,
+            reason: 'expired',
+            hint: 'The artifact expired; rerun the source operation if exact output is needed.',
+        };
+    }
+    const updated = { ...artifact, retrievalCount: artifact.retrievalCount + 1 };
+    writeArtifactFile(path, updated);
+    return {
+        found: true,
+        artifact: updated,
+        hint: 'Full artifact recovered from local Planu storage.',
+    };
+}
+export function getContextArtifactStats(projectPath) {
+    const dir = artifactDir(projectPath);
+    const stats = {
+        artifactCount: 0,
+        totalOriginalTokens: 0,
+        totalCompactTokens: 0,
+        totalTokensSaved: 0,
+        retrievalCount: 0,
+    };
+    if (!existsSync(dir)) {
+        return stats;
+    }
+    for (const entry of readdirSync(dir)) {
+        if (!entry.endsWith('.json')) {
+            continue;
+        }
+        const artifact = readArtifactFile(join(dir, entry));
+        if (artifact === null || Date.parse(artifact.expiresAt) <= Date.now()) {
+            continue;
+        }
+        stats.artifactCount += 1;
+        stats.totalOriginalTokens += artifact.originalTokens;
+        stats.totalCompactTokens += artifact.compactTokens;
+        stats.totalTokensSaved += artifact.tokensSaved;
+        stats.retrievalCount += artifact.retrievalCount;
+    }
+    return stats;
+}
+//# sourceMappingURL=store.js.map

package/dist/engine/handoff-artifacts/schemas.d.ts

@@ -96,6 +96,62 @@ export declare const ValidationReportV1Schema: z.ZodObject<{
             evidence: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    minimalityReport: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        blocked: z.ZodBoolean;
+        findings: z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+            tag: z.ZodString;
+            severity: z.ZodEnum<{
+                blocker: "blocker";
+                warning: "warning";
+                info: "info";
+            }>;
+            confidence: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>;
+            target: z.ZodString;
+            line: z.ZodOptional<z.ZodNumber>;
+            evidence: z.ZodString;
+            replacementGuidance: z.ZodString;
+            blocksDone: z.ZodBoolean;
+            evidenceSource: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    spec: "spec";
+                    runtime: "runtime";
+                    policy: "policy";
+                    "project-config": "project-config";
+                }>;
+                key: z.ZodString;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        safetyExceptions: z.ZodArray<z.ZodObject<{
+            target: z.ZodString;
+            reason: z.ZodString;
+            evidence: z.ZodString;
+        }, z.core.$strip>>;
+        debtEvidence: z.ZodArray<z.ZodObject<{
+            specId: z.ZodString;
+            files: z.ZodArray<z.ZodString>;
+            ceiling: z.ZodString;
+            upgradeTrigger: z.ZodString;
+            reviewRationale: z.ZodString;
+        }, z.core.$strip>>;
+        evidence: z.ZodArray<z.ZodObject<{
+            source: z.ZodEnum<{
+                spec: "spec";
+                runtime: "runtime";
+                policy: "policy";
+                "project-config": "project-config";
+            }>;
+            key: z.ZodString;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>;
+        markdown: z.ZodString;
+    }, z.core.$strip>>;
     score: z.ZodOptional<z.ZodNumber>;
     completedAt: z.ZodISODateTime;
 }, z.core.$strip>;
@@ -194,6 +250,62 @@ export declare const ARTIFACT_SCHEMAS: {
                 evidence: z.ZodArray<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        minimalityReport: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            blocked: z.ZodBoolean;
+            findings: z.ZodArray<z.ZodObject<{
+                ruleId: z.ZodString;
+                tag: z.ZodString;
+                severity: z.ZodEnum<{
+                    blocker: "blocker";
+                    warning: "warning";
+                    info: "info";
+                }>;
+                confidence: z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                }>;
+                target: z.ZodString;
+                line: z.ZodOptional<z.ZodNumber>;
+                evidence: z.ZodString;
+                replacementGuidance: z.ZodString;
+                blocksDone: z.ZodBoolean;
+                evidenceSource: z.ZodArray<z.ZodObject<{
+                    source: z.ZodEnum<{
+                        spec: "spec";
+                        runtime: "runtime";
+                        policy: "policy";
+                        "project-config": "project-config";
+                    }>;
+                    key: z.ZodString;
+                    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            safetyExceptions: z.ZodArray<z.ZodObject<{
+                target: z.ZodString;
+                reason: z.ZodString;
+                evidence: z.ZodString;
+            }, z.core.$strip>>;
+            debtEvidence: z.ZodArray<z.ZodObject<{
+                specId: z.ZodString;
+                files: z.ZodArray<z.ZodString>;
+                ceiling: z.ZodString;
+                upgradeTrigger: z.ZodString;
+                reviewRationale: z.ZodString;
+            }, z.core.$strip>>;
+            evidence: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    spec: "spec";
+                    runtime: "runtime";
+                    policy: "policy";
+                    "project-config": "project-config";
+                }>;
+                key: z.ZodString;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>;
+            markdown: z.ZodString;
+        }, z.core.$strip>>;
         score: z.ZodOptional<z.ZodNumber>;
         completedAt: z.ZodISODateTime;
     }, z.core.$strip>;

package/dist/engine/handoff-artifacts/schemas.js

@@ -73,6 +73,46 @@ export const ValidationReportV1Schema = z.object({
         })),
     })
         .optional(),
+    minimalityReport: z
+        .object({
+        enabled: z.boolean(),
+        blocked: z.boolean(),
+        findings: z.array(z.object({
+            ruleId: z.string(),
+            tag: z.string(),
+            severity: z.enum(['info', 'warning', 'blocker']),
+            confidence: z.enum(['low', 'medium', 'high']),
+            target: z.string(),
+            line: z.number().optional(),
+            evidence: z.string(),
+            replacementGuidance: z.string(),
+            blocksDone: z.boolean(),
+            evidenceSource: z.array(z.object({
+                source: z.enum(['policy', 'project-config', 'runtime', 'spec']),
+                key: z.string(),
+                value: z.union([z.string(), z.number(), z.boolean()]).optional(),
+            })),
+        })),
+        safetyExceptions: z.array(z.object({
+            target: z.string(),
+            reason: z.string(),
+            evidence: z.string(),
+        })),
+        debtEvidence: z.array(z.object({
+            specId: z.string(),
+            files: z.array(z.string()),
+            ceiling: z.string(),
+            upgradeTrigger: z.string(),
+            reviewRationale: z.string(),
+        })),
+        evidence: z.array(z.object({
+            source: z.enum(['policy', 'project-config', 'runtime', 'spec']),
+            key: z.string(),
+            value: z.union([z.string(), z.number(), z.boolean()]).optional(),
+        })),
+        markdown: z.string(),
+    })
+        .optional(),
     score: z.number().optional(),
     completedAt: z.iso.datetime(),
 });

package/dist/engine/minimality/analyzer.d.ts

@@ -0,0 +1,3 @@
+import type { MinimalImplementationInput, MinimalImplementationReport } from '../../types/minimal-implementation-gate.js';
+export declare function analyzeMinimalImplementation(input: MinimalImplementationInput): MinimalImplementationReport;
+//# sourceMappingURL=analyzer.d.ts.map