@planu/cli 4.3.13 → 4.3.15

package/dist/cli/commands/audit.js

@@ -8,7 +8,7 @@ import { red } from '../colors.js';
 export const auditCommand = {
     name: 'audit',
     description: 'Audit the current project',
-    usage: 'planu audit [--path .] [--project-id ID] [--spec SPEC-001]',
+    usage: 'planu audit [debt] [--path .] [--project-id ID] [--spec SPEC-001]',
     async run(args, flags) {
         const { values } = parseArgs({
             args,

package/dist/cli/commands/release.d.ts

@@ -0,0 +1,3 @@
+import type { CliCommand } from '../../types/cli.js';
+export declare const releaseCommand: CliCommand;
+//# sourceMappingURL=release.d.ts.map

package/dist/cli/commands/release.js

@@ -0,0 +1,87 @@
+// cli/commands/release.ts — lightweight release readiness checks (SPEC-1069)
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { green, red, yellow } from '../colors.js';
+const execFileAsync = promisify(execFile);
+const RELEASE_BRANCHES = ['main', 'develop', 'release'];
+export const releaseCommand = {
+    name: 'release',
+    description: 'Check lightweight release readiness',
+    usage: 'planu release check [--json]',
+    async run(args, flags) {
+        const subcommand = args[0] ?? 'check';
+        if (subcommand !== 'check') {
+            process.stderr.write(`${red('Error:')} Unknown release subcommand "${subcommand}".\n`);
+            process.stderr.write(`Usage: ${releaseCommand.usage}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const result = await checkReleaseReadiness(process.cwd());
+        if (flags?.json) {
+            process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+            if (!result.clean || !result.synced) {
+                process.exitCode = 1;
+            }
+            return;
+        }
+        writeReleaseCheck(result);
+        if (!result.clean || !result.synced) {
+            process.exitCode = 1;
+        }
+    },
+};
+async function checkReleaseReadiness(cwd) {
+    const problems = [];
+    const status = await git(cwd, ['status', '--short']);
+    const clean = status.trim().length === 0;
+    if (!clean) {
+        problems.push('working tree has uncommitted changes');
+    }
+    const head = (await git(cwd, ['rev-parse', 'HEAD'])).trim() || null;
+    const branches = {};
+    for (const branch of RELEASE_BRANCHES) {
+        branches[branch] = await resolveRef(cwd, branch);
+    }
+    const branchValues = Object.values(branches);
+    const synced = head !== null &&
+        branchValues.every((value) => value !== null) &&
+        branchValues.every((value) => value === head);
+    if (!synced) {
+        problems.push('main, develop, and release are not all synced to HEAD');
+    }
+    return { clean, synced, head, branches, problems };
+}
+async function resolveRef(cwd, branch) {
+    const candidates = [branch, `origin/${branch}`];
+    for (const candidate of candidates) {
+        try {
+            const value = (await git(cwd, ['rev-parse', candidate])).trim();
+            if (value) {
+                return value;
+            }
+        }
+        catch {
+            // Try next candidate.
+        }
+    }
+    return null;
+}
+async function git(cwd, args) {
+    const result = await execFileAsync('git', args, {
+        cwd,
+        maxBuffer: 1024 * 1024,
+        timeout: 10_000,
+    });
+    return result.stdout;
+}
+function writeReleaseCheck(result) {
+    if (result.clean && result.synced) {
+        process.stdout.write(`${green('Release ready.')} main, develop, and release match HEAD.\n`);
+        return;
+    }
+    process.stdout.write(`${yellow('Release not ready.')}\n`);
+    for (const problem of result.problems) {
+        process.stdout.write(`- ${problem}\n`);
+    }
+}
+//# sourceMappingURL=release.js.map

package/dist/cli/commands/spec.js

@@ -5,12 +5,14 @@
 //   planu spec list [--status X]      → calls handleListSpecs
 //   planu spec show SPEC-NNN          → reads spec from storage
 //   planu spec status SPEC-NNN done   → calls handleUpdateStatus
+//   planu spec validate SPEC-NNN      → calls handleValidate
 import { parseArgs } from 'node:util';
 import { resolve } from 'node:path';
 import { handleCreateSpec } from '../../tools/create-spec.js';
 import { handleListSpecs } from '../../tools/list-specs.js';
 import { handleUpdateStatus } from '../../tools/update-status.js';
 import { handleUpdateStatusBatch } from '../../tools/update-status/batch.js';
+import { handleValidate } from '../../tools/validate.js';
 import { formatToolResult } from '../formatter.js';
 import { detectProjectId } from '../project-detector.js';
 import { bold, cyan, green, red, dim } from '../colors.js';
@@ -28,16 +30,48 @@ function printSpecSubcommandHelp() {
         `  ${'list'.padEnd(10)} ${dim('List specs [--status draft|approved|done...]')}`,
         `  ${'show'.padEnd(10)} ${dim('Show spec details (SPEC-NNN)')}`,
         `  ${'status'.padEnd(10)} ${dim('Update spec status (SPEC-NNN <status>)')}`,
+        `  ${'validate'.padEnd(10)} ${dim('Validate a spec against its codebase')}`,
         '',
         cyan('Examples:'),
         `  planu spec create "Add login flow"`,
         `  planu spec list --status approved`,
         `  planu spec show SPEC-001`,
         `  planu spec status SPEC-001 done`,
+        `  planu spec validate SPEC-001`,
     ];
     process.stdout.write(lines.join('\n') + '\n');
 }
 // ---------------------------------------------------------------------------
+// Subcommand: spec validate
+// ---------------------------------------------------------------------------
+async function runValidate(args, flags) {
+    const { positionals, values } = parseArgs({
+        args,
+        options: {
+            'project-id': { type: 'string' },
+        },
+        strict: false,
+        allowPositionals: true,
+    });
+    const specId = positionals[0];
+    if (!specId) {
+        process.stderr.write(`${red('Error:')} Spec ID is required.\nUsage: planu spec validate SPEC-NNN\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const projectId = values['project-id'] ?? detectProjectId();
+    const result = await handleValidate({ specId, projectId });
+    if (result.isError) {
+        process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const output = formatToolResult(result, flags);
+    if (output) {
+        process.stdout.write(output + '\n');
+    }
+}
+// ---------------------------------------------------------------------------
 // Subcommand: spec create
 // ---------------------------------------------------------------------------
 async function runCreate(args, flags) {
@@ -258,6 +292,9 @@ export const specCommand = {
             case 'status':
                 await runStatus(rest, flags);
                 break;
+            case 'validate':
+                await runValidate(rest, flags);
+                break;
             case undefined:
             case 'help':
                 printSpecSubcommandHelp();

package/dist/cli/commands/status.js

@@ -2,15 +2,20 @@
 import { parseArgs } from 'node:util';
 import { handleUpdateStatus } from '../../tools/update-status.js';
 import { handleUpdateStatusBatch } from '../../tools/update-status/batch.js';
+import { handlePlanStatus } from '../../tools/status-handler.js';
 import { formatToolResult } from '../formatter.js';
 import { detectProjectId } from '../project-detector.js';
 import { red, green } from '../colors.js';
 export const statusCommand = {
     name: 'status',
-    description: 'Update the status of a spec',
-    usage: 'planu status <specId> --set <status> [--project-id ID] [--model-tier-used TIER --model-id ID --context-hash HASH --handoff-path PATH --reviewed-by ID --arbitrated-by ID] | planu status batch --set <status> SPEC-001 SPEC-002',
+    description: 'Show project status or update the status of a spec',
+    usage: 'planu status [--project-path . --project-id ID] | planu status <specId> --set <status> [--project-id ID] | planu status batch --set <status> SPEC-001 SPEC-002',
     async run(args, flags) {
         const { values, positionals } = parseStatusArgs(args);
+        if (positionals.length === 0 && !values.set) {
+            await runProjectStatus(values, flags);
+            return;
+        }
         const isBatch = positionals[0] === 'batch';
         const specId = positionals[0];
         if (!specId) {
@@ -56,6 +61,21 @@ function parseStatusArgs(args) {
     });
     return { values: parsed.values, positionals: parsed.positionals };
 }
+async function runProjectStatus(values, flags) {
+    const result = await handlePlanStatus({
+        projectPath: values['project-path'] ?? process.cwd(),
+        projectId: values['project-id'],
+    });
+    if (result.isError) {
+        process.stderr.write(`${red(formatToolResult(result, flags))}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const output = formatToolResult(result, flags);
+    if (output) {
+        process.stdout.write(`${output}\n`);
+    }
+}
 function writeUsageError(message) {
     process.stderr.write(`${red('Error:')} ${message}\nUsage: ${statusCommand.usage}\n`);
 }

package/dist/cli/router.js

@@ -4,7 +4,7 @@ import { PLANU_VERSION } from '../config/version.js';
 import { red, bold, cyan, dim } from './colors.js';
 // Lazy-load commands to avoid importing tool handlers when not needed
 async function loadCommands() {
-    const [{ initCommand }, { createCommand }, { listCommand }, { statusCommand }, { estimateCommand }, { validateCommand }, { dashboardCommand }, { auditCommand }, { serveCommand }, { handoffCommand }, { watchCommand }, { installCommand }, { doctorCommand }, { uninstallCommand }, { activateCommand }, { specCommand }, { healthCommand },] = await Promise.all([
+    const [{ initCommand }, { createCommand }, { listCommand }, { statusCommand }, { estimateCommand }, { validateCommand }, { dashboardCommand }, { auditCommand }, { serveCommand }, { handoffCommand }, { watchCommand }, { installCommand }, { doctorCommand }, { uninstallCommand }, { activateCommand }, { specCommand }, { healthCommand }, { releaseCommand },] = await Promise.all([
         import('./commands/init.js'),
         import('./commands/create.js'),
         import('./commands/list.js'),
@@ -22,6 +22,7 @@ async function loadCommands() {
         import('./commands/activate.js'),
         import('./commands/spec.js'),
         import('./commands/health.js'),
+        import('./commands/release.js'),
     ]);
     const cmds = [
         initCommand,
@@ -41,6 +42,7 @@ async function loadCommands() {
         activateCommand,
         specCommand,
         healthCommand,
+        releaseCommand,
     ];
     const map = new Map();
     for (const cmd of cmds) {

package/dist/config/elicitation-dimensions.json

@@ -36,7 +36,7 @@
     "id": "database",
     "headerKey": "questions.database.header",
     "questionKey": "questions.database.question",
-    "requiresDNA": ["supabase"],
+    "requiresSignal": "hasDatabase",
     "optionSet": "database",
     "multiSelect": true
   },
@@ -44,7 +44,7 @@
     "id": "uiType",
     "headerKey": "questions.uiType.header",
     "questionKey": "questions.uiType.question",
-    "requiresDNA": ["react", "next"],
+    "requiresSignal": "hasUi",
     "optionSet": "uiType",
     "multiSelect": false
   }

package/dist/config/skill-templates/planu-native.md

@@ -0,0 +1,29 @@
+---
+name: planu-native
+description: Use Planu's lightweight native CLI surface before escalating to full MCP mode.
+triggers:
+  - use planu lightweight
+  - planu native mode
+  - check planu without mcp
+  - lightweight planu status
+version: 1.0.0
+---
+
+# /planu-native — Lightweight Planu Surface
+
+## When to invoke
+
+Use this skill when the user wants a fast Planu workflow that does not need the full MCP tool graph.
+
+## Native commands
+
+- `planu status` — compact project snapshot
+- `planu spec create "<title>"` — create a spec
+- `planu spec list` — list specs
+- `planu spec validate SPEC-001` — validate one spec
+- `planu audit debt` — read-only technical debt audit
+- `planu release check` — local release readiness check
+
+## Escalation
+
+Use full MCP mode when the task needs advanced lifecycle automation, generators, governance tools, MCP resources, prompts, or multi-step orchestration.

package/dist/config/workflow-conventions-catalog.json

@@ -22,14 +22,6 @@
         "Working tree is clean (no uncommitted changes)"
       ],
       "whenToUse": "End of spec only. Do NOT run during iterative development — it runs the full coverage suite (> 2 min)."
-    },
-    "propose-spec-split.sh": {
-      "name": "propose-spec-split.sh",
-      "purpose": "Analyze a spec.md and propose a split when it exceeds the 35-criteria threshold for a single implementation context.",
-      "triggerCondition": "When a spec has > 35 acceptance criteria in spec.md. Must run BEFORE starting implementation — never implement XL specs directly.",
-      "expectedOutput": "Proposed sub-spec split with suggested groupings, estimated size per sub-spec, and recommended implementation order.",
-      "preConditions": ["SPEC-XXX directory exists with spec.md", "spec.md has acceptance criteria section"],
-      "whenToUse": "Proactively at spec planning time. The /implement-spec skill should call this automatically for specs > 35 criteria."
     }
   },
 

package/dist/engine/core-bridge.js

@@ -104,6 +104,11 @@ let nativeModule = null;
 let loadDiagnostic = { attempted: [], errors: [] };
 let loaded = false;
 function loadNative() {
+    if (process.env.DISABLE_NATIVE_CORE === '1') {
+        loadDiagnostic = { attempted: [], errors: [] };
+        loaded = true;
+        return null;
+    }
     if (loaded) {
         return nativeModule;
     }

package/dist/engine/elicitation/answer-extractor.js

@@ -4,6 +4,7 @@ const FRONTEND_TERMS = /\b(component|ui|page|css|style|layout|form|button|modal|
 const BACKEND_TERMS = /\b(api|endpoint|route|handler|migration|query|rpc|action|middleware)\b/;
 const INFRA_TERMS = /\b(deploy|ci|cd|docker|pipeline|config|env)\b/;
 const BILLING_TERMS = /\b(payment|billing|invoice|subscription|checkout|pricing|pay)\b/;
+const DATABASE_TERMS = /\b(database|schema|migration|table|query|sql|rls|rpc|persist|persistence|data access)\b/;
 const PAYMENT_PROVIDERS = [
     { name: 'Stripe', pattern: /\bstripe\b/ },
     { name: 'PayPal', pattern: /\bpaypal\b/ },
@@ -17,8 +18,10 @@ const PAYMENT_PROVIDERS = [
  * Any signal set to true means the corresponding question can be suppressed.
  */
 export function extractSignals(description) {
-    const lower = description.toLowerCase();
+    const lower = stripIncidentalReferences(description.toLowerCase());
     const hasTarget = FRONTEND_TERMS.test(lower) || BACKEND_TERMS.test(lower) || INFRA_TERMS.test(lower);
+    const hasDatabase = DATABASE_TERMS.test(lower);
+    const hasUi = FRONTEND_TERMS.test(lower);
     let namedProvider = null;
     for (const { name, pattern } of PAYMENT_PROVIDERS) {
         if (pattern.test(lower)) {
@@ -30,6 +33,12 @@ export function extractSignals(description) {
     const hasBilling = BILLING_TERMS.test(lower) || namedProvider !== null;
     const wordCount = description.trim().split(/\s+/).length;
     const hasScope = wordCount >= 10;
-    return { hasTarget, hasBilling, namedProvider, hasScope };
+    return { hasTarget, hasBilling, hasDatabase, hasUi, namedProvider, hasScope };
+}
+function stripIncidentalReferences(description) {
+    return description
+        .replace(/`[^`]*(?:\/|\.\w{1,8})[^`]*`/g, ' ')
+        .replace(/\b\S+\/\S+\b/g, ' ')
+        .replace(/\b[\w-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|css|scss|py|go|rs|java|rb|php)\b/g, ' ');
 }
 //# sourceMappingURL=answer-extractor.js.map

package/dist/engine/skill-generator/skill-definitions.js

@@ -327,8 +327,8 @@ Route a new workflow pattern to the correct skill or rule file.
 
 1. Identify the new pattern or lesson.
 2. Determine target: skill file, CLAUDE.md rule, or MEMORY.md.
-3. If skill: update \`.claude/skills/{name}/skill.md\`.
-4. If rule: update \`~/.claude/rules/{category}.md\`.
+3. If skill: update \`.claude/skills/<skill-name>/skill.md\`.
+4. If rule: update \`~/.claude/rules/<category>.md\`.
 5. If permanent memory: update \`MEMORY.md\`.
 6. Commit the updated file.
 
@@ -416,8 +416,8 @@ Design and implement an MCP tool.
 ## Steps
 
 1. Create spec for the tool (use \`create_spec\`).
-2. Define input schema (Zod) in \`src/tools/{name}/schema.ts\`.
-3. Implement handler in \`src/tools/{name}/handler.ts\`.
+2. Define input schema (Zod) in \`src/tools/<tool-name>/schema.ts\`.
+3. Implement handler in \`src/tools/<tool-name>/handler.ts\`.
 4. Register tool in \`src/tools/index.ts\`.
 5. Write unit + integration tests.
 6. Run: \`{test_cmd}\`

package/dist/hosts/claude-code/ux/skills-writer.js

@@ -1,5 +1,5 @@
 // hosts/claude-code/ux/skills-writer.ts — SPEC-588
-// Builds and writes .claude/skills/planu-*.md files (4 skills).
+// Builds and writes .claude/skills/planu-*.md files.
 // Idempotent: skips files whose content already matches the template.
 import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -12,6 +12,7 @@ const SKILL_SLUGS = [
     'planu-resume-work',
     'planu-release',
     'planu-validate',
+    'planu-native',
 ];
 /** Resolve the canonical skill-templates directory (works after tsc compilation). */
 function resolveSkillTemplateDir() {

package/dist/index.js

@@ -22,6 +22,7 @@ const KNOWN_COMMANDS = [
     'watch',
     'spec',
     'health',
+    'release',
     'help',
     'version',
 ];

package/dist/native/lightweight-command-catalog.d.ts

@@ -0,0 +1,59 @@
+import type { LightweightCommand, LightweightHost, NativeSurfaceManifest } from '../types/native.js';
+export declare const LIGHTWEIGHT_COMMANDS: readonly [{
+    readonly id: "planu.status";
+    readonly title: "Project status";
+    readonly description: "Show the compact Planu project snapshot without loading the MCP tool graph.";
+    readonly invocation: "planu status";
+    readonly hosts: readonly ["codex", "claude-code"];
+    readonly requiresMcp: false;
+    readonly requiresDaemon: false;
+    readonly mapsTo: "handlePlanStatus";
+}, {
+    readonly id: "planu.spec.create";
+    readonly title: "Create spec";
+    readonly description: "Create a new spec through the CLI-backed SDD contract.";
+    readonly invocation: "planu spec create \"<title>\"";
+    readonly hosts: readonly ["codex", "claude-code"];
+    readonly requiresMcp: false;
+    readonly requiresDaemon: false;
+    readonly mapsTo: "handleCreateSpec";
+}, {
+    readonly id: "planu.spec.list";
+    readonly title: "List specs";
+    readonly description: "List specs in the current project with optional status/type filters.";
+    readonly invocation: "planu spec list";
+    readonly hosts: readonly ["codex", "claude-code"];
+    readonly requiresMcp: false;
+    readonly requiresDaemon: false;
+    readonly mapsTo: "handleListSpecs";
+}, {
+    readonly id: "planu.spec.validate";
+    readonly title: "Validate spec";
+    readonly description: "Validate a spec against the current codebase from the native CLI surface.";
+    readonly invocation: "planu spec validate SPEC-001";
+    readonly hosts: readonly ["codex", "claude-code"];
+    readonly requiresMcp: false;
+    readonly requiresDaemon: false;
+    readonly mapsTo: "handleValidate";
+}, {
+    readonly id: "planu.audit.debt";
+    readonly title: "Audit technical debt";
+    readonly description: "Run the read-only project audit path for lightweight debt checks.";
+    readonly invocation: "planu audit debt";
+    readonly hosts: readonly ["codex", "claude-code"];
+    readonly requiresMcp: false;
+    readonly requiresDaemon: false;
+    readonly mapsTo: "handleAudit";
+}, {
+    readonly id: "planu.release.check";
+    readonly title: "Check release readiness";
+    readonly description: "Check local branch cleanliness and main/develop/release sync readiness.";
+    readonly invocation: "planu release check";
+    readonly hosts: readonly ["codex", "claude-code"];
+    readonly requiresMcp: false;
+    readonly requiresDaemon: false;
+    readonly mapsTo: "releaseCommand";
+}];
+export declare function getLightweightCommands(host?: LightweightHost): readonly LightweightCommand[];
+export declare function buildNativeSurfaceManifest(version?: string): NativeSurfaceManifest;
+//# sourceMappingURL=lightweight-command-catalog.d.ts.map

package/dist/native/lightweight-command-catalog.js

@@ -0,0 +1,94 @@
+// native/lightweight-command-catalog.ts — SPEC-1069 native/plugin-lite command surface.
+import { PLANU_VERSION } from '../config/version.js';
+export const LIGHTWEIGHT_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'],
+        requiresMcp: false,
+        requiresDaemon: false,
+        mapsTo: 'handlePlanStatus',
+    },
+    {
+        id: 'planu.spec.create',
+        title: 'Create spec',
+        description: 'Create a new spec through the CLI-backed SDD contract.',
+        invocation: 'planu spec create "<title>"',
+        hosts: ['codex', 'claude-code'],
+        requiresMcp: false,
+        requiresDaemon: false,
+        mapsTo: 'handleCreateSpec',
+    },
+    {
+        id: 'planu.spec.list',
+        title: 'List specs',
+        description: 'List specs in the current project with optional status/type filters.',
+        invocation: 'planu spec list',
+        hosts: ['codex', 'claude-code'],
+        requiresMcp: false,
+        requiresDaemon: false,
+        mapsTo: 'handleListSpecs',
+    },
+    {
+        id: 'planu.spec.validate',
+        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'],
+        requiresMcp: false,
+        requiresDaemon: false,
+        mapsTo: 'handleValidate',
+    },
+    {
+        id: 'planu.audit.debt',
+        title: 'Audit technical debt',
+        description: 'Run the read-only project audit path for lightweight debt checks.',
+        invocation: 'planu audit debt',
+        hosts: ['codex', 'claude-code'],
+        requiresMcp: false,
+        requiresDaemon: false,
+        mapsTo: 'handleAudit',
+    },
+    {
+        id: 'planu.release.check',
+        title: 'Check release readiness',
+        description: 'Check local branch cleanliness and main/develop/release sync readiness.',
+        invocation: 'planu release check',
+        hosts: ['codex', 'claude-code'],
+        requiresMcp: false,
+        requiresDaemon: false,
+        mapsTo: 'releaseCommand',
+    },
+];
+export function getLightweightCommands(host) {
+    if (host === undefined) {
+        return LIGHTWEIGHT_COMMANDS;
+    }
+    return LIGHTWEIGHT_COMMANDS.filter((command) => command.hosts.includes(host));
+}
+export function buildNativeSurfaceManifest(version = PLANU_VERSION) {
+    return {
+        name: 'dev.planu.native',
+        displayName: 'Planu Native Lightweight Surface',
+        version,
+        packageName: '@planu/cli',
+        modes: {
+            lightweight: {
+                requiresMcp: false,
+                requiresDaemon: false,
+                hosts: ['codex', 'claude-code'],
+                commands: LIGHTWEIGHT_COMMANDS,
+                fullMcpFallback: 'Use full MCP mode for advanced lifecycle mutations, generators, governance, and automation beyond the curated lightweight commands.',
+            },
+            fullMcp: {
+                requiresMcp: true,
+                requiresDaemon: false,
+                manifest: 'planu-plugin.json',
+                useWhen: 'Use full MCP mode when the task needs the complete Planu tool graph, MCP resources, prompts, or multi-step automation.',
+            },
+        },
+    };
+}
+//# sourceMappingURL=lightweight-command-catalog.js.map

package/dist/tools/create-spec/autopilot-analyzer.js

@@ -71,7 +71,6 @@ export async function analyzeProjectForSpec(projectPath, description, title, kno
     // Detect stack patterns and suggest relevant criteria
     if (knowledge) {
         result.detectedPatterns = detectPatterns(knowledge, description);
-        result.suggestedCriteria = generatePatternCriteria(result.detectedPatterns, knowledge);
     }
     return result;
 }
@@ -139,16 +138,32 @@ function inferTestPath(srcPath) {
 function detectPatterns(knowledge, description) {
     const patterns = [];
     const desc = description.toLowerCase();
-    if (desc.includes('data') ||
+    const hasDatabaseIntent = desc.includes('data') ||
         desc.includes('database') ||
         desc.includes('tabla') ||
-        desc.includes('schema')) {
+        desc.includes('schema') ||
+        desc.includes('rls') ||
+        desc.includes('rpc') ||
+        desc.includes('migration') ||
+        desc.includes('persistence') ||
+        desc.includes('data access');
+    const hasUiIntent = desc.includes('component') ||
+        desc.includes('ui') ||
+        desc.includes('page') ||
+        desc.includes('screen') ||
+        desc.includes('form') ||
+        desc.includes('layout') ||
+        desc.includes('style') ||
+        desc.includes('button') ||
+        desc.includes('modal') ||
+        desc.includes('dialog');
+    if (hasDatabaseIntent) {
         patterns.push('database');
     }
     if (knowledge.framework?.toLowerCase().includes('next') && desc.includes('page')) {
         patterns.push('nextjs-pages');
     }
-    if (knowledge.framework?.toLowerCase().includes('react')) {
+    if (knowledge.framework?.toLowerCase().includes('react') && hasUiIntent) {
         patterns.push('react-components');
     }
     if (desc.includes('api') || desc.includes('endpoint')) {
@@ -160,7 +175,7 @@ function detectPatterns(knowledge, description) {
     if (desc.includes('test') || desc.includes('coverage')) {
         patterns.push('testing');
     }
-    if (knowledge.stack.some((s) => s.toLowerCase().includes('supabase'))) {
+    if (knowledge.stack.some((s) => s.toLowerCase().includes('supabase')) && hasDatabaseIntent) {
         patterns.push('supabase');
     }
     // SPEC-535: Detect LLM/foundation model features for EU AI Act Article 53-55 compliance
@@ -180,42 +195,4 @@ function detectPatterns(knowledge, description) {
     }
     return patterns;
 }
-/** Generate stack-specific criteria based on detected patterns — GIVEN/WHEN/THEN format. */
-function generatePatternCriteria(patterns, _knowledge) {
-    const criteria = [];
-    for (const pattern of patterns) {
-        switch (pattern) {
-            case 'database':
-                criteria.push('GIVEN migration WHEN applied to the database THEN target table exists with columns [id, created_at] and correct data types');
-                break;
-            case 'supabase':
-                criteria.push('GIVEN unauthenticated request WHEN RLS policy is active on the table THEN query returns empty array instead of data');
-                criteria.push('GIVEN schema change WHEN supabase gen types runs THEN TypeScript types reflect the new columns without manual edits');
-                break;
-            case 'api-endpoint':
-                criteria.push('GIVEN POST handler WHEN called with invalid body (missing required field) THEN returns {status: 400, error: string}');
-                criteria.push('GIVEN POST handler WHEN called with valid body THEN validates input with Zod schema before processing');
-                break;
-            case 'authentication':
-                criteria.push('GIVEN endpoint WHEN called with no Authorization header THEN returns {status: 401}');
-                break;
-            case 'react-components':
-                criteria.push('GIVEN component WHEN rendered THEN has role attribute and aria-label set correctly for screen readers');
-                break;
-            case 'nextjs-pages':
-                criteria.push('GIVEN page component WHEN rendered THEN uses Server Component (no "use client" directive) where data-fetching occurs');
-                break;
-            case 'testing':
-                criteria.push('GIVEN test file WHEN run with vitest THEN coverage >= threshold defined in vitest.config for branches and lines');
-                break;
-            // SPEC-535: EU AI Act Article 53-55 compliance criteria for foundation model features
-            case 'llm-feature':
-                criteria.push('GIVEN the feature uses a foundation model WHEN the spec is implemented THEN spec.md documents in its inline Technical section: model name, provider (Anthropic/OpenAI/Google), and access date — required by EU AI Act Article 53(1)(a)');
-                criteria.push('GIVEN EU users interact with this feature WHEN the feature is deployed THEN an acceptable use policy is visible before the first AI interaction — required by EU AI Act Article 53(1)(c)');
-                criteria.push("GIVEN the feature processes user-generated content via LLM WHEN any EU user's data is involved THEN the privacy notice explicitly states LLM processing and links to the model provider's data processing terms");
-                break;
-        }
-    }
-    return criteria;
-}
 //# sourceMappingURL=autopilot-analyzer.js.map

package/dist/tools/create-spec/question-generator.js

@@ -45,6 +45,12 @@ function hasRequiredSignal(key, signals) {
     if (key === 'hasBilling') {
         return signals.hasBilling;
     }
+    if (key === 'hasDatabase') {
+        return signals.hasDatabase;
+    }
+    if (key === 'hasUi') {
+        return signals.hasUi;
+    }
     if (key === 'hasTarget') {
         return signals.hasTarget;
     }

package/dist/tools/create-spec.js

@@ -24,7 +24,6 @@ import { analyzeProjectForSpec, getEmptyAutopilotResult, } from './create-spec/a
 import { AutopilotSummaryCollector } from '../engine/autopilot/summary-collector.js';
 import { trackCost } from '../engine/cost-tracking/operation-tracker.js';
 import { analyzeSimplicity } from '../engine/simplicity-detector.js';
-import { filterCriteriaByTags } from '../engine/acceptance-criteria-injector/criteria-filter.js';
 import { withBudget, unwrapBudget, withTotalBudget } from '../engine/timing/budget.js';
 import { measureStep } from '../engine/timing/structured-log.js';
 import { resolveProjectIdOrAutoDetect } from './resolve-project-id.js';
@@ -514,8 +513,7 @@ export async function handleCreateSpec(inputParams, server) {
                 }
                 // Create spec directory and write lean files (SPEC-461)
                 await measureStep('mkdir-specDir', () => mkdir(specDir, { recursive: true }));
-                // SPEC-586: Filter suggested criteria by spec tags/target/scope before injection
-                const filteredCriteria = await filterCriteriaByTags(autopilot.suggestedCriteria, spec.tags, spec.target, spec.scope).catch(() => autopilot.suggestedCriteria);
+                const filteredCriteria = autopilot.suggestedCriteria;
                 const technologyContract = await readTechnologySelectionContract(params.projectPath ?? '');
                 const contractNote = technologyContract
                     ? [

package/dist/tools/init-project/host-assets-writer.js

@@ -8,6 +8,7 @@ const CORE_SKILL_TEMPLATES = [
     'planu-validate.md',
     'planu-release.md',
     'planu-resume-work.md',
+    'planu-native.md',
     'planu-multi-teammate-review.md',
     'planu-context-assets.md',
 ];

package/dist/tools/init-project/per-client-files-writer.js

@@ -64,6 +64,27 @@ Planu enforces Spec Driven Development — spec first, then implement, then vali
 - NEVER write production code before spec is \`approved\`
 - NEVER skip \`validate\` after implementation
 `;
+const CODEX_NATIVE_SKILL_CONTENT = `# planu-native — Planu Lightweight Native Surface
+
+Auto-generated by \`init_project\`.
+
+## Overview
+
+Use Planu's lightweight CLI surface for common SDD checks without loading the full MCP tool graph.
+
+## Native Commands
+
+- \`planu status\` — compact project snapshot
+- \`planu spec create "<title>"\` — create a spec
+- \`planu spec list\` — list specs
+- \`planu spec validate SPEC-001\` — validate one spec
+- \`planu audit debt\` — read-only technical debt audit
+- \`planu release check\` — local release readiness check
+
+## Escalate to Full MCP
+
+Use full MCP mode for advanced lifecycle automation, generators, governance tools, MCP resources, prompts, or multi-step orchestration.
+`;
 async function writeIfMissing(filePath, content) {
     try {
         await access(filePath);
@@ -84,6 +105,10 @@ async function writeCursorMdc(projectPath) {
 async function writeCodexSkill(projectPath) {
     return writeIfMissing(join(projectPath, '.agents', 'skills', 'planu-sdd.md'), CODEX_SKILL_CONTENT);
 }
+/** SPEC-1069: Generate .agents/skills/planu-native.md for Codex lightweight mode. */
+async function writeCodexNativeSkill(projectPath) {
+    return writeIfMissing(join(projectPath, '.agents', 'skills', 'planu-native.md'), CODEX_NATIVE_SKILL_CONTENT);
+}
 /**
  * SPEC-648: Detect LLM client and generate the appropriate config files.
  * AGENTS.md is always assumed to be generated by generateAgentFilesIfMissing.
@@ -100,10 +125,16 @@ export async function generatePerClientFiles(projectPath) {
         }
     }
     if (detectedClient === 'codex') {
-        const written = await writeCodexSkill(projectPath);
-        if (written) {
+        const [sddWritten, nativeWritten] = await Promise.all([
+            writeCodexSkill(projectPath),
+            writeCodexNativeSkill(projectPath),
+        ]);
+        if (sddWritten) {
             filesWritten.push('.agents/skills/planu-sdd.md');
         }
+        if (nativeWritten) {
+            filesWritten.push('.agents/skills/planu-native.md');
+        }
     }
     return { detectedClient, filesWritten };
 }

package/dist/types/clarification.d.ts

@@ -25,6 +25,8 @@ export interface InteractiveClarificationResponse {
 export interface DescriptionSignals {
     hasTarget: boolean;
     hasBilling: boolean;
+    hasDatabase: boolean;
+    hasUi: boolean;
     namedProvider: string | null;
     hasScope: boolean;
 }

package/dist/types/index.d.ts

@@ -236,7 +236,6 @@ export * from './observatory.js';
 export * from './orphan-spec-refs.js';
 export * from './session-safeguard.js';
 export * from './impact-detection.js';
-export * from './criteria-injection.js';
 export * from './gemini.js';
 export * from './claude-code-runtime.js';
 export * from './claude-code-ux.js';

package/dist/types/index.js

@@ -233,7 +233,6 @@ export * from './observatory.js';
 export * from './orphan-spec-refs.js';
 export * from './session-safeguard.js';
 export * from './impact-detection.js';
-export * from './criteria-injection.js';
 export * from './gemini.js';
 export * from './claude-code-runtime.js';
 export * from './claude-code-ux.js';

package/dist/types/native.d.ts

@@ -0,0 +1,33 @@
+export type LightweightHost = 'codex' | 'claude-code';
+export interface LightweightCommand {
+    id: string;
+    title: string;
+    description: string;
+    invocation: string;
+    hosts: readonly LightweightHost[];
+    requiresMcp: boolean;
+    requiresDaemon: boolean;
+    mapsTo: string;
+}
+export interface NativeSurfaceManifest {
+    name: string;
+    displayName: string;
+    version: string;
+    packageName: string;
+    modes: {
+        lightweight: {
+            requiresMcp: false;
+            requiresDaemon: false;
+            hosts: readonly LightweightHost[];
+            commands: readonly LightweightCommand[];
+            fullMcpFallback: string;
+        };
+        fullMcp: {
+            requiresMcp: true;
+            requiresDaemon: false;
+            manifest: string;
+            useWhen: string;
+        };
+    };
+}
+//# sourceMappingURL=native.d.ts.map

package/dist/types/native.js

@@ -0,0 +1,3 @@
+// types/native.ts — Native/plugin-lite surface types (SPEC-1069)
+export {};
+//# sourceMappingURL=native.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.3.13",
+  "version": "4.3.15",
   "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",
@@ -13,6 +13,8 @@
     "!dist/**/*.map",
     "!dist/engine/*.node",
     "src/i18n/messages/",
+    "planu-native.json",
+    "planu-plugin.json",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
@@ -32,14 +34,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "4.3.13",
-    "@planu/core-darwin-x64": "4.3.13",
-    "@planu/core-linux-arm64-gnu": "4.3.13",
-    "@planu/core-linux-arm64-musl": "4.3.13",
-    "@planu/core-linux-x64-gnu": "4.3.13",
-    "@planu/core-linux-x64-musl": "4.3.13",
-    "@planu/core-win32-arm64-msvc": "4.3.13",
-    "@planu/core-win32-x64-msvc": "4.3.13"
+    "@planu/core-darwin-arm64": "4.3.15",
+    "@planu/core-darwin-x64": "4.3.15",
+    "@planu/core-linux-arm64-gnu": "4.3.15",
+    "@planu/core-linux-arm64-musl": "4.3.15",
+    "@planu/core-linux-x64-gnu": "4.3.15",
+    "@planu/core-linux-x64-musl": "4.3.15",
+    "@planu/core-win32-arm64-msvc": "4.3.15",
+    "@planu/core-win32-x64-msvc": "4.3.15"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -127,7 +129,7 @@
   ],
   "license": "SEE LICENSE IN LICENSE",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.98.0",
+    "@anthropic-ai/sdk": "^0.99.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "glob": "^13.0.6",
     "yaml": "^2.9.0",
@@ -200,7 +202,7 @@
     "tsc-alias": "^1.8.17",
     "type-coverage": "^2.29.7",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.4",
+    "typescript-eslint": "^8.60.0",
     "vite": "^8.0.14",
     "vitest": "^4.1.7",
     "vue": "^3.5.34"

package/planu-native.json

@@ -0,0 +1,82 @@
+{
+  "name": "dev.planu.native",
+  "displayName": "Planu Native Lightweight Surface",
+  "version": "4.3.15",
+  "packageName": "@planu/cli",
+  "modes": {
+    "lightweight": {
+      "requiresMcp": false,
+      "requiresDaemon": false,
+      "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"],
+          "requiresMcp": false,
+          "requiresDaemon": false,
+          "mapsTo": "handlePlanStatus"
+        },
+        {
+          "id": "planu.spec.create",
+          "title": "Create spec",
+          "description": "Create a new spec through the CLI-backed SDD contract.",
+          "invocation": "planu spec create \"<title>\"",
+          "hosts": ["codex", "claude-code"],
+          "requiresMcp": false,
+          "requiresDaemon": false,
+          "mapsTo": "handleCreateSpec"
+        },
+        {
+          "id": "planu.spec.list",
+          "title": "List specs",
+          "description": "List specs in the current project with optional status/type filters.",
+          "invocation": "planu spec list",
+          "hosts": ["codex", "claude-code"],
+          "requiresMcp": false,
+          "requiresDaemon": false,
+          "mapsTo": "handleListSpecs"
+        },
+        {
+          "id": "planu.spec.validate",
+          "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"],
+          "requiresMcp": false,
+          "requiresDaemon": false,
+          "mapsTo": "handleValidate"
+        },
+        {
+          "id": "planu.audit.debt",
+          "title": "Audit technical debt",
+          "description": "Run the read-only project audit path for lightweight debt checks.",
+          "invocation": "planu audit debt",
+          "hosts": ["codex", "claude-code"],
+          "requiresMcp": false,
+          "requiresDaemon": false,
+          "mapsTo": "handleAudit"
+        },
+        {
+          "id": "planu.release.check",
+          "title": "Check release readiness",
+          "description": "Check local branch cleanliness and main/develop/release sync readiness.",
+          "invocation": "planu release check",
+          "hosts": ["codex", "claude-code"],
+          "requiresMcp": false,
+          "requiresDaemon": false,
+          "mapsTo": "releaseCommand"
+        }
+      ],
+      "fullMcpFallback": "Use full MCP mode for advanced lifecycle mutations, generators, governance, and automation beyond the curated lightweight commands."
+    },
+    "fullMcp": {
+      "requiresMcp": true,
+      "requiresDaemon": false,
+      "manifest": "planu-plugin.json",
+      "useWhen": "Use full MCP mode when the task needs the complete Planu tool graph, MCP resources, prompts, or multi-step automation."
+    }
+  }
+}

package/planu-plugin.json

@@ -0,0 +1,39 @@
+{
+  "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.3.15",
+  "icon": "assets/plugin/icon.svg",
+  "command": ["npx", "@planu/cli@latest"],
+  "packageName": "@planu/cli",
+  "capabilities": {
+    "tools": [
+      "planu_status",
+      "facilitate",
+      "init_project",
+      "clarify_requirements",
+      "create_spec",
+      "challenge_spec",
+      "check_readiness",
+      "update_status",
+      "package_handoff",
+      "validate",
+      "reconcile_spec",
+      "create_rule",
+      "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"]
+  },
+  "compatibility": {
+    "minimumHostVersion": "1.0.0",
+    "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"]
+}

package/dist/config/criteria-injection-rules.json

@@ -1,82 +0,0 @@
-{
-  "version": 1,
-  "rules": [
-    {
-      "id": "eu-ai-act-53-1a",
-      "criterion": "GIVEN the feature uses a foundation model WHEN the spec is implemented THEN spec.md documents in its inline Technical section: model name, provider, and access date — EU AI Act Article 53(1)(a)",
-      "requiresTags": ["llm", "foundation-model", "ai-feature"],
-      "requiresTargets": [],
-      "requiresScopes": []
-    },
-    {
-      "id": "eu-ai-act-53-1c",
-      "criterion": "GIVEN EU users interact with this feature WHEN the feature is deployed THEN an acceptable use policy is visible before the first AI interaction — required by EU AI Act Article 53(1)(c)",
-      "requiresTags": ["llm", "foundation-model", "ai-feature"],
-      "requiresTargets": [],
-      "requiresScopes": []
-    },
-    {
-      "id": "eu-ai-act-privacy",
-      "criterion": "GIVEN the feature processes user-generated content via LLM WHEN any EU user's data is involved THEN the privacy notice explicitly states LLM processing and links to the model provider's data processing terms",
-      "requiresTags": ["llm", "foundation-model", "ai-feature"],
-      "requiresTargets": [],
-      "requiresScopes": []
-    },
-    {
-      "id": "vitest-coverage",
-      "criterion": "GIVEN test file WHEN run with vitest THEN coverage >= threshold defined in vitest.config for branches and lines",
-      "requiresTags": [],
-      "requiresTargets": ["backend", "frontend", "shared", "fullstack"],
-      "requiresScopes": []
-    },
-    {
-      "id": "db-migration",
-      "criterion": "GIVEN migration WHEN applied to the database THEN target table exists with columns [id, created_at] and correct data types",
-      "requiresTags": ["database", "migration"],
-      "requiresTargets": ["database"],
-      "requiresScopes": []
-    },
-    {
-      "id": "api-zod-invalid",
-      "criterion": "GIVEN POST handler WHEN called with invalid body THEN returns {status: 400, error: string}",
-      "requiresTags": ["api", "endpoint", "http"],
-      "requiresTargets": [],
-      "requiresScopes": []
-    },
-    {
-      "id": "api-zod-valid",
-      "criterion": "GIVEN POST handler WHEN called with valid body THEN validates input with Zod schema before processing",
-      "requiresTags": ["api", "endpoint", "http"],
-      "requiresTargets": [],
-      "requiresScopes": []
-    },
-    {
-      "id": "otel-http-metrics",
-      "criterion": "GIVEN HTTP requests WHEN the service runs THEN histogram http.server.request.duration records P50/P95/P99 latency with http.method, http.status_code, and http.route attributes",
-      "requiresTags": ["otel", "observability", "monitoring"],
-      "requiresTargets": [],
-      "requiresScopes": []
-    },
-    {
-      "id": "otel-traces",
-      "criterion": "GIVEN any inbound request WHEN processed THEN a trace span is created with service.name, trace_id, and span_id attributes exported to the configured OTel collector",
-      "requiresTags": ["otel", "observability", "monitoring"],
-      "requiresTargets": [],
-      "requiresScopes": []
-    },
-    {
-      "id": "resilience-retry",
-      "criterion": "GIVEN an external service call WHEN the call fails with a transient error THEN the client retries up to 3 times with exponential backoff before returning an error",
-      "requiresTags": ["resilience", "reliability"],
-      "requiresTargets": [],
-      "requiresScopes": []
-    },
-    {
-      "id": "resilience-circuit-breaker",
-      "criterion": "GIVEN repeated failures from an external dependency WHEN the failure rate exceeds 50% in a 10s window THEN the circuit breaker opens and fast-fails subsequent calls for 30s",
-      "requiresTags": ["resilience", "reliability"],
-      "requiresTargets": [],
-      "requiresScopes": []
-    }
-  ]
-}

package/dist/engine/acceptance-criteria-injector/criteria-filter.d.ts

@@ -1,12 +0,0 @@
-/** Invalidate the rules cache (useful in tests). */
-export declare function clearRulesCache(): void;
-/**
- * Filter a list of candidate criteria against the injection rules.
- * Returns only criteria that pass the tag/target/scope gate.
- */
-export declare function filterCriteriaByTags(candidates: string[], specTags: string[], specTarget: string, specScope: string): Promise<string[]>;
-/**
- * Check whether the EU AI Act criteria should be injected for this spec.
- */
-export declare function shouldInjectEuAiActCriteria(specTags: string[]): Promise<boolean>;
-//# sourceMappingURL=criteria-filter.d.ts.map

package/dist/engine/acceptance-criteria-injector/criteria-filter.js

@@ -1,60 +0,0 @@
-// engine/acceptance-criteria-injector/criteria-filter.ts — SPEC-586: Tag-aware criteria filter
-import { readFile } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-let cachedRules = null;
-const RULES_PATH = join(dirname(fileURLToPath(import.meta.url)), '../../config/criteria-injection-rules.json');
-async function loadRules() {
-    if (cachedRules !== null) {
-        return cachedRules;
-    }
-    try {
-        const content = await readFile(RULES_PATH, 'utf-8');
-        const parsed = JSON.parse(content);
-        cachedRules = parsed.rules;
-        return cachedRules;
-    }
-    catch {
-        return [];
-    }
-}
-/** Invalidate the rules cache (useful in tests). */
-export function clearRulesCache() {
-    cachedRules = null;
-}
-function ruleApplies(rule, specTags, specTarget, specScope) {
-    const tagsMatch = rule.requiresTags.length === 0 || rule.requiresTags.some((t) => specTags.includes(t));
-    const targetsMatch = rule.requiresTargets.length === 0 || rule.requiresTargets.includes(specTarget);
-    const scopesMatch = rule.requiresScopes.length === 0 || rule.requiresScopes.includes(specScope);
-    return tagsMatch && targetsMatch && scopesMatch;
-}
-/**
- * Filter a list of candidate criteria against the injection rules.
- * Returns only criteria that pass the tag/target/scope gate.
- */
-export async function filterCriteriaByTags(candidates, specTags, specTarget, specScope) {
-    const rules = await loadRules();
-    if (rules.length === 0) {
-        return candidates;
-    }
-    return candidates.filter((criterion) => {
-        const matchingRule = rules.find((r) => criterion.toLowerCase().includes(r.criterion.toLowerCase().slice(0, 40)) ||
-            r.criterion.toLowerCase().includes(criterion.toLowerCase().slice(0, 40)));
-        if (!matchingRule) {
-            return true;
-        }
-        return ruleApplies(matchingRule, specTags, specTarget, specScope);
-    });
-}
-/**
- * Check whether the EU AI Act criteria should be injected for this spec.
- */
-export async function shouldInjectEuAiActCriteria(specTags) {
-    const rules = await loadRules();
-    const euRule = rules.find((r) => r.id === 'eu-ai-act-53-1a');
-    if (!euRule) {
-        return true;
-    }
-    return euRule.requiresTags.some((t) => specTags.includes(t));
-}
-//# sourceMappingURL=criteria-filter.js.map

package/dist/types/criteria-injection.d.ts

@@ -1,12 +0,0 @@
-export interface InjectionRule {
-    id: string;
-    criterion: string;
-    requiresTags: string[];
-    requiresTargets: string[];
-    requiresScopes: string[];
-}
-export interface RulesFile {
-    version: number;
-    rules: InjectionRule[];
-}
-//# sourceMappingURL=criteria-injection.d.ts.map

package/dist/types/criteria-injection.js

@@ -1,3 +0,0 @@
-// types/criteria-injection.ts — SPEC-586: Criteria injection rule types
-export {};
-//# sourceMappingURL=criteria-injection.js.map