@planu/cli 3.9.5 → 3.9.7

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [3.9.6] - 2026-05-15
+
+**Tarball SHA-256:** `56592815d33401b0cd7aa1d02ca26c7dda8dd131176841ccda3163932e53b43b`
+
+
 ## [3.9.5] - 2026-05-15
 
 **Tarball SHA-256:** `11fa506c006e59292069158b32b580ab861cfb71ea5fefa60c5308fbf55b129a`

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/universal-rules/catalog.js

@@ -4,12 +4,20 @@ 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';
 /**
  * The full catalog of universal Planu rules.
  * Order matters: rules are installed in catalog order.
  */
 export const UNIVERSAL_RULES = [
     planuWorkflowRule,
+    planuEnglishSpecsRule,
+    planuBddCriteriaRule,
+    planuApprovalGatesRule,
+    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

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

@@ -0,0 +1,36 @@
+// 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
+
+Auto-generated by \`init_project\`. Do not edit manually.
+
+## Rule
+
+All generated spec artifacts are written in English, regardless of the user's conversation language:
+
+- \`spec.md\`
+- \`technical.md\`
+- architecture notes inside \`planu/specs/**\`
+- acceptance criteria
+- implementation notes
+- validation 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.
+
+## Hard Blocks
+
+- Do not create mixed-language acceptance criteria.
+- Do not translate BDD keywords.
+- 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.',
+    category: 'quality',
+    applicableHosts: ['all'],
+    defaultEnabled: true,
+    buildContent: (_host) => buildBody(),
+};
+//# sourceMappingURL=planu-english-specs.js.map

package/dist/engine/universal-rules/rules/planu-release-policy.d.ts

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

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

@@ -0,0 +1,38 @@
+// engine/universal-rules/rules/planu-release-policy.ts — Universal rule: release decision
+function buildBody() {
+    return `# Planu Release Policy
+
+Auto-generated by \`init_project\`. Do not edit manually.
+
+## Rule
+
+When implementation changes are complete and validated, always address release explicitly:
+
+- create the release when the user has already requested shipping or publishing
+- otherwise ask before publishing, tagging, or pushing externally visible release artifacts
+
+## Required Release Checklist
+
+- tests and 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
+- 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 leave release notes promising capabilities that are not in the public runtime.
+`;
+}
+export const planuReleasePolicyRule = {
+    id: 'planu-release-policy',
+    name: 'Planu Release Policy',
+    description: 'Requires an explicit release decision after validated implementation work.',
+    category: 'safety',
+    applicableHosts: ['all'],
+    defaultEnabled: true,
+    buildContent: (_host) => buildBody(),
+};
+//# sourceMappingURL=planu-release-policy.js.map

package/dist/tools/init-project/host-assets-writer.d.ts

@@ -0,0 +1,21 @@
+import type { ProjectKnowledge } from '../../types/index.js';
+import type { HostId, InstalledRule } from '../../types/universal-rules/index.js';
+export type InitAssetHost = HostId | 'opencode';
+export interface InitHostAssetsResult {
+    detectedHosts: InitAssetHost[];
+    rulesInstalled: InstalledRule[];
+    skillsInstalled: {
+        host: HostId;
+        name: string;
+        path: string;
+    }[];
+    opencodeConfigured: boolean;
+}
+/**
+ * Detect every project host that should receive Planu-owned assets.
+ * Environment identifies the active MCP host; files identify other checked-in
+ * host configs that should stay in sync too.
+ */
+export declare function detectInitAssetHosts(projectPath: string): Promise<InitAssetHost[]>;
+export declare function installInitHostAssets(projectPath: string, _knowledge: ProjectKnowledge): Promise<InitHostAssetsResult>;
+//# sourceMappingURL=host-assets-writer.d.ts.map

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

@@ -0,0 +1,171 @@
+// tools/init-project/host-assets-writer.ts — Host-aware rules/skills installed by init_project
+import { access, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { detectHost } from '../../engine/host-detection/detect-host.js';
+import { handleCreateSkill } from '../create-skill.js';
+const CORE_SKILL_TEMPLATES = [
+    'planu-new-spec.md',
+    'planu-validate.md',
+    'planu-release.md',
+    'planu-resume-work.md',
+    'planu-multi-teammate-review.md',
+    'planu-context-assets.md',
+];
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function addHost(hosts, host) {
+    if (!hosts.includes(host)) {
+        hosts.push(host);
+    }
+}
+/**
+ * Detect every project host that should receive Planu-owned assets.
+ * Environment identifies the active MCP host; files identify other checked-in
+ * host configs that should stay in sync too.
+ */
+export async function detectInitAssetHosts(projectPath) {
+    const hosts = [];
+    const activeHost = detectHost();
+    if (activeHost === 'claude-code' || activeHost === 'codex' || activeHost === 'gemini') {
+        addHost(hosts, activeHost);
+    }
+    const checks = await Promise.all([
+        fileExists(join(projectPath, 'CLAUDE.md')),
+        fileExists(join(projectPath, '.claude')),
+        fileExists(join(projectPath, 'AGENTS.md')),
+        fileExists(join(projectPath, '.openai')),
+        fileExists(join(projectPath, 'GEMINI.md')),
+        fileExists(join(projectPath, '.gemini')),
+        fileExists(join(projectPath, 'opencode.json')),
+        fileExists(join(projectPath, '.opencode')),
+    ]);
+    const [hasClaudeMd, hasClaudeDir, hasAgentsMd, hasOpenAiDir, hasGeminiMd, hasGeminiDir, hasOpenCodeJson, hasOpenCodeDir,] = checks;
+    if (hasClaudeMd || hasClaudeDir) {
+        addHost(hosts, 'claude-code');
+    }
+    if (hasAgentsMd || hasOpenAiDir) {
+        addHost(hosts, 'codex');
+    }
+    if (hasGeminiMd || hasGeminiDir) {
+        addHost(hosts, 'gemini');
+    }
+    if (hasOpenCodeJson || hasOpenCodeDir) {
+        addHost(hosts, 'opencode');
+    }
+    // Portable default for new/unknown projects: AGENTS.md, not Claude-specific files.
+    if (hosts.length === 0) {
+        addHost(hosts, 'codex');
+    }
+    return hosts;
+}
+async function installRulesForHost(projectPath, host) {
+    try {
+        const { installUniversalRules } = await import('../../engine/universal-rules/installer.js');
+        return await installUniversalRules(projectPath, host);
+    }
+    catch {
+        return [];
+    }
+}
+function parseSkillTemplate(raw, fallbackName) {
+    const frontmatter = /^---\n([\s\S]*?)\n---\n?/.exec(raw);
+    const name = /(?:^|\n)name:\s*([^\n]+)/.exec(frontmatter?.[1] ?? '')?.[1]?.trim() ??
+        fallbackName.replace(/\.md$/, '');
+    const description = /(?:^|\n)description:\s*([^\n]+)/.exec(frontmatter?.[1] ?? '')?.[1]?.trim() ??
+        `Planu workflow skill: ${name}`;
+    const content = frontmatter ? raw.slice(frontmatter[0].length) : raw;
+    return {
+        name,
+        description: description.replace(/^["']|["']$/g, ''),
+        content: content.trimEnd() + '\n',
+    };
+}
+async function readCoreSkillTemplate(fileName) {
+    try {
+        const { fileURLToPath } = await import('node:url');
+        const templatePath = join(fileURLToPath(new URL('.', import.meta.url)), '../../config/skill-templates', fileName);
+        const raw = await readFile(templatePath, 'utf-8');
+        return parseSkillTemplate(raw, fileName);
+    }
+    catch {
+        return null;
+    }
+}
+async function installCoreSkillsForHost(projectPath, host) {
+    const installed = [];
+    for (const fileName of CORE_SKILL_TEMPLATES) {
+        const template = await readCoreSkillTemplate(fileName);
+        if (template === null) {
+            continue;
+        }
+        const result = await handleCreateSkill({
+            projectPath,
+            host,
+            name: template.name,
+            description: template.description,
+            content: template.content,
+            overwriteExisting: false,
+        });
+        if (result.isError === true) {
+            continue;
+        }
+        const path = typeof result.structuredContent === 'object' &&
+            'skillFilePath' in result.structuredContent &&
+            typeof result.structuredContent.skillFilePath === 'string'
+            ? result.structuredContent.skillFilePath
+            : host === 'codex'
+                ? join(projectPath, 'AGENTS.md')
+                : host === 'gemini'
+                    ? join(projectPath, '.gemini', 'skills', `${template.name}.md`)
+                    : join(projectPath, '.claude', 'skills', template.name, 'SKILL.md');
+        installed.push({ host, name: template.name, path });
+    }
+    return installed;
+}
+async function scaffoldHostConfig(projectPath, host) {
+    try {
+        if (host === 'codex') {
+            const { scaffoldCodexConfig } = await import('../../hosts/codex/config-scaffold.js');
+            await scaffoldCodexConfig(projectPath);
+            return true;
+        }
+        if (host === 'gemini') {
+            const { scaffoldGeminiConfig } = await import('../../hosts/gemini/config-scaffold.js');
+            await scaffoldGeminiConfig(projectPath);
+            return true;
+        }
+        if (host === 'opencode') {
+            const { scaffoldOpenCodeConfig } = await import('../../engine/opencode/config-scaffold.js');
+            scaffoldOpenCodeConfig(projectPath);
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+export async function installInitHostAssets(projectPath, _knowledge) {
+    const detectedHosts = await detectInitAssetHosts(projectPath);
+    const rulesInstalled = [];
+    const skillsInstalled = [];
+    let opencodeConfigured = false;
+    for (const host of detectedHosts) {
+        const configured = await scaffoldHostConfig(projectPath, host);
+        if (host === 'opencode') {
+            opencodeConfigured ||= configured;
+            continue;
+        }
+        rulesInstalled.push(...(await installRulesForHost(projectPath, host)));
+        skillsInstalled.push(...(await installCoreSkillsForHost(projectPath, host)));
+    }
+    return { detectedHosts, rulesInstalled, skillsInstalled, opencodeConfigured };
+}
+//# sourceMappingURL=host-assets-writer.js.map

package/dist/tools/init-project/scaffold-writer.d.ts

@@ -44,6 +44,14 @@ export interface ScaffoldWriteResult {
     pluginsInstalled: Pick<PluginInstallResult, 'marketplaceAdded' | 'installed' | 'skipped' | 'failed'> | null;
     /** SPEC-685: Number of workflow skill files written by generateWorkflowSkills. */
     workflowSkillsWritten: number;
+    /** Hosts that received Planu init assets (rules/skills/config). */
+    detectedAssetHosts: string[];
+    /** Number of host-aware universal rules written by init_project. */
+    hostRulesWritten: number;
+    /** Number of host-aware core skills written by init_project. */
+    hostSkillsWritten: number;
+    /** Whether OpenCode Planu assets were configured. */
+    opencodeConfigScaffolded: boolean;
 }
 /**
  * Write all scaffold files to disk:

package/dist/tools/init-project/scaffold-writer.js

@@ -27,6 +27,7 @@ import { generateWorkflowSkills } from '../../engine/skill-generator/workflow-sk
  * - ESLint/Prettier config
  * - Architecture rules
  */
+// eslint-disable-next-line complexity
 export async function runScaffoldWriter(projectPath, projectId, knowledge, recommendedSkills, permissionsMode, pluginsMode) {
     // Generate and write AI rules files
     const rulesResult = await runRulesWriter(projectPath, projectId, knowledge, recommendedSkills);
@@ -44,15 +45,33 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
             /* best-effort */
         }
     }
-    // Auto-inject SDD workflow into CLAUDE.md (best-effort, idempotent)
-    let claudeMdUpdated = false;
+    let detectedAssetHosts = [];
+    let hostRulesWritten = 0;
+    let hostSkillsWritten = 0;
+    let opencodeConfigScaffolded = false;
     try {
-        const projectSections = buildProjectSections(knowledge);
-        claudeMdUpdated = await injectSddIntoClaude(projectPath, projectSections);
+        const { installInitHostAssets } = await import('./host-assets-writer.js');
+        const hostAssets = await installInitHostAssets(projectPath, knowledge);
+        detectedAssetHosts = hostAssets.detectedHosts;
+        hostRulesWritten = hostAssets.rulesInstalled.length;
+        hostSkillsWritten = hostAssets.skillsInstalled.length;
+        opencodeConfigScaffolded = hostAssets.opencodeConfigured;
     }
     catch {
         /* best-effort */
     }
+    const shouldWriteClaudeAssets = detectedAssetHosts.includes('claude-code');
+    // Auto-inject SDD workflow into CLAUDE.md (best-effort, idempotent)
+    let claudeMdUpdated = false;
+    if (shouldWriteClaudeAssets) {
+        try {
+            const projectSections = buildProjectSections(knowledge);
+            claudeMdUpdated = await injectSddIntoClaude(projectPath, projectSections);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
     // SPEC-178: Scaffold ESLint and Prettier config if missing (best-effort)
     let eslintCreated = false;
     let prettierCreated = false;
@@ -70,69 +89,85 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
     const { written: architectureRulesWritten, skipped: architectureRulesSkipped } = generateAndWriteRules(projectPath);
     // SPEC-263: Inject Planu SDD Workflow section into CLAUDE.md (idempotent, best-effort)
     let planuWorkflowInjected = false;
-    try {
-        const claudeMdPath = `${projectPath}/CLAUDE.md`;
-        const section = generatePlanuSection(projectPath, projectId);
-        await injectPlanuSection(claudeMdPath, section);
-        planuWorkflowInjected = true;
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            const claudeMdPath = `${projectPath}/CLAUDE.md`;
+            const section = generatePlanuSection(projectPath, projectId);
+            await injectPlanuSection(claudeMdPath, section);
+            planuWorkflowInjected = true;
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-263: Configure Planu hooks in .claude.json (idempotent, best-effort)
     let planuHooksConfigured = false;
-    try {
-        planuHooksConfigured = await configurePlanuHooks(projectPath);
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            planuHooksConfigured = await configurePlanuHooks(projectPath);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-263: Write .claude/rules/planu-workflow.md if missing (best-effort)
     let planuRulesWritten = false;
-    try {
-        planuRulesWritten = await generateWorkflowRulesIfMissing(projectPath);
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            planuRulesWritten = await generateWorkflowRulesIfMissing(projectPath);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-291: Write .claude/rules/agent-teams.md if missing (best-effort)
     let agentTeamsRulesWritten = false;
-    try {
-        agentTeamsRulesWritten = await generateAgentTeamsRulesIfMissing(projectPath);
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            agentTeamsRulesWritten = await generateAgentTeamsRulesIfMissing(projectPath);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-494: Write .claude/rules/planu-modes.md if missing (best-effort)
     let modeRulesWritten = false;
-    try {
-        modeRulesWritten = await generateModeRulesIfMissing(projectPath);
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            modeRulesWritten = await generateModeRulesIfMissing(projectPath);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-517: Write .claude/rules/planu-response-style.md if missing (best-effort)
     let responseStyleRulesWritten = false;
-    try {
-        responseStyleRulesWritten = await generateResponseStyleRulesIfMissing(projectPath);
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            responseStyleRulesWritten = await generateResponseStyleRulesIfMissing(projectPath);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-519: Write .claude/skills/compact.md if missing (best-effort)
     let compactSkillWritten = false;
-    try {
-        compactSkillWritten = await generateCompactSkillIfMissing(projectPath);
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            compactSkillWritten = await generateCompactSkillIfMissing(projectPath);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-655: Write .claude/skills/find-skills.md if missing (best-effort, idempotent)
-    try {
-        await generateFindSkillsIfMissing(projectPath);
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            await generateFindSkillsIfMissing(projectPath);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-347: Inject git auto-stage snippet for planu HTML files (best-effort)
     let gitAutoStageInjected = false;
@@ -167,11 +202,13 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
     }
     // SPEC-530: Generate .claude/rules/conventions.md (best-effort, idempotent)
     let conventionsMdWritten = false;
-    try {
-        conventionsMdWritten = await generateConventionsMdIfMissing(projectPath, knowledge);
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            conventionsMdWritten = await generateConventionsMdIfMissing(projectPath, knowledge);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-591: Scaffold .gemini/ if a Gemini workspace marker is present (best-effort, idempotent)
     let geminiConfigScaffolded = false;
@@ -188,11 +225,14 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
     }
     // SPEC-593: Write .claude/skills/planu-multi-teammate-review.md if missing (best-effort, idempotent)
     let multiTeammateReviewSkillWritten = false;
-    try {
-        multiTeammateReviewSkillWritten = await generateMultiTeammateReviewSkillIfMissing(projectPath);
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            multiTeammateReviewSkillWritten =
+                await generateMultiTeammateReviewSkillIfMissing(projectPath);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-592: Scaffold Codex workspace config if Codex env is detected (best-effort, no-op outside Codex)
     let codexConfigScaffolded = false;
@@ -213,17 +253,19 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
     // (idempotent — skips files already up-to-date; best-effort, no-op elsewhere)
     let planuSubagentsScaffolded = false;
     let planuUxSkillsScaffolded = 0;
-    try {
-        const { scaffoldPlanuSubagents, scaffoldPlanuSkills } = await import('../../hosts/claude-code/ux/index.js');
-        const [subagentResult, skillResult] = await Promise.all([
-            scaffoldPlanuSubagents(projectPath),
-            scaffoldPlanuSkills(projectPath),
-        ]);
-        planuSubagentsScaffolded = subagentResult.created.length > 0;
-        planuUxSkillsScaffolded = skillResult.created.length;
-    }
-    catch {
-        /* best-effort */
+    if (shouldWriteClaudeAssets) {
+        try {
+            const { scaffoldPlanuSubagents, scaffoldPlanuSkills } = await import('../../hosts/claude-code/ux/index.js');
+            const [subagentResult, skillResult] = await Promise.all([
+                scaffoldPlanuSubagents(projectPath),
+                scaffoldPlanuSkills(projectPath),
+            ]);
+            planuSubagentsScaffolded = subagentResult.created.length > 0;
+            planuUxSkillsScaffolded = skillResult.created.length;
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-594: Configure .claude/settings.json permissions (opt-in; idempotent; best-effort)
     let permissionsConfigured = null;
@@ -282,12 +324,14 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
     }
     // SPEC-685: Generate all 22 workflow skill files (idempotent, best-effort)
     let workflowSkillsWritten = 0;
-    try {
-        const skillResult = await generateWorkflowSkills(projectPath, knowledge);
-        workflowSkillsWritten = skillResult.written.length;
-    }
-    catch {
-        /* best-effort — never fail init_project */
+    if (shouldWriteClaudeAssets) {
+        try {
+            const skillResult = await generateWorkflowSkills(projectPath, knowledge);
+            workflowSkillsWritten = skillResult.written.length;
+        }
+        catch {
+            /* best-effort — never fail init_project */
+        }
     }
     // SPEC-587: Install spec-sanctity PostToolUse hook when Claude Code is detected
     // (idempotent — overwrites only when content differs; best-effort, no-op elsewhere)
@@ -364,6 +408,10 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
         permissionsConfigured,
         pluginsInstalled,
         workflowSkillsWritten,
+        detectedAssetHosts,
+        hostRulesWritten,
+        hostSkillsWritten,
+        opencodeConfigScaffolded,
     };
 }
 //# sourceMappingURL=scaffold-writer.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "3.9.5",
+  "version": "3.9.7",
   "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",
@@ -32,12 +32,12 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "3.1.0",
-    "@planu/core-darwin-x64": "3.1.0",
-    "@planu/core-linux-arm64-gnu": "3.1.0",
-    "@planu/core-linux-arm64-musl": "3.1.0",
-    "@planu/core-linux-x64-gnu": "3.1.0",
-    "@planu/core-linux-x64-musl": "3.1.0"
+    "@planu/core-darwin-arm64": "3.9.7",
+    "@planu/core-darwin-x64": "3.9.7",
+    "@planu/core-linux-arm64-gnu": "3.9.7",
+    "@planu/core-linux-arm64-musl": "3.9.7",
+    "@planu/core-linux-x64-gnu": "3.9.7",
+    "@planu/core-linux-x64-musl": "3.9.7"
   },
   "engines": {
     "node": ">=24.0.0"