@planu/cli 3.9.14 → 4.1.0

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

@@ -0,0 +1,199 @@
+// engine/spec-migrator/strict-planu-cleanup.ts — SPEC-1017
+// Destructive cleanup for non-canonical files under planu/.
+import { readdir, readFile, rm, stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { join, relative } from 'node:path';
+import { atomicWriteFile } from '../safety/atomic-write-file.js';
+import { safeUnlink } from './git-aware-fs.js';
+import { PLANU_CANONICAL_POLICY, canonicalContractText, isCanonicalPlanuRootDir, isCanonicalPlanuRootFile, isCanonicalReleaseFile, isCanonicalSpecFile, mustMergeBeforeDeleteSpecFile, } from './planu-canonical-policy.js';
+const execFileAsync = promisify(execFile);
+async function pathIsDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function gitRmCached(projectPath, relPath) {
+    if (!existsSync(join(projectPath, '.git'))) {
+        return;
+    }
+    try {
+        await execFileAsync('git', ['rm', '--cached', '--quiet', '--ignore-unmatch', relPath], {
+            cwd: projectPath,
+            timeout: 5_000,
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+function stripFrontmatter(content) {
+    return content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+}
+function appendSectionIfMissing(specContent, heading, body) {
+    if (body.trim().length === 0 || new RegExp(`\\n## ${heading}(\\n|$)`).test(specContent)) {
+        return specContent;
+    }
+    return `${specContent.trimEnd()}\n\n## ${heading}\n\n${body.trim()}\n`;
+}
+async function mergeLegacySpecFile(projectPath, specDir, fileName) {
+    const specPath = join(specDir, 'spec.md');
+    const legacyPath = join(specDir, fileName);
+    if (!existsSync(legacyPath) || !existsSync(specPath)) {
+        return false;
+    }
+    const [specContent, legacyContent] = await Promise.all([
+        readFile(specPath, 'utf-8'),
+        readFile(legacyPath, 'utf-8'),
+    ]);
+    const body = stripFrontmatter(legacyContent);
+    const section = fileName === 'progress.md' ? 'Progress' : fileName === 'technical.md' ? 'Technical' : 'Files';
+    const merged = appendSectionIfMissing(specContent, section, body);
+    if (merged !== specContent) {
+        await atomicWriteFile(specPath, merged, {
+            forceEdit: {
+                reason: `SPEC-1017 strict cleanup is merging legacy ${fileName} into canonical spec.md.`,
+            },
+        });
+    }
+    await safeUnlink(projectPath, legacyPath);
+    return true;
+}
+async function removePath(projectPath, absolutePath) {
+    const rel = relative(projectPath, absolutePath);
+    if (await pathIsDirectory(absolutePath)) {
+        await gitRmCached(projectPath, rel);
+        await rm(absolutePath, { recursive: true, force: true });
+        return;
+    }
+    await safeUnlink(projectPath, absolutePath);
+    await rm(absolutePath, { force: true });
+}
+async function updateGitignore(projectPath) {
+    const gitignorePath = join(projectPath, '.gitignore');
+    let current = '';
+    try {
+        current = await readFile(gitignorePath, 'utf-8');
+    }
+    catch {
+        /* missing .gitignore is fine */
+    }
+    const required = [
+        'planu/*.html',
+        'planu/status.json',
+        'planu/CHANGELOG.md',
+        'planu/.housekeeping-history.jsonl',
+        'planu/audits/',
+        'planu/handoffs/',
+        'planu/data/',
+        'planu/state/',
+        'planu/.locks/',
+        'planu/specs/data/',
+        'planu/specs/**/.analysis.json',
+        'planu/specs/**/technical-report.html',
+        'planu/specs/**/reference/',
+        'planu/specs/**/*.bak.*',
+    ];
+    const missing = required.filter((entry) => !current.split('\n').includes(entry));
+    if (missing.length === 0) {
+        return false;
+    }
+    const separator = current === '' || current.endsWith('\n') ? '' : '\n';
+    await atomicWriteFile(gitignorePath, `${current}${separator}# Planu generated/runtime\n${missing.join('\n')}\n`);
+    return true;
+}
+async function walkSpecDirectory(projectPath, specDir, result) {
+    const entries = await readdir(specDir).catch(() => []);
+    for (const entry of entries) {
+        const full = join(specDir, entry);
+        if (mustMergeBeforeDeleteSpecFile(entry)) {
+            if (await mergeLegacySpecFile(projectPath, specDir, entry)) {
+                result.merged.push(relative(projectPath, full));
+            }
+            continue;
+        }
+        if (entry === 'reference' || !isCanonicalSpecFile(entry)) {
+            await removePath(projectPath, full);
+            result.deleted.push(relative(projectPath, full));
+        }
+    }
+}
+export async function runStrictPlanuCleanup(projectPath) {
+    const result = { deleted: [], merged: [], gitignoreUpdated: false };
+    const planuDir = join(projectPath, 'planu');
+    if (!existsSync(planuDir)) {
+        return result;
+    }
+    const entries = await readdir(planuDir).catch(() => []);
+    for (const entry of entries) {
+        const full = join(planuDir, entry);
+        const isDir = await pathIsDirectory(full);
+        if (isDir && !isCanonicalPlanuRootDir(entry)) {
+            await removePath(projectPath, full);
+            result.deleted.push(relative(projectPath, full));
+            continue;
+        }
+        if (!isDir && !isCanonicalPlanuRootFile(entry)) {
+            await removePath(projectPath, full);
+            result.deleted.push(relative(projectPath, full));
+        }
+    }
+    const releasesDir = join(planuDir, 'releases');
+    for (const entry of await readdir(releasesDir).catch(() => [])) {
+        const rel = `releases/${entry}`;
+        if (!isCanonicalReleaseFile(rel)) {
+            const full = join(releasesDir, entry);
+            await removePath(projectPath, full);
+            result.deleted.push(relative(projectPath, full));
+        }
+    }
+    const specsDir = join(planuDir, 'specs');
+    for (const entry of await readdir(specsDir).catch(() => [])) {
+        const full = join(specsDir, entry);
+        if (!(await pathIsDirectory(full)) || entry === 'data') {
+            await removePath(projectPath, full);
+            result.deleted.push(relative(projectPath, full));
+            continue;
+        }
+        await walkSpecDirectory(projectPath, full, result);
+    }
+    result.gitignoreUpdated = await updateGitignore(projectPath);
+    return result;
+}
+export async function validateStrictPlanuLayout(projectPath) {
+    const offenders = [];
+    const planuDir = join(projectPath, 'planu');
+    const entries = await readdir(planuDir).catch(() => []);
+    for (const entry of entries) {
+        const full = join(planuDir, entry);
+        const isDir = await pathIsDirectory(full);
+        if ((isDir && !isCanonicalPlanuRootDir(entry)) || (!isDir && !isCanonicalPlanuRootFile(entry))) {
+            offenders.push(relative(projectPath, full));
+        }
+    }
+    for (const entry of await readdir(join(planuDir, 'releases')).catch(() => [])) {
+        const rel = `releases/${entry}`;
+        if (!isCanonicalReleaseFile(rel)) {
+            offenders.push(`planu/${rel}`);
+        }
+    }
+    for (const specDir of await readdir(join(planuDir, 'specs')).catch(() => [])) {
+        const full = join(planuDir, 'specs', specDir);
+        if (!(await pathIsDirectory(full)) || specDir === 'data') {
+            offenders.push(relative(projectPath, full));
+            continue;
+        }
+        for (const entry of await readdir(full).catch(() => [])) {
+            if (!isCanonicalSpecFile(entry)) {
+                offenders.push(relative(projectPath, join(full, entry)));
+            }
+        }
+    }
+    return { ok: offenders.length === 0, offenders, contract: canonicalContractText() };
+}
+export { PLANU_CANONICAL_POLICY };
+//# sourceMappingURL=strict-planu-cleanup.js.map

package/dist/engine/spec-summary-html.d.ts

@@ -1,10 +1,10 @@
 import type { Spec } from '../types/index.js';
 /**
- * Generate planu/index.html with specs overview + regenerate per-spec reports.
- * Merges store specs with filesystem specs to ensure all specs appear.
- * Designed to be called from list_specs, update_status, create_spec.
- * Best-effort: never throws, never blocks the caller.
- * Skips writing the file when spec data has not changed (hash comparison).
+ * Legacy compatibility entrypoint.
+ *
+ * SPEC-1017 makes `planu/index.html` and generated per-spec reports forbidden
+ * project-tree artifacts. Keep this function for old call sites, but make it
+ * a best-effort read-only refresh so callers stop reintroducing legacy files.
  */
 export declare function regenerateSpecSummaryHtml(projectPath: string, specs: Spec[], _changedSpecIds?: string[]): Promise<void>;
 //# sourceMappingURL=spec-summary-html.d.ts.map

package/dist/engine/spec-summary-html.js

@@ -1,9 +1,6 @@
-import { writeFile, mkdir, readFile, readdir } from 'node:fs/promises';
+import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parseFrontmatter } from './frontmatter-parser.js';
-import { generateDashboardHtml } from './spec-summary-html/dashboard-renderer.js';
-import { computeSpecDataHash, extractEmbeddedHash, HASH_MARKER, } from './spec-summary-html/hash-utils.js';
-import { detectAvailablePages } from './doc-generator/portal/portal-page-detector.js';
 /**
  * Scan planu/specs/ filesystem for spec.md files and build minimal Spec objects
  * from frontmatter. This catches specs not tracked in the JSON store.
@@ -87,38 +84,16 @@ function mergeSpecs(storeSpecs, fsSpecs) {
     return merged;
 }
 /**
- * Generate planu/index.html with specs overview + regenerate per-spec reports.
- * Merges store specs with filesystem specs to ensure all specs appear.
- * Designed to be called from list_specs, update_status, create_spec.
- * Best-effort: never throws, never blocks the caller.
- * Skips writing the file when spec data has not changed (hash comparison).
+ * Legacy compatibility entrypoint.
+ *
+ * SPEC-1017 makes `planu/index.html` and generated per-spec reports forbidden
+ * project-tree artifacts. Keep this function for old call sites, but make it
+ * a best-effort read-only refresh so callers stop reintroducing legacy files.
  */
 export async function regenerateSpecSummaryHtml(projectPath, specs, _changedSpecIds) {
-    const portalPath = join(projectPath, 'planu');
-    const outputPath = join(portalPath, 'index.html');
     try {
         const fsSpecs = await scanFilesystemSpecs(projectPath);
-        const allSpecs = mergeSpecs(specs, fsSpecs);
-        await mkdir(portalPath, { recursive: true });
-        // Detect available portal pages before generating to populate navbar + quick links
-        const availablePages = await detectAvailablePages(portalPath);
-        // Skip writing if spec data has not changed (avoids git noise on every tool call)
-        const newHash = computeSpecDataHash(allSpecs, availablePages);
-        try {
-            const existing = await readFile(outputPath, 'utf-8');
-            if (extractEmbeddedHash(existing) === newHash) {
-                return; // data unchanged — skip write
-            }
-        }
-        catch {
-            // file does not exist yet — proceed to write
-        }
-        const html = generateDashboardHtml(allSpecs, availablePages);
-        const htmlWithHash = html.replace('<!DOCTYPE html>', `<!DOCTYPE html>\n<!-- ${HASH_MARKER} ${newHash} -->`);
-        await writeFile(outputPath, htmlWithHash, 'utf-8');
-        // SPEC-466: Per-spec reports are legacy and no longer regenerated.
-        // Only the global index.html is generated. Remove this block entirely once
-        // all clients have migrated (regeneratePerSpecReports stays as dead code for now).
+        void mergeSpecs(specs, fsSpecs);
     }
     catch {
         /* best-effort — never fail the caller */

package/dist/engine/universal-rules/host-writer.js

@@ -2,6 +2,7 @@
 // Write a UniversalRule to disk using the appropriate host strategy.
 import { readFile, mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { assertEnglishOnlyArtifactText } from '../spec-language/english-only.js';
 // ---------------------------------------------------------------------------
 // Claude Code writer
 // ---------------------------------------------------------------------------
@@ -14,6 +15,7 @@ async function writeForClaudeCode(rule, projectPath) {
     await mkdir(rulesDir, { recursive: true });
     const filePath = join(rulesDir, `${rule.id}.md`);
     const content = rule.buildContent('claude-code');
+    assertEnglishOnlyArtifactText(`${rule.name}\n\n${rule.description}\n\n${content}`, 'rule');
     await writeFile(filePath, content, 'utf-8');
     return filePath;
 }
@@ -39,7 +41,9 @@ async function writeForCodex(rule, projectPath) {
     }
     const open = OPEN_MARKER(rule.id);
     const close = CLOSE_MARKER(rule.id);
-    const block = `${open}\n${rule.buildContent('codex')}\n${close}`;
+    const content = rule.buildContent('codex');
+    assertEnglishOnlyArtifactText(`${rule.name}\n\n${rule.description}\n\n${content}`, 'rule');
+    const block = `${open}\n${content}\n${close}`;
     // Replace existing block or append
     const openIdx = existing.indexOf(open);
     const closeIdx = existing.indexOf(close);
@@ -74,7 +78,9 @@ async function writeForGemini(rule, projectPath) {
     }
     const open = OPEN_MARKER(rule.id);
     const close = CLOSE_MARKER(rule.id);
-    const block = `${open}\n${rule.buildContent('gemini')}\n${close}`;
+    const content = rule.buildContent('gemini');
+    assertEnglishOnlyArtifactText(`${rule.name}\n\n${rule.description}\n\n${content}`, 'rule');
+    const block = `${open}\n${content}\n${close}`;
     const openIdx = existing.indexOf(open);
     const closeIdx = existing.indexOf(close);
     let updated;

package/dist/engine/universal-rules/rules/planu-english-specs.js

@@ -1,31 +1,35 @@
 // engine/universal-rules/rules/planu-english-specs.ts — Universal rule: specs are written in English
 function buildBody() {
-    return `# Planu Specs Must Be Written in English
+    return `# Planu Artifacts Must Be Written in English
 
 Auto-generated by \`init_project\`. Do not edit manually.
 
 ## Rule
 
-All generated spec content is written in English, regardless of the user's conversation language:
+All generated Planu-owned artifacts are written in English, regardless of the user's conversation language:
 
 - \`spec.md\`
+- Planu skills, including \`SKILL.md\` and host-adapted skill blocks
+- Planu agent instructions, including \`AGENTS.md\`, \`CLAUDE.md\`, \`GEMINI.md\`, and host-specific sections
+- Planu rules, including \`.claude/rules/*.md\`, Codex rule blocks, and Gemini conventions
 - inline \`## Technical\`, \`## Files\`, and \`## Progress\` sections
 - acceptance criteria, implementation notes, validation notes, and reconciliation notes
 
-User-facing chat may use the user's preferred language. The spec contract itself stays in English so every agent, tool, and CI gate can parse it consistently.
+User-facing chat may use the user's preferred language. The persisted Planu contract stays in English so every agent, tool, and CI gate can parse it consistently.
 
 ## Hard Blocks
 
 - Do not create mixed-language acceptance criteria.
 - Do not translate BDD keywords.
+- Do not generate Planu-owned skills, agents, or rules in Spanish, Portuguese, or mixed language.
 - Do not create standalone \`technical.md\`, \`progress.md\`, \`HU.md\`, \`FICHA-TECNICA.md\`, or \`PROGRESS.md\`.
 - Do not approve a spec that contains unresolved placeholders such as \`to be determined\`, \`TBD\`, \`TODO\`, or equivalent filler.
 `;
 }
 export const planuEnglishSpecsRule = {
     id: 'planu-english-specs',
-    name: 'Planu English Specs',
-    description: 'Requires Planu spec artifacts to be written in English.',
+    name: 'Planu English Artifacts',
+    description: 'Requires Planu spec, skill, agent, and rule artifacts to be written in English.',
     category: 'quality',
     applicableHosts: ['all'],
     defaultEnabled: true,

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

@@ -4,6 +4,7 @@
 import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { assertEnglishOnlyArtifactText } from '../../../engine/spec-language/english-only.js';
 const SKILLS_DIR = '.claude/skills';
 /** Canonical skill slugs managed by SPEC-588. */
 const SKILL_SLUGS = [
@@ -68,6 +69,7 @@ async function writeSkillFile(projectPath, slug, content) {
     if (existing === content) {
         return { path: dest, created: false };
     }
+    assertEnglishOnlyArtifactText(content, 'skill');
     await writeFile(dest, content, 'utf-8');
     return { path: dest, created: existing === null };
 }

package/dist/hosts/codex/config-scaffold.js

@@ -12,6 +12,7 @@ import { mkdir, writeFile, readFile, access } from 'node:fs/promises';
 import { join } from 'node:path';
 import { detectCodexWorkspace } from './workspace-scope.js';
 import { buildRulesForHost } from '../../engine/host-rules-templates/index.js';
+import { assertEnglishOnlyArtifactText } from '../../engine/spec-language/english-only.js';
 const CODEX_CONFIG_TOML = `# .openai/config.toml — Planu Codex workspace configuration
 # Auto-generated by Planu init_project. Safe to customize.
 
@@ -79,6 +80,9 @@ async function writeIfMissing(filePath, content) {
         // File exists — skip (idempotent)
     }
     catch {
+        if (filePath.endsWith('AGENTS.md')) {
+            assertEnglishOnlyArtifactText(content, 'agent');
+        }
         await writeFile(filePath, content, 'utf-8');
     }
 }
@@ -91,6 +95,7 @@ const PLANU_RULES_START_REGEX = /<!-- planu:rules:start[^>]* -->/;
  */
 async function injectRulesBlock(filePath, version) {
     const block = buildRulesForHost('codex', version).rules;
+    assertEnglishOnlyArtifactText(block, 'rule');
     let existing;
     try {
         existing = await readFile(filePath, 'utf-8');

package/dist/hosts/gemini/config-scaffold.js

@@ -5,6 +5,7 @@
 import { writeFile, readFile, mkdir, access } from 'node:fs/promises';
 import { join } from 'node:path';
 import { buildRulesForHost } from '../../engine/host-rules-templates/index.js';
+import { assertEnglishOnlyArtifactText } from '../../engine/spec-language/english-only.js';
 // ---------------------------------------------------------------------------
 // File content generators
 // ---------------------------------------------------------------------------
@@ -144,6 +145,8 @@ export async function scaffoldGeminiConfig(projectPath, planuVersion = '1.96.0')
             // Ensure parent directory exists
             const parentDir = join(projectPath, relPath.split('/').slice(0, -1).join('/'));
             await mkdir(parentDir, { recursive: true });
+            const artifactKind = relPath.includes('/skills/') ? 'skill' : 'agent';
+            assertEnglishOnlyArtifactText(content, artifactKind);
             await writeFile(fullPath, content, 'utf-8');
             filesCreated.push(relPath);
         }
@@ -166,6 +169,7 @@ const PLANU_RULES_START_REGEX = /<!-- planu:rules:start[^>]* -->/;
  */
 async function injectRulesBlock(filePath, version) {
     const block = buildRulesForHost('gemini', version).rules;
+    assertEnglishOnlyArtifactText(block, 'rule');
     let existing;
     try {
         existing = await readFile(filePath, 'utf-8');

package/dist/storage/gaps-log.js

@@ -1,6 +1,6 @@
 // storage/gaps-log.ts — SPEC-739: Hash-chained gaps log (JSONL per project)
 //
-// Layout: planu/research/gaps.jsonl
+// Layout: ~/.planu/data/projects/<projectId>/research/gaps.jsonl
 //
 // Each entry is a JSON object on its own line. The `sha` field is a SHA-256 hash
 // of the entry's canonical JSON (excluding `sha`), chained via `prevSha`.
@@ -8,12 +8,12 @@ import { createHash, randomUUID } from 'node:crypto';
 import { appendFile, readFile, mkdir } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { isNativeActive, fastAppendGapEntry, fastVerifyGapsChain } from '../engine/core-bridge.js';
+import { projectDataDir } from './base-store.js';
 // ---------------------------------------------------------------------------
 // Path helper
 // ---------------------------------------------------------------------------
-function gapsLogPath(_projectId) {
-    // Per-spec: stored in planu/research/gaps.jsonl (project-level, not per-spec-id)
-    return join('planu', 'research', 'gaps.jsonl');
+function gapsLogPath(projectId) {
+    return join(projectDataDir(projectId), 'research', 'gaps.jsonl');
 }
 // ---------------------------------------------------------------------------
 // Node error type guard

package/dist/storage/transition-log.js

@@ -1,17 +1,18 @@
 // storage/transition-log.ts — SPEC-723: Hash-chained transition log (JSONL per project)
 //
-// Layout: planu/data/projects/<projectId>/transition-log.jsonl
+// Layout: ~/.planu/data/projects/<projectId>/transition-log.jsonl
 //
 // Each entry is a JSON object on its own line. The `sha` field is a SHA-256 hash
 // of the entry's canonical JSON (excluding `sha`), chained via `prevSha`.
 import { createHash, randomUUID } from 'node:crypto';
 import { appendFile, readFile, mkdir } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { projectDataDir } from './base-store.js';
 // ---------------------------------------------------------------------------
 // Path helper
 // ---------------------------------------------------------------------------
 function transitionLogPath(projectId) {
-    return join('planu', 'data', 'projects', projectId, 'transition-log.jsonl');
+    return join(projectDataDir(projectId), 'transition-log.jsonl');
 }
 // ---------------------------------------------------------------------------
 // Node error type guard

package/dist/tools/audit-specs-drift.js

@@ -7,8 +7,8 @@ export function registerAuditSpecsDriftTool(server) {
         description: 'Run a two-tier drift audit over all done specs. ' +
             'Tier-1: deterministic checks (missing files, broken refs). ' +
             'Tier-2: LLM-based semantic drift for ambiguous cases (budget-capped). ' +
-            'Produces a prioritised P0/P1/P2 markdown report at planu/research/audit-full-<ts>.md ' +
-            'and appends a drift_review entry to planu/pending.json. ' +
+            'Produces a prioritised P0/P1/P2 markdown report in external Planu project data ' +
+            'and appends a drift_review entry to external pending state. ' +
             'Specs superseded by newer specs (per SPEC-746 graph) are excluded.',
         inputSchema: {
             projectPath: z.string().min(1).max(4096).describe('Absolute path to project root.'),
@@ -50,7 +50,7 @@ export function registerAuditSpecsDriftTool(server) {
                         ``,
                         p0 + p1 + p2 === 0
                             ? '✓ No drift detected.'
-                            : `⚠ ${p0 + p1 + p2} total issues found. Review \`planu/pending.json\` for the drift_review entry.`,
+                            : `⚠ ${p0 + p1 + p2} total issues found. Review external Planu pending state for the drift_review entry.`,
                     ].join('\n'),
                 },
             ],

package/dist/tools/create-skill.js

@@ -3,6 +3,7 @@
 import { readFile, mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { detectHost } from '../engine/host-detection/detect-host.js';
+import { validateEnglishOnlyArtifactText } from '../engine/spec-language/english-only.js';
 import { hashContent } from '../engine/universal-rules/user-edit-detector.js';
 import { hashProjectPath } from '../storage/base-store.js';
 import { appendAutopilotLogEntry } from '../storage/autopilot-log-store.js';
@@ -96,6 +97,26 @@ export async function handleCreateSkill(input) {
     const { projectPath, name, content, overwriteExisting } = input;
     const description = input.description ?? '';
     const host = resolveHost(input);
+    const languageValidation = validateEnglishOnlyArtifactText(`${name}\n\n${description}\n\n${content}`, 'skill');
+    if (!languageValidation.ok) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `English-only skill gate blocked create_skill.\n\n` +
+                        `${languageValidation.reason ?? 'Non-English prose detected.'}\n\n` +
+                        'Rewrite the skill name, description, and content in English before creating it.',
+                },
+            ],
+            isError: true,
+            structuredContent: {
+                error: 'SKILL_LANGUAGE_GATE_BLOCKED',
+                detectedLanguage: languageValidation.detectedLanguage,
+                signals: languageValidation.signals,
+                fixHint: 'Rewrite skill artifacts in English.',
+            },
+        };
+    }
     let result;
     try {
         switch (host) {

package/dist/tools/create-spec/post-creation.d.ts

@@ -1,4 +1,5 @@
 import type { Spec, PostCreationSuggestion, ProjectKnowledge } from '../../types/index.js';
+export declare function getAsyncAnalysisPath(projectPath: string, specId: string): string;
 /** Auto-setup git branch (non-blocking). Returns branch info or undefined. */
 export declare function setupGitBranch(projectId: string, specId: string): Promise<{
     branch: string;
@@ -13,7 +14,7 @@ export declare function generatePostCreationSuggestions(projectPath: string, des
 /**
  * SPEC-781: Run heavy analysis (contradiction detection, complexity advice) in a
  * fire-and-forget fashion after the spec has already been persisted synchronously.
- * Writes results to `planu/specs/SPEC-XXX/.analysis.json` and appends an
+ * Writes results to Planu's external project data dir and appends an
  * autopilot-log entry on completion. Never throws — fully best-effort.
  */
 export declare function runAutopilotAsync(specId: string, projectPath: string, _description: string): void;

package/dist/tools/create-spec/post-creation.js

@@ -10,9 +10,13 @@ import { emitAutopilotEvent } from '../../engine/autopilot/event-bus.js';
 import { incrementSpecCount } from '../../engine/autopilot/state-updater.js';
 import { writeFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
-import { hashProjectPath } from '../../storage/base-store.js';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 import { appendAutopilotLogEntry } from '../../storage/autopilot-log-store.js';
 const ASYNC_ANALYSIS_HOOK = 'create-spec-async-analysis';
+export function getAsyncAnalysisPath(projectPath, specId) {
+    const projectId = hashProjectPath(projectPath);
+    return join(projectDataDir(projectId), 'analysis', `${specId}.json`);
+}
 /** Auto-setup git branch (non-blocking). Returns branch info or undefined. */
 export async function setupGitBranch(projectId, specId) {
     const result = await tryAutoSetupGit(projectId, specId);
@@ -161,7 +165,7 @@ export async function generatePostCreationSuggestions(projectPath, description,
 /**
  * SPEC-781: Run heavy analysis (contradiction detection, complexity advice) in a
  * fire-and-forget fashion after the spec has already been persisted synchronously.
- * Writes results to `planu/specs/SPEC-XXX/.analysis.json` and appends an
+ * Writes results to Planu's external project data dir and appends an
  * autopilot-log entry on completion. Never throws — fully best-effort.
  */
 export function runAutopilotAsync(specId, projectPath, _description) {
@@ -169,20 +173,14 @@ export function runAutopilotAsync(specId, projectPath, _description) {
     const start = Date.now();
     void (async () => {
         try {
-            const { glob } = await import('glob');
-            const specFiles = await glob(join(projectPath, 'planu/specs', `${specId}-*`, 'spec.md'));
-            const specDir = specFiles[0] !== undefined ? dirname(specFiles[0]) : null;
             const analysisResult = {
                 specId,
                 completedAt: new Date().toISOString(),
                 pendingAnalysis: false,
             };
-            // Write .analysis.json to spec directory
-            if (specDir !== null) {
-                const analysisPath = join(specDir, '.analysis.json');
-                await mkdir(dirname(analysisPath), { recursive: true });
-                await writeFile(analysisPath, JSON.stringify(analysisResult, null, 2), 'utf-8');
-            }
+            const analysisPath = getAsyncAnalysisPath(projectPath, specId);
+            await mkdir(dirname(analysisPath), { recursive: true });
+            await writeFile(analysisPath, JSON.stringify(analysisResult, null, 2), 'utf-8');
             await appendAutopilotLogEntry(projectId, {
                 specId,
                 hookName: ASYNC_ANALYSIS_HOOK,

package/dist/tools/create-spec/spec-builder.js

@@ -26,7 +26,7 @@ export async function buildSpecContext(params) {
     const knowledge = await knowledgeStore.getKnowledge(projectId);
     const existingSpecs = await specStore.listSpecs(projectId);
     // License: check active spec limit (exclude completed specs)
-    const activeSpecs = existingSpecs.filter((s) => s.status !== 'done');
+    const activeSpecs = existingSpecs.filter((s) => s.status !== 'done' && s.status !== 'discarded');
     const tier = await getCurrentTier();
     const specLimit = checkLimits(tier, activeSpecs.length, 'maxActiveSpecs');
     /* v8 ignore start -- license limit requires paid tier test env */