@planu/cli 4.7.2 → 4.7.4

package/dist/engine/spec-format/acceptance-criteria.js

@@ -0,0 +1,106 @@
+import { parseFrontmatterScenarios } from '../validator/spec-compliance-runner.js';
+import { stripFrontmatter } from '../frontmatter-parser.js';
+import { extractListItems, extractSection } from '../validator/extractors.js';
+function normalizeCriterionValue(value) {
+    return value
+        .replace(/^-\s*\[[ x]\]\s*/i, '')
+        .replace(/[`*_()[\]:]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function stripCriterionIdPrefix(value) {
+    return value.replace(/^(AC\d+)\s*[:.)-]?\s*/i, '').trim();
+}
+function detectCriterionId(value, index) {
+    const explicit = /^(AC\d+)\b/i.exec(value)?.[1];
+    return (explicit ?? `AC${String(index + 1)}`).toUpperCase();
+}
+function extractSectionCriteria(section) {
+    const listItems = extractListItems(section);
+    if (listItems.length > 0) {
+        return listItems;
+    }
+    const lines = section.split('\n').map((line) => line.trim());
+    if (lines.length === 0) {
+        return [];
+    }
+    const bddBlocks = [];
+    let current = [];
+    for (const line of lines) {
+        if (line.length === 0) {
+            if (current.length > 0) {
+                bddBlocks.push(current.join(' '));
+                current = [];
+            }
+            continue;
+        }
+        if (/^(GIVEN|WHEN|THEN|AND|DADO|CUANDO|ENTONCES|Y)\b/i.test(line)) {
+            if (/^(GIVEN|DADO)\b/i.test(line) && current.length > 0) {
+                bddBlocks.push(current.join(' '));
+                current = [];
+            }
+            current.push(line.replace(/^[-*+]\s*/, ''));
+            continue;
+        }
+        if (current.length > 0) {
+            current.push(line);
+        }
+    }
+    if (current.length > 0) {
+        bddBlocks.push(current.join(' '));
+    }
+    return bddBlocks;
+}
+function extractBodyCriteria(raw) {
+    const body = stripFrontmatter(raw);
+    const acceptanceCriteria = extractSection(body, 'acceptance criteria', 'criterios de aceptaci');
+    if (acceptanceCriteria) {
+        const sectionCriteria = extractSectionCriteria(acceptanceCriteria);
+        if (sectionCriteria.length > 0) {
+            return sectionCriteria;
+        }
+    }
+    return body
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => /^-\s*\[[ x]\]/i.test(line) || /^- .*\bgiven\b.*\bwhen\b.*\bthen\b/i.test(line))
+        .map((line) => line.replace(/^-\s*\[[ x]\]\s*/i, '').trim());
+}
+function buildCriterion(text, source, index) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    const id = detectCriterionId(trimmed, index);
+    const withoutId = stripCriterionIdPrefix(trimmed);
+    const aliases = new Set([
+        normalizeCriterionValue(trimmed),
+        normalizeCriterionValue(withoutId),
+        normalizeCriterionValue(id),
+    ]);
+    return {
+        id,
+        text: withoutId,
+        source,
+        aliases: [...aliases].filter((alias) => alias.length > 0),
+    };
+}
+export function extractNormalizedAcceptanceCriteria(raw) {
+    const bodyCriteria = extractBodyCriteria(raw)
+        .map((criterion, index) => buildCriterion(criterion, 'body', index))
+        .filter((criterion) => criterion !== null);
+    if (bodyCriteria.length > 0) {
+        return bodyCriteria;
+    }
+    return parseFrontmatterScenarios(raw)
+        .map((scenario, index) => buildCriterion(scenario.title, 'frontmatter', index))
+        .filter((criterion) => criterion !== null);
+}
+export function extractAcceptanceCriteriaTexts(raw) {
+    return extractNormalizedAcceptanceCriteria(raw).map((criterion) => criterion.text);
+}
+export function normalizeAcceptanceCriterionToken(value) {
+    return normalizeCriterionValue(stripCriterionIdPrefix(value));
+}
+//# sourceMappingURL=acceptance-criteria.js.map

package/dist/engine/spec-migrator/strict-planu-cleanup.js

@@ -133,6 +133,13 @@ async function walkSpecDirectory(projectPath, specDir, result) {
         }
     }
 }
+async function shouldDeleteOrphanSpecDir(specDir) {
+    const entries = await readdir(specDir).catch(() => []);
+    if (entries.includes('spec.md')) {
+        return false;
+    }
+    return !entries.some((entry) => mustMergeBeforeDeleteSpecFile(entry));
+}
 export async function runStrictPlanuCleanup(projectPath) {
     const result = { deleted: [], merged: [], gitignoreUpdated: false };
     const planuDir = join(projectPath, 'planu');
@@ -170,6 +177,11 @@ export async function runStrictPlanuCleanup(projectPath) {
             result.deleted.push(relative(projectPath, full));
             continue;
         }
+        if (await shouldDeleteOrphanSpecDir(full)) {
+            await removePath(projectPath, full);
+            result.deleted.push(relative(projectPath, full));
+            continue;
+        }
         await walkSpecDirectory(projectPath, full, result);
     }
     result.gitignoreUpdated = await updateGitignore(projectPath);
@@ -210,6 +222,10 @@ export async function validateStrictPlanuLayout(projectPath, options = {}) {
             offenders.push(relative(projectPath, full));
             continue;
         }
+        if (await shouldDeleteOrphanSpecDir(full)) {
+            offenders.push(relative(projectPath, full));
+            continue;
+        }
         for (const entry of await readdir(full).catch(() => [])) {
             const entryPath = join(full, entry);
             const isDir = await pathIsDirectory(entryPath);

package/dist/engine/token-optimizer/content-aware-compactor.d.ts

@@ -0,0 +1,4 @@
+import type { ContentAwareCompactionInput, ContentAwareCompactionResult, ContextArtifactContentType } from '../../types/context-artifacts.js';
+export declare function classifyContentType(kind: string | undefined, text: string): ContextArtifactContentType;
+export declare function compactContentAware(input: ContentAwareCompactionInput): ContentAwareCompactionResult;
+//# sourceMappingURL=content-aware-compactor.d.ts.map

package/dist/engine/token-optimizer/content-aware-compactor.js

@@ -0,0 +1,230 @@
+import { countTokens } from './counter.js';
+import { storeContextArtifact } from '../context-artifacts/store.js';
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_MIN_TOKENS = 200;
+function redact(text, patterns) {
+    return patterns.reduce((current, pattern) => {
+        const re = new RegExp(pattern, 'gi');
+        return current.replace(re, '[redacted]');
+    }, text);
+}
+function escapeInert(text) {
+    return text.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function bounded(value, maxChars) {
+    return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...`;
+}
+function isLikelyJson(text) {
+    const trimmed = text.trim();
+    return ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+        (trimmed.startsWith('[') && trimmed.endsWith(']')));
+}
+function isSearchResult(text) {
+    return text
+        .split('\n')
+        .some((line) => /^[^:\n]+:\d+(?::\d+)?:/.test(line) || /^[^:\n]+\(\d+,\d+\):/.test(line));
+}
+function isCode(text) {
+    const lines = text.split('\n');
+    const codeLines = lines.filter((line) => /^\s*(import|export|function|class|interface|type |const |let |var |def |fn |pub |func |struct |enum )/.test(line));
+    return lines.length > 0 && codeLines.length / lines.length > 0.12;
+}
+function isSpecOrHandoff(text) {
+    return (/\bSPEC-\d+\b/.test(text) ||
+        /\b(acceptance criteria|handoff|validation score|next action)\b/i.test(text));
+}
+export function classifyContentType(kind, text) {
+    const normalized = kind?.toLowerCase() ?? '';
+    if (normalized.includes('json') || isLikelyJson(text)) {
+        return 'json';
+    }
+    if (normalized.includes('test') ||
+        /\b(vitest|jest|failed tests?|test files?|assertionerror)\b/i.test(text)) {
+        return 'test-log';
+    }
+    if (normalized.includes('log') ||
+        /\b(error|warn|exception|stack trace|exit code)\b/i.test(text)) {
+        return 'runtime-log';
+    }
+    if (normalized.includes('search') || isSearchResult(text)) {
+        return 'search-results';
+    }
+    if (normalized.includes('code') || isCode(text)) {
+        return 'code';
+    }
+    if (normalized.includes('spec') || normalized.includes('handoff') || isSpecOrHandoff(text)) {
+        return 'spec-or-handoff';
+    }
+    return 'generic-text';
+}
+function summarizeJsonValue(value, depth = 0) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value.length <= 80 ? value : `${value.slice(0, 80)}...`;
+    }
+    if (Array.isArray(value)) {
+        return {
+            length: value.length,
+            sample: value.slice(0, 3).map((item) => summarizeJsonValue(item, depth + 1)),
+        };
+    }
+    if (typeof value === 'object') {
+        const out = {};
+        for (const [key, child] of Object.entries(value).slice(0, depth > 1 ? 12 : 40)) {
+            if (/^(status|state|count|total|id|uuid|name|ok|success|error|errors|warning|warnings)$/i.test(key)) {
+                out[key] = summarizeJsonValue(child, depth + 1);
+            }
+            else if (depth < 2) {
+                out[key] = summarizeJsonValue(child, depth + 1);
+            }
+        }
+        return out;
+    }
+    if (typeof value === 'undefined') {
+        return 'undefined';
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (typeof value === 'symbol') {
+        return value.description ?? 'symbol';
+    }
+    return '[unsupported]';
+}
+function compactJson(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return JSON.stringify(summarizeJsonValue(parsed), null, 2);
+    }
+    catch {
+        return compactGenericText(text);
+    }
+}
+function compactLog(text, maxLines) {
+    const lines = text.split('\n');
+    const important = lines.filter((line) => /\b(error|fail|failed|failure|exception|stack|trace|warning|warn|duration|total|passed|exit code|exit status)\b/i.test(line));
+    const selected = important.length > 0 ? important : lines;
+    return [...new Set(selected)].slice(0, maxLines).join('\n');
+}
+function compactSearchResults(text, maxLines, maxSnippetChars) {
+    const grouped = new Map();
+    for (const line of text.split('\n')) {
+        const match = /^([^:\n]+):(\d+)(?::\d+)?:\s?(.*)$/.exec(line);
+        if (!match) {
+            continue;
+        }
+        const [, path, lineNumber, snippet] = match;
+        if (path === undefined || lineNumber === undefined) {
+            continue;
+        }
+        const entries = grouped.get(path) ?? [];
+        entries.push(`  ${lineNumber}: ${bounded(snippet ?? '', maxSnippetChars)}`);
+        grouped.set(path, [...new Set(entries)]);
+    }
+    if (grouped.size === 0) {
+        return compactGenericText(text);
+    }
+    const out = [];
+    for (const [path, entries] of grouped.entries()) {
+        out.push(path, ...entries.slice(0, maxLines));
+    }
+    return out.slice(0, maxLines).join('\n');
+}
+function bracesBalanced(text) {
+    let balance = 0;
+    for (const char of text) {
+        if (char === '{') {
+            balance += 1;
+        }
+        else if (char === '}') {
+            balance -= 1;
+        }
+        if (balance < 0) {
+            return false;
+        }
+    }
+    return balance === 0;
+}
+function compactCode(text) {
+    if (!bracesBalanced(text)) {
+        return compactGenericText(text);
+    }
+    const preserved = text
+        .split('\n')
+        .filter((line) => /^\s*(import|export|interface|type |class |function |async function|const [A-Z0-9_]+|enum |struct |def |fn |pub )/.test(line));
+    return preserved.length > 0 ? preserved.join('\n') : compactGenericText(text);
+}
+function compactSpecOrHandoff(text) {
+    const lines = text.split('\n');
+    const important = lines.filter((line) => /\b(SPEC-\d+|title:|status|acceptance criteria|blocker|blocked|files?|validation score|risk|security|privacy|next action|implementation|handoff)\b/i.test(line) ||
+        /^-\s*\[[ xX]\]\s+/.test(line) ||
+        /^#{1,3}\s/.test(line));
+    return (important.length > 0 ? important : lines).slice(0, 80).join('\n');
+}
+function compactGenericText(text) {
+    const lines = text.split('\n').filter((line) => line.trim().length > 0);
+    const important = lines.filter((line) => /^#{1,3}\s/.test(line) ||
+        /\b(error|failed|blocked|warning|todo|next action|pnpm|npm|git|https?:\/\/|\w+\/[\w./-]+\.\w+)\b/i.test(line));
+    return (important.length > 0 ? important : lines).slice(0, 60).join('\n');
+}
+function compactByType(type, text, maxLines, maxSnippetChars) {
+    switch (type) {
+        case 'json':
+            return compactJson(text);
+        case 'test-log':
+        case 'runtime-log':
+            return compactLog(text, maxLines);
+        case 'search-results':
+            return compactSearchResults(text, maxLines, maxSnippetChars);
+        case 'code':
+            return compactCode(text);
+        case 'spec-or-handoff':
+            return compactSpecOrHandoff(text);
+        case 'generic-text':
+            return compactGenericText(text);
+    }
+}
+export function compactContentAware(input) {
+    const contentType = classifyContentType(input.kind, input.text);
+    const strategyConfig = input.policy.contentCompaction?.strategies?.[contentType];
+    const maxLines = strategyConfig?.maxLines ?? 60;
+    const maxSnippetChars = strategyConfig?.maxSnippetChars ?? input.policy.redaction.maxSnippetChars;
+    const redacted = redact(input.text, input.policy.redaction.redactPatterns);
+    const compact = escapeInert(compactByType(contentType, redacted, maxLines, maxSnippetChars));
+    const originalTokens = countTokens(input.text).tokens;
+    const compactTokens = countTokens(compact).tokens;
+    const result = {
+        text: compact,
+        originalTokens,
+        compactTokens,
+        tokensSaved: Math.max(0, originalTokens - compactTokens),
+        strategy: contentType,
+        contentType,
+    };
+    const artifactsEnabled = input.policy.contextArtifacts?.enabled !== false;
+    const minTokens = input.policy.contextArtifacts?.minTokens ?? DEFAULT_MIN_TOKENS;
+    if (!artifactsEnabled || input.projectPath === undefined || originalTokens < minTokens) {
+        return result;
+    }
+    const stored = storeContextArtifact({
+        projectPath: input.projectPath,
+        originalContent: input.text,
+        compactContent: compact,
+        contentType,
+        strategy: contentType,
+        originalTokens,
+        compactTokens,
+        ttlMs: input.policy.contextArtifacts?.ttlMs ?? DEFAULT_TTL_MS,
+        sourcePath: input.sourcePath,
+        flow: input.flow,
+        metadata: input.metadata,
+    });
+    return {
+        ...result,
+        ...(stored.metadata !== undefined ? { artifact: stored.metadata } : {}),
+        ...(stored.refusedReason !== undefined ? { refusedReason: stored.refusedReason } : {}),
+    };
+}
+//# sourceMappingURL=content-aware-compactor.js.map

package/dist/engine/token-optimizer/index.d.ts

@@ -9,6 +9,7 @@ export { OptimizationReporter } from './reporter.js';
 export { TokenOptimizer } from './optimizer.js';
 export { aggregateEntries, computeDailyBreakdown, detectTrend, detectAnomalies, computeBudgetStatus, getTopConsumers, computeOptimizationSavings, } from './analytics.js';
 export { loadTokenWastePolicy } from './policy-loader.js';
+export { classifyContentType, compactContentAware } from './content-aware-compactor.js';
 export { analyzeContextPreflight } from './context-preflight.js';
 export { filterVerboseOutput } from './output-filter.js';
 export { recommendRelevantTools, toolsFromPolicyGroups } from './tool-relevance.js';

package/dist/engine/token-optimizer/index.js

@@ -10,6 +10,7 @@ export { OptimizationReporter } from './reporter.js';
 export { TokenOptimizer } from './optimizer.js';
 export { aggregateEntries, computeDailyBreakdown, detectTrend, detectAnomalies, computeBudgetStatus, getTopConsumers, computeOptimizationSavings, } from './analytics.js';
 export { loadTokenWastePolicy } from './policy-loader.js';
+export { classifyContentType, compactContentAware } from './content-aware-compactor.js';
 export { analyzeContextPreflight } from './context-preflight.js';
 export { filterVerboseOutput } from './output-filter.js';
 export { recommendRelevantTools, toolsFromPolicyGroups } from './tool-relevance.js';

package/dist/engine/token-optimizer/output-filter.js

@@ -1,3 +1,4 @@
+import { compactContentAware } from './content-aware-compactor.js';
 function escapeInert(text) {
     return text.replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -46,7 +47,21 @@ export function filterVerboseOutput(input) {
     const strategy = selectStrategy(input);
     const originalLines = input.text.split('\n').length;
     const lines = compactLines(input, strategy);
-    const compact = redact(escapeInert(lines.join('\n')), input.policy.redaction.redactPatterns);
+    let compact = redact(escapeInert(lines.join('\n')), input.policy.redaction.redactPatterns);
+    let compaction;
+    if (input.policy.contextArtifacts?.enabled === true && input.projectPath !== undefined) {
+        const contentAware = compactContentAware({
+            text: input.text,
+            policy: input.policy,
+            kind: input.kind,
+            projectPath: input.projectPath,
+            sourcePath: input.sourcePath,
+            flow: input.flow,
+            metadata: input.metadata,
+        });
+        compact = contentAware.text;
+        compaction = contentAware.artifact;
+    }
     const decisions = [
         {
             decision: originalLines > lines.length ? 'summarize' : 'include',
@@ -59,8 +74,9 @@ export function filterVerboseOutput(input) {
     return {
         text: compact,
         originalLines,
-        returnedLines: lines.length,
+        returnedLines: compact.split('\n').length,
         ...(input.fullOutputRef !== undefined ? { fullOutputRef: input.fullOutputRef } : {}),
+        ...(compaction !== undefined ? { compaction } : {}),
         decisions,
     };
 }

package/dist/engine/token-optimizer/policy-loader.js

@@ -39,6 +39,18 @@ function validatePolicy(value) {
     if (!isRecord(policy.outputs.strategies)) {
         throw new Error('Invalid token waste policy at outputs.strategies: expected object');
     }
+    if (policy.contextArtifacts !== undefined) {
+        if (!Number.isFinite(policy.contextArtifacts.ttlMs) || policy.contextArtifacts.ttlMs < 1) {
+            throw new Error('Invalid token waste policy at contextArtifacts.ttlMs: expected positive number');
+        }
+        if (!Number.isFinite(policy.contextArtifacts.minTokens) ||
+            policy.contextArtifacts.minTokens < 1) {
+            throw new Error('Invalid token waste policy at contextArtifacts.minTokens: expected positive number');
+        }
+    }
+    if (policy.contentCompaction !== undefined && !isRecord(policy.contentCompaction.strategies)) {
+        throw new Error('Invalid token waste policy at contentCompaction.strategies: expected object');
+    }
     if (!isRecord(policy.tools.groups)) {
         throw new Error('Invalid token waste policy at tools.groups: expected object');
     }

package/dist/engine/token-optimizer/reporter.d.ts

@@ -18,6 +18,10 @@ export declare class OptimizationReporter {
      * Record a cache hit for a tool.
      */
     recordCacheHit(toolName: string, tokensSaved: number): void;
+    /**
+     * Record measured savings from reversible compaction.
+     */
+    recordCompaction(toolName: string, tokensSaved: number, retrievals?: number): void;
     /**
      * Record a cache miss for a tool.
      */

package/dist/engine/token-optimizer/reporter.js

@@ -28,6 +28,16 @@ export class OptimizationReporter {
         record.tokensSaved += tokensSaved;
         this.totalSaved += tokensSaved;
     }
+    /**
+     * Record measured savings from reversible compaction.
+     */
+    recordCompaction(toolName, tokensSaved, retrievals = 0) {
+        const record = this.getOrCreateRecord(toolName);
+        record.compactionTokensSaved = (record.compactionTokensSaved ?? 0) + tokensSaved;
+        record.artifactRetrievals = (record.artifactRetrievals ?? 0) + retrievals;
+        record.tokensSaved += tokensSaved;
+        this.totalSaved += tokensSaved;
+    }
     /**
      * Record a cache miss for a tool.
      */
@@ -106,7 +116,8 @@ export class OptimizationReporter {
             for (const record of toolRecords) {
                 lines.push(`- ${record.toolName}: ${String(record.totalTokens)} tokens, ` +
                     `${String(record.callCount)} calls, ` +
-                    `${String(record.tokensSaved)} saved`);
+                    `${String(record.tokensSaved)} saved ` +
+                    `(compaction ${String(record.compactionTokensSaved ?? 0)}, retrievals ${String(record.artifactRetrievals ?? 0)})`);
             }
         }
         return lines.join('\n');
@@ -134,6 +145,8 @@ export class OptimizationReporter {
                 cacheHits: 0,
                 cacheMisses: 0,
                 tokensSaved: 0,
+                compactionTokensSaved: 0,
+                artifactRetrievals: 0,
             };
             this.toolRecords.set(toolName, record);
         }

package/dist/engine/universal-rules/rules/planu-release-policy.js

@@ -6,23 +6,26 @@ Auto-generated by \`init_project\`. Do not edit manually.
 
 ## Rule
 
-When implementation changes are complete and validated, always address release explicitly:
+When implementation changes are complete and validated, always address release explicitly with a local-first flow:
 
-- create the release when the user has already requested shipping or publishing
-- otherwise ask before publishing, tagging, or pushing externally visible release artifacts
+- canonical local gates: \`pnpm validate\` then \`pnpm check:strict\`
+- canonical local release command: \`pnpm release:local\`
+- publish externally only when the user has explicitly requested shipping/publishing
+- use \`main\` as the default release branch; treat \`develop\` as optional gitflow compatibility only when the repository actively uses it
 
 ## Required Release Checklist
 
-- tests and validation commands passed
+- local validation commands passed
 - changelog or release notes updated when applicable
 - package version and git tag stay aligned
-- main/develop branch state is reconciled when the repository uses both
+- release metadata under \`planu/releases/pending.json\` contains only genuinely pending entries
 - published package smoke check is run after release when applicable
 
 ## Hard Blocks
 
 - Do not silently skip release discussion after completed product/runtime changes.
 - Do not publish without validation evidence.
+- Do not let hosted CI, branch protection, or release bots redefine the canonical local release contract.
 - Do not leave release notes promising capabilities that are not in the public runtime.
 `;
 }

package/dist/engine/web-fetcher/docs-fetcher.js

@@ -1,6 +1,7 @@
 // Planu — Web Fetcher: consultDocs orchestration
 import { searchAndRegisterFramework, saveRegistry } from '../registry-updater.js';
 import { loadDocsRegistry, findDocsEntry, setDocsRegistryCache, getStoredRegistryPath, } from './registry-loader.js';
+import { DEFAULT_CONFIG } from './cache.js';
 import { fetchUrl } from './http-client.js';
 import { extractTextContent, extractCodeBlocks, extractBestPractices, buildSummaryFromContent, buildPlaceholderSummary, buildPlaceholderExamples, buildPlaceholderBestPractices, } from './content-extractor.js';
 export async function consultDocsImpl(topic, framework) {
@@ -25,7 +26,10 @@ export async function consultDocsImpl(topic, framework) {
         : `https://www.google.com/search?q=${encodeURIComponent(`${resolvedFramework} ${topic} documentation`)}`;
     const baseUrl = docsEntry?.base ?? '';
     if (baseUrl) {
-        const fetchResult = await fetchUrl(docsUrl);
+        const fetchResult = await fetchUrl(docsUrl, {
+            ...DEFAULT_CONFIG,
+            timeoutMs: 2_500,
+        });
         if (fetchResult) {
             const textContent = extractTextContent(fetchResult.content);
             const codeBlocks = extractCodeBlocks(fetchResult.content);

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

@@ -47,7 +47,7 @@ export declare const LIGHTWEIGHT_COMMANDS: readonly [{
 }, {
     readonly id: "planu.release.check";
     readonly title: "Check release readiness";
-    readonly description: "Check local branch cleanliness and main/develop/release sync readiness.";
+    readonly description: "Check local-first release readiness, branch cleanliness, and optional gitflow drift.";
     readonly invocation: "planu release check";
     readonly hosts: readonly ["codex", "claude-code"];
     readonly requiresMcp: false;

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

@@ -54,7 +54,7 @@ export const LIGHTWEIGHT_COMMANDS = [
     {
         id: 'planu.release.check',
         title: 'Check release readiness',
-        description: 'Check local branch cleanliness and main/develop/release sync readiness.',
+        description: 'Check local-first release readiness, branch cleanliness, and optional gitflow drift.',
         invocation: 'planu release check',
         hosts: ['codex', 'claude-code'],
         requiresMcp: false,

package/dist/resources/process.js

@@ -93,8 +93,9 @@ function getSddProcess() {
                 id: 'documenting',
                 name: '8. Document & Ship',
                 tools: ['generate_docs', 'generate_docs_site', 'integrate_pm', 'learn_pattern'],
-                description: 'Generate documentation. Sync with project management tools. ' +
-                    'Learn patterns for future estimations.',
+                description: 'Generate documentation, run the local-first release contract ' +
+                    '(`pnpm validate`, `pnpm check:strict`, `pnpm release:local` when shipping), ' +
+                    'sync with project management tools, and learn patterns for future estimations.',
             },
         ],
         specLifecycle: ['draft', 'review', 'approved', 'implementing', 'done'],

package/dist/tools/challenge-spec/event-challenge-scenarios.js

@@ -6,12 +6,8 @@ import { detectBrokers, getBrokerConfig, requiresIdempotence, } from '../../engi
  * Returns true when the spec or project has event-driven characteristics.
  */
 export function isEventDrivenSpec(spec, specContent, knowledge) {
-    const brokers = detectBrokers(knowledge.stack);
-    if (brokers.length > 0 && brokers[0] !== 'unknown') {
-        return true;
-    }
     const lower = `${spec.title} ${spec.tags.join(' ')} ${specContent}`.toLowerCase();
-    return (lower.includes('event') ||
+    const specSignals = lower.includes('event') ||
         lower.includes('kafka') ||
         lower.includes('rabbitmq') ||
         lower.includes('pubsub') ||
@@ -21,7 +17,15 @@ export function isEventDrivenSpec(spec, specContent, knowledge) {
         lower.includes('sns') ||
         lower.includes('message') ||
         lower.includes('consumer') ||
-        lower.includes('producer'));
+        lower.includes('producer');
+    if (spec.target === 'frontend' && !specSignals) {
+        return false;
+    }
+    const brokers = detectBrokers(knowledge.stack);
+    if (specSignals) {
+        return true;
+    }
+    return brokers.length > 0 && brokers[0] !== 'unknown' && spec.target !== 'frontend';
 }
 /**
  * Generate event-driven failure scenarios for challenge_spec.

package/dist/tools/git/hook-ops.js

@@ -265,7 +265,7 @@ export async function handleSetupHooks(projectId, config) {
     /* v8 ignore start */
     const protectedBranches = mergedConfig.protectedBranches ?? DEFAULT_PROTECTED_BRANCHES;
     const stalenessThreshold = mergedConfig.stalenessThreshold ?? 50;
-    const baseBranch = mergedConfig.baseBranch ?? 'develop';
+    const baseBranch = mergedConfig.baseBranch ?? 'main';
     /* v8 ignore end */
     const preCommitScript = buildPreCommitScript(
     /* v8 ignore next */ mergedConfig.requireSpecInCommit ?? true, stalenessThreshold, baseBranch);

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

@@ -63,6 +63,7 @@ Planu enforces Spec Driven Development — spec first, then implement, then vali
 
 - NEVER write production code before spec is \`approved\`
 - NEVER skip \`validate\` after implementation
+- Specs stay \`spec.md\`-only. Do not recreate standalone \`technical.md\` or \`progress.md\`.
 `;
 const CODEX_NATIVE_SKILL_CONTENT = `# planu-native — Planu Lightweight Native Surface
 
@@ -79,7 +80,7 @@ Use Planu's lightweight CLI surface for common SDD checks without loading the fu
 - \`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
+- \`planu release check\` — local-first release readiness check
 
 ## Escalate to Full MCP