@planu/cli 3.9.6 → 3.9.8

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/engine/universal-rules/rules/planu-sdd-model-routing.d.ts

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

package/dist/engine/universal-rules/rules/planu-sdd-model-routing.js

@@ -0,0 +1,51 @@
+// engine/universal-rules/rules/planu-sdd-model-routing.ts — Universal rule: model routing + context continuity
+function buildBody() {
+    return `# Planu SDD Model Routing and Context Guarantee
+
+Auto-generated by \`init_project\`. Do not edit manually.
+
+## Required Model Tiers
+
+- Analysis/spec phase (\`facilitate\`, \`create_spec\`, \`challenge_spec\`, \`check_readiness\`): use the strongest available model, such as Opus, GPT-5.5, Gemini Pro/Ultra, or equivalent.
+- Implementation phase: use a lower/intermediate implementation model only after the approved spec and handoff package are complete.
+- Review phase: use a reviewer-grade model/agent.
+- Arbitration/close phase: use the strongest available model or an explicit arbiter.
+
+## Phase Gates
+
+- \`update_status(approved)\` must include max-model evidence: \`modelTierUsed=max\` or a frontier \`modelId\`.
+- \`update_status(implementing)\` must include \`modelTierUsed=implementation\`, \`contextHash\`, and \`handoffPath\` or \`handoffArtifactId\`.
+- \`update_status(done)\` must include validate evidence, \`reviewedBy\`, \`arbitratedBy\`, \`contextHash\`, and the handoff reference.
+- If implementation changes architecture or scope, move the spec back to \`review\` and run \`reconcile_spec\`.
+
+## Context Contract
+
+\`package_handoff\` is the operating contract for the implementer. It must include:
+
+- objective
+- BDD acceptance criteria
+- files to modify/create
+- ownership
+- test plan
+- risks
+- out-of-scope
+- current state
+- next action
+
+The package must be persisted outside chat history. Do not rely on memory from the current conversation.
+
+## Force Policy
+
+Forcing a blocked phase is allowed only with an audited reason of at least 100 characters. The reason must state which gate was bypassed and what follow-up is required.
+`;
+}
+export const planuSddModelRoutingRule = {
+    id: 'planu-sdd-model-routing',
+    name: 'Planu SDD Model Routing',
+    description: 'Requires correct model tiers and reconstructible context across SDD phases.',
+    category: 'safety',
+    applicableHosts: ['all'],
+    defaultEnabled: true,
+    buildContent: (_host) => buildBody(),
+};
+//# sourceMappingURL=planu-sdd-model-routing.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