@planu/cli 3.9.6 → 3.9.8

package/dist/config/skill-templates/planu-context-assets.md

@@ -0,0 +1,94 @@
+---
+name: planu-context-assets
+description: Create project-specific Planu rules or skills from the current app context so recurring standards and workflows become reusable agent guidance instead of MCP tool bloat.
+triggers:
+  - create project rules
+  - create project skills
+  - capture this workflow
+  - make this a rule
+  - make this a skill
+  - codify this pattern
+  - project context changed
+  - app conventions
+version: 1.0.0
+---
+
+# /planu-context-assets — Create Rules or Skills from App Context
+
+## When to invoke
+
+Use this skill when project context reveals a recurring convention, workflow, integration, domain rule, or implementation pattern that future agents should reuse.
+
+Examples:
+
+- A design system rule is discovered while implementing UI.
+- A release or deployment workflow becomes stable.
+- A legacy cleanup pattern repeats across modules.
+- A domain invariant must never be violated.
+- A framework-specific project convention is discovered during analysis.
+
+## Decision rule
+
+Create a **rule** when the guidance is mandatory and should constrain every future agent:
+
+- architecture boundaries
+- spec quality gates
+- release policy
+- BDD/SDD invariants
+- security or data handling rules
+- "never do X" / "always do Y" project standards
+
+Create a **skill** when the guidance is an optional workflow invoked for a specific task:
+
+- release workflow
+- Figma implementation workflow
+- legacy characterization workflow
+- domain bundle generation
+- integration setup
+- migration playbook
+- debugging or audit procedure
+
+Do not create either when the information is one-off, speculative, or already covered by an existing rule/skill.
+
+## Workflow
+
+1. Inspect the current context and existing project assets:
+   - `AGENTS.md`
+   - `CLAUDE.md`
+   - `.claude/rules/`
+   - `.claude/skills/`
+   - `.gemini/conventions.md`
+   - `.gemini/skills/`
+   - `.opencode/rules/`
+   - `.opencode/skills/`
+2. Decide whether the new asset is a rule, a skill, or nothing.
+3. Keep the asset small and operational:
+   - one purpose
+   - explicit trigger
+   - concrete steps or constraints
+   - verification command when applicable
+4. Use Planu host-aware tools:
+   - `create_rule` for mandatory constraints
+   - `create_skill` for reusable workflows
+5. Use `host: "auto"` unless the user explicitly targets a host.
+6. Prefer updating an existing Planu-owned asset over creating a duplicate.
+
+## Quality bar
+
+- Rules must be enforceable and written as constraints.
+- Skills must describe when to invoke, what to inspect, what to do, and what output to produce.
+- Do not reference legacy MCP tools that are not part of the 14-tool public core.
+- Do not create broad "misc" skills.
+- Do not preserve dead workflows "just in case".
+
+## Output
+
+Report:
+
+- asset type: rule or skill
+- asset name
+- host target
+- path or file updated
+- why it should exist
+- when it should trigger
+

package/dist/engine/handoff-packager.js

@@ -1,5 +1,7 @@
 // engine/handoff-packager.ts — Assembles handoff context package for AI agents (SPEC-039)
-import { readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { stripFrontmatter } from './frontmatter-parser.js';
 // ── Parsing helpers ──────────────────────────────────────────────────────────
 async function safeReadFile(path) {
@@ -41,11 +43,37 @@ function extractCriteria(huContent) {
     if (!huContent) {
         return [];
     }
+    const bddBlocks = extractBddCriteria(huContent);
+    if (bddBlocks.length > 0) {
+        return bddBlocks;
+    }
     return huContent
         .split('\n')
         .filter((line) => /^- \[[ x]\]/.test(line.trim()))
         .map((line) => line.trim().replace(/^- \[[ x]\]\s*/, ''));
 }
+function extractBddCriteria(content) {
+    const criteria = [];
+    let current = [];
+    for (const rawLine of content.split('\n')) {
+        const trimmed = rawLine.trim().replace(/^-+\s*/, '');
+        if (/^(GIVEN|WHEN|THEN|AND)\b/i.test(trimmed)) {
+            if (/^GIVEN\b/i.test(trimmed) && current.length > 0) {
+                criteria.push(current.join(' / '));
+                current = [];
+            }
+            current.push(trimmed);
+        }
+        else if (current.length > 0 && trimmed === '') {
+            criteria.push(current.join(' / '));
+            current = [];
+        }
+    }
+    if (current.length > 0) {
+        criteria.push(current.join(' / '));
+    }
+    return criteria.filter((criterion) => /GIVEN\b/i.test(criterion) && /WHEN\b/i.test(criterion) && /THEN\b/i.test(criterion));
+}
 function extractFilesFromFicha(fichaContent) {
     if (!fichaContent) {
         return { toModify: [], toCreate: [] };
@@ -88,6 +116,35 @@ function extractFilesFromFicha(fichaContent) {
     }
     return { toModify, toCreate };
 }
+function extractBacktickedFiles(content) {
+    const files = new Set();
+    const matches = content.matchAll(/`([^`\n]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|yml|yaml|sh|css|scss|html))`/g);
+    for (const match of matches) {
+        const filePath = match[1]?.trim();
+        if (filePath && !filePath.includes(' ')) {
+            files.add(filePath);
+        }
+    }
+    return [...files];
+}
+function extractLinesByKeywords(content, keywords) {
+    return content
+        .split('\n')
+        .map((line) => line.trim().replace(/^[-*]\s*/, ''))
+        .filter((line) => line.length > 0 && keywords.test(line))
+        .slice(0, 12);
+}
+function extractOperationalSections(content, spec) {
+    return {
+        testPlan: extractLinesByKeywords(content, /\b(test|typecheck|lint|vitest|playwright|verification|validate|pnpm|npm)\b/i),
+        risks: extractLinesByKeywords(content, /\b(risk|edge|failure|security|drift|migration|breaking|compatibility|rollback)\b/i),
+        ownership: extractLinesByKeywords(content, /\b(owner|ownership|wave|agent|reviewer|arbiter|files?|responsible)\b/i),
+        currentState: `Spec ${spec.id} is ${spec.status}; implementation must follow the approved spec artifact, not chat history.`,
+        nextAction: spec.status === 'approved'
+            ? 'Move to implementing with this handoff, then implement only the listed scope.'
+            : 'Review the current spec status and move through the required SDD gates before implementation.',
+    };
+}
 function extractOutOfScope(huContent, spec) {
     if (!huContent) {
         return [
@@ -155,13 +212,24 @@ export async function packageHandoff(spec, knowledge) {
     }
     const objective = extractObjective(huContent, spec);
     const criteria = extractCriteria(huContent);
-    const { toModify, toCreate } = extractFilesFromFicha(fichaContent);
+    const parsedFiles = extractFilesFromFicha(fichaContent);
+    const discoveredFiles = extractBacktickedFiles(`${huContent}\n${fichaContent}`);
+    const toModify = parsedFiles.toModify.length > 0 ? parsedFiles.toModify : discoveredFiles;
+    const toCreate = parsedFiles.toCreate;
     const outOfScope = extractOutOfScope(huContent, spec);
     const constraints = buildConstraints(knowledge);
+    const operational = extractOperationalSections(`${huContent}\n${fichaContent}`, spec);
     if (criteria.length === 0) {
-        warnings.push('No acceptance criteria found in HU.md — criteria list will be empty');
+        warnings.push('No acceptance criteria found with complete BDD structure — implementation handoff is blocked');
     }
-    return {
+    const blockers = [
+        ...(criteria.length === 0 ? ['Missing BDD acceptance criteria'] : []),
+        ...(toModify.length + toCreate.length === 0 ? ['Missing file ownership / target files'] : []),
+        ...(operational.testPlan.length === 0 ? ['Missing test plan'] : []),
+        ...(operational.risks.length === 0 ? ['Missing risk analysis'] : []),
+        ...(operational.ownership.length === 0 ? ['Missing ownership'] : []),
+    ];
+    const pkg = {
         specId: spec.id,
         generatedAt: new Date().toISOString(),
         readinessScore: 0, // caller can populate with checkSpecReadiness result
@@ -169,9 +237,88 @@ export async function packageHandoff(spec, knowledge) {
         criteria,
         filesToModify: toModify,
         filesToCreate: toCreate,
+        ownership: operational.ownership,
+        testPlan: operational.testPlan,
+        risks: operational.risks,
         outOfScope,
+        currentState: operational.currentState,
+        nextAction: operational.nextAction,
         constraints,
         warnings,
+        blocked: blockers.length > 0,
+        blockers,
     };
+    return persistHandoffIfPossible(pkg, knowledge);
+}
+function renderPersistedHandoff(pkg) {
+    return [
+        `# Implementation Handoff Package — ${pkg.specId}`,
+        '',
+        `Generated: ${pkg.generatedAt}`,
+        `Blocked: ${pkg.blocked ? 'yes' : 'no'}`,
+        '',
+        '## Objective',
+        pkg.objective,
+        '',
+        '## Acceptance Criteria (BDD)',
+        ...pkg.criteria.map((criterion) => `- ${criterion}`),
+        '',
+        '## Files To Modify',
+        ...pkg.filesToModify.map((filePath) => `- ${filePath}`),
+        '',
+        '## Files To Create',
+        ...pkg.filesToCreate.map((filePath) => `- ${filePath}`),
+        '',
+        '## Ownership',
+        ...pkg.ownership.map((item) => `- ${item}`),
+        '',
+        '## Test Plan',
+        ...pkg.testPlan.map((item) => `- ${item}`),
+        '',
+        '## Risks',
+        ...pkg.risks.map((item) => `- ${item}`),
+        '',
+        '## Out Of Scope',
+        ...pkg.outOfScope.map((item) => `- ${item}`),
+        '',
+        '## Current State',
+        pkg.currentState,
+        '',
+        '## Next Action',
+        pkg.nextAction,
+        '',
+        '## Blockers',
+        ...(pkg.blockers.length > 0 ? pkg.blockers.map((item) => `- ${item}`) : ['- None']),
+        '',
+    ].join('\n');
+}
+async function persistHandoffIfPossible(pkg, knowledge) {
+    if (!knowledge.projectPath) {
+        return pkg;
+    }
+    const handoffDir = join(knowledge.projectPath, 'planu', 'handoffs');
+    const handoffPath = join(handoffDir, `${pkg.specId}.md`);
+    const sessionContextPath = join(knowledge.projectPath, 'planu', 'session-context.md');
+    const markdown = renderPersistedHandoff(pkg);
+    try {
+        await mkdir(handoffDir, { recursive: true });
+        await writeFile(handoffPath, markdown, 'utf-8');
+    }
+    catch {
+        return {
+            ...pkg,
+            warnings: [
+                ...pkg.warnings,
+                'Could not persist handoff artifact — context gate will block implementing.',
+            ],
+            blocked: true,
+            blockers: [...pkg.blockers, 'Handoff artifact could not be persisted'],
+        };
+    }
+    const contextContent = await readFile(sessionContextPath, 'utf-8').catch(() => '');
+    const contextHash = createHash('sha256')
+        .update(`${contextContent}\n---HANDOFF---\n${markdown}`, 'utf8')
+        .digest('hex');
+    return { ...pkg, handoffPath, contextHash };
 }
 //# sourceMappingURL=handoff-packager.js.map

package/dist/engine/sdd-model-routing.d.ts

@@ -0,0 +1,16 @@
+import type { SpecStatus, UpdateStatusInput } from '../types/index.js';
+import type { SddModelTier, SddLifecyclePhase, SddRoutingGateResult, TransitionEvidenceMeta } from '../types/sdd-model-routing.js';
+export declare function requiredTierForPhase(phase: SddLifecyclePhase): SddModelTier;
+export declare function phaseForTransition(status: SpecStatus): SddLifecyclePhase | null;
+export declare function classifySddModelTier(modelId: string | undefined): SddModelTier | 'unknown';
+export declare function hashContextPackage(input: {
+    projectPath: string;
+    handoffPath?: string;
+}): Promise<string>;
+export declare function checkSddModelRoutingGate(input: {
+    params: UpdateStatusInput;
+    status: SpecStatus;
+    projectPath?: string;
+}): Promise<SddRoutingGateResult>;
+export declare function buildTransitionEvidenceMeta(params: UpdateStatusInput): TransitionEvidenceMeta;
+//# sourceMappingURL=sdd-model-routing.d.ts.map

package/dist/engine/sdd-model-routing.js

@@ -0,0 +1,195 @@
+// engine/sdd-model-routing.ts — Hard gates for SDD model tiers and context continuity.
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { classifyModelTier } from './model-tier-resolver.js';
+const FORCE_REASON_MIN_LENGTH = 100;
+export function requiredTierForPhase(phase) {
+    if (phase === 'analysis' || phase === 'arbitration') {
+        return 'max';
+    }
+    if (phase === 'review') {
+        return 'review';
+    }
+    return 'implementation';
+}
+export function phaseForTransition(status) {
+    if (status === 'approved') {
+        return 'analysis';
+    }
+    if (status === 'implementing') {
+        return 'implementation';
+    }
+    if (status === 'done') {
+        return 'arbitration';
+    }
+    return null;
+}
+export function classifySddModelTier(modelId) {
+    if (!modelId) {
+        return 'unknown';
+    }
+    const id = modelId.toLowerCase();
+    if (/opus|ultra|o1|o3|gemini.*(?:ultra|pro)|gpt-5(?:[._-]?5)?(?!.*(?:mini|nano|small|flash))/.test(id)) {
+        return 'max';
+    }
+    const modelTier = classifyModelTier(modelId);
+    if (modelTier === 'haiku') {
+        return 'implementation';
+    }
+    if (modelTier === 'opus') {
+        return 'max';
+    }
+    return 'review';
+}
+function hasTierEvidence(params, required) {
+    if (params.modelTierUsed === required) {
+        return true;
+    }
+    const classified = classifySddModelTier(params.modelId);
+    if (required === 'max') {
+        return classified === 'max';
+    }
+    if (required === 'implementation') {
+        return classified === 'implementation';
+    }
+    return classified === 'review' || classified === 'max';
+}
+function forceReason(params) {
+    const reason = params.forceStatusReason ?? params.reason ?? '';
+    return reason.trim().length >= FORCE_REASON_MIN_LENGTH ? reason.trim() : null;
+}
+function canForce(params, status) {
+    const forceFlag = status === 'approved'
+        ? params.forceApprove === true
+        : status === 'done'
+            ? params.forceStatus === true || params.force === true
+            : params.force === true;
+    return forceFlag && forceReason(params) !== null;
+}
+function buildBlock(status, blockers, fixHint) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    error: 'SDD_MODEL_ROUTING_GATE_FAILED',
+                    status,
+                    blockers,
+                    fixHint,
+                }, null, 2),
+            },
+        ],
+        isError: true,
+        structuredContent: {
+            error: 'SDD_MODEL_ROUTING_GATE_FAILED',
+            status,
+            blockers,
+            fixHint,
+        },
+    };
+}
+export async function hashContextPackage(input) {
+    const parts = [];
+    const sessionContextPath = join(input.projectPath, 'planu', 'session-context.md');
+    parts.push(await readFile(sessionContextPath, 'utf-8'));
+    if (input.handoffPath) {
+        parts.push(await readFile(input.handoffPath, 'utf-8'));
+    }
+    return createHash('sha256').update(parts.join('\n---HANDOFF---\n'), 'utf8').digest('hex');
+}
+async function contextCanBeReconstructed(params) {
+    const blockers = [];
+    if (!params.projectPath) {
+        blockers.push('projectPath is required to reconstruct planu/session-context.md.');
+        return blockers;
+    }
+    const sessionContextPath = join(params.projectPath, 'planu', 'session-context.md');
+    try {
+        const raw = await readFile(sessionContextPath, 'utf-8');
+        if (raw.trim().length < 80) {
+            blockers.push('planu/session-context.md exists but is too small to reconstruct context.');
+        }
+    }
+    catch {
+        blockers.push('planu/session-context.md is missing or unreadable.');
+    }
+    if (params.handoffPath) {
+        try {
+            const raw = await readFile(params.handoffPath, 'utf-8');
+            if (raw.trim().length < 200) {
+                blockers.push('handoffPath exists but is too small to be an operational package.');
+            }
+        }
+        catch {
+            blockers.push('handoffPath is missing or unreadable.');
+        }
+    }
+    else if (!params.handoffArtifactId) {
+        blockers.push('handoffPath or handoffArtifactId is required.');
+    }
+    return blockers;
+}
+export async function checkSddModelRoutingGate(input) {
+    const { params, status, projectPath } = input;
+    const phase = phaseForTransition(status);
+    const gateResults = {};
+    const forcedReasons = [];
+    if (phase === null) {
+        return { blockResult: null, gateResults: { sddModelRouting: 'skip' }, forcedReasons };
+    }
+    const requiredTier = requiredTierForPhase(phase);
+    const blockers = [];
+    if (!hasTierEvidence(params, requiredTier)) {
+        blockers.push(`Transition to ${status} requires model tier "${requiredTier}" evidence. Received modelTierUsed="${params.modelTierUsed ?? 'missing'}", modelId="${params.modelId ?? 'missing'}".`);
+    }
+    if (status === 'implementing' || status === 'done') {
+        if (!params.contextHash) {
+            blockers.push('contextHash is required so the next agent can verify context continuity.');
+        }
+        blockers.push(...(await contextCanBeReconstructed({
+            projectPath,
+            handoffPath: params.handoffPath,
+            handoffArtifactId: params.handoffArtifactId,
+        })));
+    }
+    if (status === 'done') {
+        if (!params.reviewedBy || params.reviewedBy.trim().length === 0) {
+            blockers.push('reviewedBy is required before done.');
+        }
+        if (!params.arbitratedBy || params.arbitratedBy.trim().length === 0) {
+            blockers.push('arbitratedBy is required before done.');
+        }
+        if (params.reconcileRequired === true) {
+            blockers.push('reconcileRequired=true blocks done until reconcile_spec records the intentional drift.');
+        }
+    }
+    if (blockers.length === 0) {
+        gateResults.sddModelRouting = 'pass';
+        return { blockResult: null, gateResults, forcedReasons };
+    }
+    if (canForce(params, status)) {
+        gateResults.sddModelRouting = 'forced';
+        forcedReasons.push(forceReason(params) ?? 'Forced SDD model/context gate');
+        return { blockResult: null, gateResults, forcedReasons };
+    }
+    gateResults.sddModelRouting = 'fail';
+    return {
+        blockResult: buildBlock(status, blockers, 'Provide modelTierUsed/modelId evidence plus package_handoff context evidence, or force with a >=100 character audited reason.'),
+        gateResults,
+        forcedReasons,
+    };
+}
+export function buildTransitionEvidenceMeta(params) {
+    return {
+        ...(params.modelTierUsed !== undefined && { modelTierUsed: params.modelTierUsed }),
+        ...(params.modelId !== undefined && { modelId: params.modelId }),
+        ...(params.contextHash !== undefined && { contextHash: params.contextHash }),
+        ...(params.handoffPath !== undefined && { handoffPath: params.handoffPath }),
+        ...(params.handoffArtifactId !== undefined && { handoffArtifactId: params.handoffArtifactId }),
+        ...(params.reviewedBy !== undefined && { reviewedBy: params.reviewedBy }),
+        ...(params.arbitratedBy !== undefined && { arbitratedBy: params.arbitratedBy }),
+        ...(params.reconcileRequired !== undefined && { reconcileRequired: params.reconcileRequired }),
+    };
+}
+//# sourceMappingURL=sdd-model-routing.js.map

package/dist/engine/universal-rules/catalog.js

@@ -4,12 +4,22 @@ import { planuDogfoodBugsRule } from './rules/planu-dogfood-bugs.js';
 import { planuWorkflowRule } from './rules/planu-workflow.js';
 import { planuModesRule } from './rules/planu-modes.js';
 import { agentTeamsRule } from './rules/agent-teams.js';
+import { planuEnglishSpecsRule } from './rules/planu-english-specs.js';
+import { planuBddCriteriaRule } from './rules/planu-bdd-criteria.js';
+import { planuApprovalGatesRule } from './rules/planu-approval-gates.js';
+import { planuReleasePolicyRule } from './rules/planu-release-policy.js';
+import { planuSddModelRoutingRule } from './rules/planu-sdd-model-routing.js';
 /**
  * The full catalog of universal Planu rules.
  * Order matters: rules are installed in catalog order.
  */
 export const UNIVERSAL_RULES = [
     planuWorkflowRule,
+    planuEnglishSpecsRule,
+    planuBddCriteriaRule,
+    planuApprovalGatesRule,
+    planuSddModelRoutingRule,
+    planuReleasePolicyRule,
     planuModesRule,
     agentTeamsRule,
     planuDogfoodBugsRule,

package/dist/engine/universal-rules/installer.js

@@ -6,8 +6,14 @@ import { UNIVERSAL_RULES } from './catalog.js';
 import { writeRuleForHost } from './host-writer.js';
 import { hashContent, readManifest, upsertManifestEntry } from './user-edit-detector.js';
 /** Path of the manifest relative to projectPath. */
-function manifestPath(projectPath) {
-    return join(projectPath, '.claude', 'rules', '.planu-rules-manifest.json');
+function manifestPath(projectPath, host) {
+    if (host === 'claude-code') {
+        return join(projectPath, '.claude', 'rules', '.planu-rules-manifest.json');
+    }
+    if (host === 'gemini') {
+        return join(projectPath, '.gemini', '.planu-rules-manifest.json');
+    }
+    return join(projectPath, '.planu', 'rules-manifest.codex.json');
 }
 /**
  * Install all default-enabled universal rules applicable to `host`.
@@ -15,7 +21,7 @@ function manifestPath(projectPath) {
  * Returns the list of rules that were written.
  */
 export async function installUniversalRules(projectPath, host) {
-    const mPath = manifestPath(projectPath);
+    const mPath = manifestPath(projectPath, host);
     const manifest = (await readManifest(mPath)) ?? { rules: [] };
     const installed = [];
     for (const rule of UNIVERSAL_RULES) {

package/dist/engine/universal-rules/rules/planu-approval-gates.d.ts

@@ -0,0 +1,3 @@
+import type { UniversalRule } from '../../../types/universal-rules/index.js';
+export declare const planuApprovalGatesRule: UniversalRule;
+//# sourceMappingURL=planu-approval-gates.d.ts.map

package/dist/engine/universal-rules/rules/planu-approval-gates.js

@@ -0,0 +1,41 @@
+// engine/universal-rules/rules/planu-approval-gates.ts — Universal rule: approval and done gates
+function buildBody() {
+    return `# Planu Approval and Done Gates
+
+Auto-generated by \`init_project\`. Do not edit manually.
+
+## Approval Gate
+
+Before moving a spec to \`approved\`, run and pass:
+
+1. \`challenge_spec\`
+2. \`check_readiness\`
+3. BDD criteria completeness
+4. files-to-create / files-to-modify ownership
+5. test plan and verification commands
+
+If the user explicitly forces approval, record the reason in the audit trail and make the missing risk visible.
+
+## Done Gate
+
+Before moving a spec to \`done\`, run \`validate\`.
+
+If implementation intentionally diverged from the approved spec, run \`reconcile_spec\` first and make the divergence explicit before marking done.
+
+## Hard Blocks
+
+- Do not approve specs with placeholders.
+- Do not mark done without validation evidence.
+- Do not hide intentional drift; reconcile it.
+`;
+}
+export const planuApprovalGatesRule = {
+    id: 'planu-approval-gates',
+    name: 'Planu Approval Gates',
+    description: 'Requires challenge/readiness before approval and validate/reconcile before done.',
+    category: 'safety',
+    applicableHosts: ['all'],
+    defaultEnabled: true,
+    buildContent: (_host) => buildBody(),
+};
+//# sourceMappingURL=planu-approval-gates.js.map

package/dist/engine/universal-rules/rules/planu-bdd-criteria.d.ts

@@ -0,0 +1,3 @@
+import type { UniversalRule } from '../../../types/universal-rules/index.js';
+export declare const planuBddCriteriaRule: UniversalRule;
+//# sourceMappingURL=planu-bdd-criteria.d.ts.map

package/dist/engine/universal-rules/rules/planu-bdd-criteria.js

@@ -0,0 +1,45 @@
+// engine/universal-rules/rules/planu-bdd-criteria.ts — Universal rule: BDD acceptance criteria
+function buildBody() {
+    return `# Planu BDD Acceptance Criteria
+
+Auto-generated by \`init_project\`. Do not edit manually.
+
+## Rule
+
+Every acceptance criterion must be executable enough for an implementation agent and a validation gate.
+
+Required format:
+
+\`\`\`gherkin
+GIVEN <initial state or context>
+WHEN <action or event>
+THEN <observable result>
+AND <additional observable constraint>
+\`\`\`
+
+## Required Detail
+
+Each criterion must identify:
+
+- files or modules that are expected to change when known
+- user-visible behavior or API behavior
+- test expectation or verification command
+- ownership when the work spans more than one wave or agent
+
+## Hard Blocks
+
+- No loose checklist-only acceptance criteria.
+- No vague outcomes such as "works correctly", "improves UX", or "handles errors" without observable behavior.
+- No approval when criteria are missing \`GIVEN\`, \`WHEN\`, or \`THEN\`.
+`;
+}
+export const planuBddCriteriaRule = {
+    id: 'planu-bdd-criteria',
+    name: 'Planu BDD Criteria',
+    description: 'Requires complete GIVEN/WHEN/THEN acceptance criteria.',
+    category: 'quality',
+    applicableHosts: ['all'],
+    defaultEnabled: true,
+    buildContent: (_host) => buildBody(),
+};
+//# sourceMappingURL=planu-bdd-criteria.js.map

package/dist/engine/universal-rules/rules/planu-english-specs.d.ts

@@ -0,0 +1,3 @@
+import type { UniversalRule } from '../../../types/universal-rules/index.js';
+export declare const planuEnglishSpecsRule: UniversalRule;
+//# sourceMappingURL=planu-english-specs.d.ts.map