@open-product-primer/cli 2.9.0 → 2.11.0

package/dist/cli.js

@@ -16,6 +16,7 @@ const context_1 = require("./commands/context");
 const list_1 = require("./commands/list");
 const show_1 = require("./commands/show");
 const status_1 = require("./commands/status");
+const claude_mods_1 = require("./commands/claude-mods");
 const package_json_1 = __importDefault(require("../package.json"));
 const program = new commander_1.Command();
 program
@@ -33,4 +34,5 @@ program.addCommand((0, context_1.contextCommand)());
 program.addCommand((0, list_1.listCommand)());
 program.addCommand((0, show_1.showCommand)());
 program.addCommand((0, status_1.statusCommand)());
+program.addCommand((0, claude_mods_1.claudeModsCommand)());
 program.parse();

package/dist/commands/claude-mods.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function claudeModsCommand(): Command;

package/dist/commands/claude-mods.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeModsCommand = claudeModsCommand;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const detect_1 = require("../lib/detect");
+const install_agent_1 = require("../lib/install-agent");
+function claudeModsCommand() {
+    return new commander_1.Command('claude-mods')
+        .description('Select which Claude Code function-hook mods are installed')
+        .action(async () => {
+        const projectRoot = process.cwd();
+        const agents = (0, detect_1.readAgentsFromConfig)(projectRoot);
+        if (!agents || !agents.includes('claude')) {
+            console.error(chalk_1.default.red('Claude Code is not installed in this project.') +
+                ' Run ' +
+                chalk_1.default.cyan('oprim init') +
+                ' and select Claude Code first.');
+            process.exitCode = 1;
+            return;
+        }
+        const previousMods = (0, detect_1.readClaudeModsFromConfig)(projectRoot);
+        const selectedMods = await (0, install_agent_1.promptClaudeModsSelection)(previousMods);
+        if (selectedMods.length > 0 && !(0, install_agent_1.isFunctionHooksActive)(projectRoot)) {
+            const enable = await (0, install_agent_1.promptEnableFunctionHooks)();
+            if (enable) {
+                (0, install_agent_1.enableFunctionHooks)(projectRoot);
+                console.log(chalk_1.default.green('✓') + ' .claude/settings.json (function hooks enabled)');
+            }
+            else {
+                (0, install_agent_1.printManualFunctionHooksActivation)();
+            }
+        }
+        (0, install_agent_1.applyClaudeModsSelection)(projectRoot, selectedMods, previousMods);
+        if (selectedMods.length === 0) {
+            console.log(chalk_1.default.dim('  No mods selected — any previously-installed mod hooks were removed.'));
+        }
+        else {
+            console.log(chalk_1.default.green('✓') + ` Claude mods installed: ${selectedMods.join(', ')}`);
+        }
+    });
+}

package/dist/commands/init.js

@@ -48,7 +48,7 @@ function initCommand() {
     return new commander_1.Command('init')
         .description('Initialize oprim in the current repository')
         .option('--name <name>', 'project name (defaults to directory name)')
-        .option('--agent <name>', 'AI agent to install skills for (repeatable; supported: claude, cursor, codex, gemini, poolside, vibe, qwen, kimi)', (val, prev) => [...prev, val], [])
+        .option('--agent <name>', 'AI agent to install skills for (repeatable; supported: claude, cursor, codex, gemini, poolside, vibe, qwen, kimi, dsh)', (val, prev) => [...prev, val], [])
         .action(async (opts) => {
         const projectRoot = process.cwd();
         const projectName = opts.name ?? path.basename(projectRoot);
@@ -147,6 +147,22 @@ function initCommand() {
                 (0, install_agent_1.installAgentSkills)(agent, projectRoot, specFramework, pdrSurfacing);
             }
             console.log('\n' + chalk_1.default.green('✓') + ` Agent skills installed: ${selectedAgents.join(', ')}`);
+            if (selectedAgents.includes('claude')) {
+                const previousMods = (0, detect_1.readClaudeModsFromConfig)(projectRoot);
+                console.log('');
+                const selectedMods = await (0, install_agent_1.promptClaudeModsSelection)(previousMods);
+                if (selectedMods.length > 0 && !(0, install_agent_1.isFunctionHooksActive)(projectRoot)) {
+                    const enable = await (0, install_agent_1.promptEnableFunctionHooks)();
+                    if (enable) {
+                        (0, install_agent_1.enableFunctionHooks)(projectRoot);
+                        console.log(chalk_1.default.green('✓') + ' .claude/settings.json (function hooks enabled)');
+                    }
+                    else {
+                        (0, install_agent_1.printManualFunctionHooksActivation)();
+                    }
+                }
+                (0, install_agent_1.applyClaudeModsSelection)(projectRoot, selectedMods, previousMods);
+            }
         }
         console.log('\nRun ' + chalk_1.default.cyan('oprim doctor') + ' to verify your setup.');
         console.log('\n' +

package/dist/lib/claude-mods.d.ts

@@ -0,0 +1,15 @@
+export interface ClaudeModHookFile {
+    filename: string;
+    content: string;
+    event: 'PreToolUse' | 'PostToolUse' | 'UserPromptSubmit' | 'Stop';
+    matcher?: string;
+    command: string;
+}
+export interface ClaudeMod {
+    id: string;
+    title: string;
+    description: string;
+    hookFiles: ClaudeModHookFile[];
+}
+export declare const CLAUDE_MODS_REGISTRY: ClaudeMod[];
+export declare function getClaudeMod(id: string): ClaudeMod | undefined;

package/dist/lib/claude-mods.js

@@ -0,0 +1,78 @@
+"use strict";
+// Static registry of installable Claude Code function-hook "mods" — see
+// oprim/bets/pending/BET-051-spec-delta-drift-interceptor-mod/design.md. Both `oprim init`'s
+// mod-selection prompt and the `oprim claude-mods` command read from this single registry, so a
+// future mod (BET-052–066) is added here once rather than duplicated per entry point.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_MODS_REGISTRY = void 0;
+exports.getClaudeMod = getClaudeMod;
+// PostToolUse hook: on a Write/Edit to a bet's specs/<capability>/spec.md delta, shells out to
+// `oprim validate --json` (already runs checkSpecDeltaDrift()) and surfaces any MODIFIED/REMOVED
+// drift for that capability inline, at write time instead of only at validate/CI time. Silently
+// no-ops on any failure (oprim not resolvable, malformed hook input, etc.) — this is a
+// write-time convenience on top of `oprim validate`, never a second source of required failures.
+const SPEC_DELTA_DRIFT_INTERCEPTOR_SCRIPT = `#!/usr/bin/env node
+// PostToolUse hook (Write|Edit) — see claude-mods.ts's spec-delta-drift-interceptor entry.
+
+let raw = '';
+process.stdin.on('data', (chunk) => { raw += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const input = JSON.parse(raw || '{}');
+    const filePath = input.tool_input && input.tool_input.file_path;
+    if (!filePath) return;
+
+    const match = String(filePath).replace(/\\\\/g, '/').match(
+      /oprim\\/bets\\/pending\\/[^/]+\\/specs\\/([^/]+)\\/spec\\.md$/
+    );
+    if (!match) return;
+    const capability = match[1];
+
+    const { execSync } = require('child_process');
+    let output;
+    try {
+      output = execSync('npx --no-install oprim validate --json', {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
+    } catch (err) {
+      // validate exits non-zero when a required check fails — stdout still carries the report
+      output = err && err.stdout ? err.stdout.toString() : null;
+    }
+    if (!output) return;
+
+    const report = JSON.parse(output);
+    const drift = (report.checks || []).filter(
+      (c) => c.name && c.name.startsWith('spec-delta:') && c.name.includes(\`in \${capability} \`) && !c.pass
+    );
+    if (drift.length === 0) return;
+
+    const reason = drift.map((c) => \`- \${c.name}\${c.note ? \` (\${c.note})\` : ''}\`).join('\\n');
+    process.stdout.write(JSON.stringify({
+      decision: 'block',
+      reason: \`Spec-delta drift detected in \${capability}:\\n\${reason}\`,
+    }) + '\\n');
+  } catch {
+    // Graceful degradation — never error or block on interceptor failure.
+  }
+});
+`;
+exports.CLAUDE_MODS_REGISTRY = [
+    {
+        id: 'spec-delta-drift-interceptor',
+        title: 'Spec-delta drift interceptor',
+        description: "Catches a bet's spec-delta MODIFIED/REMOVED requirement drifting from oprim/specs current truth at write time, instead of only at oprim validate/CI time.",
+        hookFiles: [
+            {
+                filename: 'spec-delta-drift-interceptor.js',
+                content: SPEC_DELTA_DRIFT_INTERCEPTOR_SCRIPT,
+                event: 'PostToolUse',
+                matcher: 'Write|Edit',
+                command: 'node ".claude/hooks/spec-delta-drift-interceptor.js"',
+            },
+        ],
+    },
+];
+function getClaudeMod(id) {
+    return exports.CLAUDE_MODS_REGISTRY.find((mod) => mod.id === id);
+}

package/dist/lib/config-merge.js

@@ -12,6 +12,8 @@ const CONFIG_SCHEMA_FIELDS = [
     // merge only adds missing keys, never removes existing ones), but new/updated configs only
     // ever gain `remote_context`.
     { key: 'remote_context', block: 'remote_context:\n  enabled: false\n  sources: []\n' },
+    // bet-051 — installed claude-mods selection, mirroring how `agents:` is stored/rewritten.
+    { key: 'claude_mods', block: 'claude_mods: []\n' },
 ];
 function existingTopLevelKeys(content) {
     const keys = new Set();

package/dist/lib/detect.d.ts

@@ -10,3 +10,5 @@ export declare function readAgentsFromConfig(projectRoot: string): string[] | nu
 export declare function readOkfEnabledFromConfig(projectRoot: string): boolean;
 export declare function detectAvailableAgents(projectRoot: string): string[];
 export declare function writeAgentsToConfig(agents: string[], projectRoot: string): void;
+export declare function readClaudeModsFromConfig(projectRoot: string): string[];
+export declare function writeClaudeModsToConfig(mods: string[], projectRoot: string): void;

package/dist/lib/detect.js

@@ -39,6 +39,8 @@ exports.readAgentsFromConfig = readAgentsFromConfig;
 exports.readOkfEnabledFromConfig = readOkfEnabledFromConfig;
 exports.detectAvailableAgents = detectAvailableAgents;
 exports.writeAgentsToConfig = writeAgentsToConfig;
+exports.readClaudeModsFromConfig = readClaudeModsFromConfig;
+exports.writeClaudeModsToConfig = writeClaudeModsToConfig;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const yaml = __importStar(require("js-yaml"));
@@ -90,6 +92,8 @@ function detectAvailableAgents(projectRoot) {
         detected.push('qwen');
     if (fs.existsSync(path.join(projectRoot, '.kimi')))
         detected.push('kimi');
+    if (fs.existsSync(path.join(projectRoot, '.dsh')))
+        detected.push('dsh');
     return detected;
 }
 function writeAgentsToConfig(agents, projectRoot) {
@@ -101,3 +105,21 @@ function writeAgentsToConfig(agents, projectRoot) {
     config['agents'] = agents;
     fs.writeFileSync(configPath, yaml.dump(config, { indent: 2 }), 'utf-8');
 }
+function readClaudeModsFromConfig(projectRoot) {
+    const configPath = path.join(projectRoot, 'oprim', 'config.yaml');
+    if (!fs.existsSync(configPath))
+        return [];
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const config = yaml.load(content);
+    const mods = config?.['claude_mods'];
+    return Array.isArray(mods) ? mods : [];
+}
+function writeClaudeModsToConfig(mods, projectRoot) {
+    const configPath = path.join(projectRoot, 'oprim', 'config.yaml');
+    if (!fs.existsSync(configPath))
+        return;
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const config = yaml.load(content);
+    config['claude_mods'] = mods;
+    fs.writeFileSync(configPath, yaml.dump(config, { indent: 2 }), 'utf-8');
+}

package/dist/lib/install-agent.d.ts

@@ -1,8 +1,20 @@
-export type Agent = 'claude' | 'cursor' | 'codex' | 'gemini' | 'poolside' | 'vibe' | 'qwen' | 'kimi';
+export type Agent = 'claude' | 'cursor' | 'codex' | 'gemini' | 'poolside' | 'vibe' | 'qwen' | 'kimi' | 'dsh';
 export declare const SUPPORTED_AGENTS: readonly Agent[];
 export declare function promptFrameworkSelection(projectRoot: string): Promise<string>;
 export declare function resolveSpecFramework(projectRoot: string): string;
 export declare function promptAgentSelection(projectRoot: string): Promise<string[]>;
+export declare function promptClaudeModsSelection(preChecked: string[]): Promise<string[]>;
+export declare function isFunctionHooksActive(projectRoot: string): boolean;
+export declare function promptEnableFunctionHooks(): Promise<boolean>;
+export declare function enableFunctionHooks(projectRoot: string): void;
+export declare function printManualFunctionHooksActivation(): void;
+/**
+ * Merges newly-selected mods' hookFiles into .claude/settings.json (additive, non-clobbering —
+ * same convention as mergeClaudeSettingsHooks) and removes deselected mods' entries, writing/
+ * deleting each mod's hook script file(s) to match. Persists the resulting selection to
+ * oprim/config.yaml's claude_mods key.
+ */
+export declare function applyClaudeModsSelection(projectRoot: string, selectedIds: string[], previousIds: string[]): void;
 export declare function promptPdrSurfacing(): Promise<boolean>;
 export declare function promptOkfFrontmatter(): Promise<boolean>;
 export declare function installAgentSkills(agent: Agent, projectRoot: string, framework?: string, pdrSurfacing?: boolean): void;
@@ -13,6 +25,7 @@ export declare const POOLSIDE_SKILLS: Record<string, string>;
 export declare const VIBE_SKILLS: Record<string, string>;
 export declare const QWEN_SKILLS: Record<string, string>;
 export declare const KIMI_SKILLS: Record<string, string>;
+export declare const DSH_SKILLS: Record<string, string>;
 export declare const CURSOR_SKILLS: Record<string, string>;
 export declare const CURSOR_COMMANDS: Record<string, string>;
 export declare function specAuthoringSkill(): string;
@@ -23,3 +36,4 @@ export declare function poolsideInstructions(): string;
 export declare function vibeInstructions(): string;
 export declare function qwenInstructions(): string;
 export declare function kimiInstructions(): string;
+export declare function dshInstructions(): string;

package/dist/lib/install-agent.js

@@ -36,10 +36,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CURSOR_COMMANDS = exports.CURSOR_SKILLS = exports.KIMI_SKILLS = exports.QWEN_SKILLS = exports.VIBE_SKILLS = exports.POOLSIDE_SKILLS = exports.CLAUDE_COMMANDS = exports.CLAUDE_SKILLS = exports.OPRIM_CONTEXT_SKILL_STEP = exports.SUPPORTED_AGENTS = void 0;
+exports.CURSOR_COMMANDS = exports.CURSOR_SKILLS = exports.DSH_SKILLS = exports.KIMI_SKILLS = exports.QWEN_SKILLS = exports.VIBE_SKILLS = exports.POOLSIDE_SKILLS = exports.CLAUDE_COMMANDS = exports.CLAUDE_SKILLS = exports.OPRIM_CONTEXT_SKILL_STEP = exports.SUPPORTED_AGENTS = void 0;
 exports.promptFrameworkSelection = promptFrameworkSelection;
 exports.resolveSpecFramework = resolveSpecFramework;
 exports.promptAgentSelection = promptAgentSelection;
+exports.promptClaudeModsSelection = promptClaudeModsSelection;
+exports.isFunctionHooksActive = isFunctionHooksActive;
+exports.promptEnableFunctionHooks = promptEnableFunctionHooks;
+exports.enableFunctionHooks = enableFunctionHooks;
+exports.printManualFunctionHooksActivation = printManualFunctionHooksActivation;
+exports.applyClaudeModsSelection = applyClaudeModsSelection;
 exports.promptPdrSurfacing = promptPdrSurfacing;
 exports.promptOkfFrontmatter = promptOkfFrontmatter;
 exports.installAgentSkills = installAgentSkills;
@@ -51,6 +57,7 @@ exports.poolsideInstructions = poolsideInstructions;
 exports.vibeInstructions = vibeInstructions;
 exports.qwenInstructions = qwenInstructions;
 exports.kimiInstructions = kimiInstructions;
+exports.dshInstructions = dshInstructions;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const chalk_1 = __importDefault(require("chalk"));
@@ -59,6 +66,7 @@ const detect_1 = require("./detect");
 const config_merge_1 = require("./config-merge");
 const workflow_schema_1 = require("./workflow-schema");
 const workflow_renderer_1 = require("./workflow-renderer");
+const claude_mods_1 = require("./claude-mods");
 exports.SUPPORTED_AGENTS = [
     'claude',
     'cursor',
@@ -68,6 +76,7 @@ exports.SUPPORTED_AGENTS = [
     'vibe',
     'qwen',
     'kimi',
+    'dsh',
 ];
 // oprim/config.yaml (via integrations.spec_framework) is the source of truth for the
 // selected speccing framework; .claude/hooks/config.json is checked only as a fallback for
@@ -139,9 +148,144 @@ async function promptAgentSelection(projectRoot) {
             { name: 'Mistral Vibe', value: 'vibe', checked: detected.includes('vibe') },
             { name: 'Qwen Code', value: 'qwen', checked: detected.includes('qwen') },
             { name: 'Kimi CLI', value: 'kimi', checked: detected.includes('kimi') },
+            { name: 'DeepSeek Harness', value: 'dsh', checked: detected.includes('dsh') },
         ],
     });
 }
+// ─── claude-mods ───────────────────────────────────────────────────────────
+async function promptClaudeModsSelection(preChecked) {
+    const { checkbox } = await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
+    return checkbox({
+        message: 'Which Claude Code mods should be installed?',
+        choices: claude_mods_1.CLAUDE_MODS_REGISTRY.map((mod) => ({
+            name: `${mod.title} — ${mod.description}`,
+            value: mod.id,
+            checked: preChecked.includes(mod.id),
+        })),
+    });
+}
+function isFunctionHooksActive(projectRoot) {
+    if (process.env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS)
+        return true;
+    const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
+    if (!fs.existsSync(settingsPath))
+        return false;
+    try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        const env = settings.env;
+        return Boolean(env?.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS);
+    }
+    catch {
+        return false;
+    }
+}
+async function promptEnableFunctionHooks() {
+    const { confirm } = await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
+    return confirm({ message: 'Enable Claude Code function hooks now? (y/n)', default: true });
+}
+function enableFunctionHooks(projectRoot) {
+    const settingsPath = path.join(projectRoot, '.claude', 'settings.json');
+    const settings = readSettings(settingsPath);
+    if (!settings.env)
+        settings.env = {};
+    settings.env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS = '1';
+    writeSettings(settingsPath, settings);
+}
+function printManualFunctionHooksActivation() {
+    console.log(chalk_1.default.yellow('  Function hooks are not active.') +
+        ' Selected mod(s) will no-op until you either:\n' +
+        '    - set CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 in your shell environment, or\n' +
+        '    - add an "env": { "CLAUDE_CODE_ENABLE_FUNCTION_HOOKS": "1" } block to .claude/settings.json');
+}
+function readSettings(settingsPath) {
+    if (!fs.existsSync(settingsPath))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeSettings(settingsPath, settings) {
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+}
+function addModHookToSettings(settings, hookFile) {
+    if (!settings.hooks)
+        settings.hooks = {};
+    const hooks = settings.hooks;
+    if (!hooks[hookFile.event])
+        hooks[hookFile.event] = [];
+    const entries = hooks[hookFile.event];
+    const present = entries.some((entry) => {
+        const entryHooks = entry.hooks;
+        return entryHooks?.some((h) => h.command === hookFile.command);
+    });
+    if (!present) {
+        const entry = { hooks: [{ type: 'command', command: hookFile.command }] };
+        if (hookFile.matcher)
+            entry.matcher = hookFile.matcher;
+        entries.push(entry);
+    }
+}
+function removeModHookFromSettings(settings, hookFile) {
+    const hooks = settings.hooks;
+    if (!hooks || !hooks[hookFile.event])
+        return;
+    const entries = hooks[hookFile.event];
+    const filtered = entries.filter((entry) => {
+        const entryHooks = entry.hooks;
+        return !entryHooks?.some((h) => h.command === hookFile.command);
+    });
+    if (filtered.length === 0) {
+        delete hooks[hookFile.event];
+    }
+    else {
+        hooks[hookFile.event] = filtered;
+    }
+}
+/**
+ * Merges newly-selected mods' hookFiles into .claude/settings.json (additive, non-clobbering —
+ * same convention as mergeClaudeSettingsHooks) and removes deselected mods' entries, writing/
+ * deleting each mod's hook script file(s) to match. Persists the resulting selection to
+ * oprim/config.yaml's claude_mods key.
+ */
+function applyClaudeModsSelection(projectRoot, selectedIds, previousIds) {
+    const claudeDir = path.join(projectRoot, '.claude');
+    const hooksDir = path.join(claudeDir, 'hooks');
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    const settings = readSettings(settingsPath);
+    const added = selectedIds.filter((id) => !previousIds.includes(id));
+    const removed = previousIds.filter((id) => !selectedIds.includes(id));
+    for (const id of added) {
+        const mod = (0, claude_mods_1.getClaudeMod)(id);
+        if (!mod)
+            continue;
+        for (const hookFile of mod.hookFiles) {
+            const scriptPath = path.join(hooksDir, hookFile.filename);
+            (0, scaffold_1.writeFile)(scriptPath, hookFile.content);
+            fs.chmodSync(scriptPath, 0o755);
+            addModHookToSettings(settings, hookFile);
+            console.log(chalk_1.default.green('✓') + ` .claude/hooks/${hookFile.filename} (${mod.title})`);
+        }
+    }
+    for (const id of removed) {
+        const mod = (0, claude_mods_1.getClaudeMod)(id);
+        if (!mod)
+            continue;
+        for (const hookFile of mod.hookFiles) {
+            const scriptPath = path.join(hooksDir, hookFile.filename);
+            if (fs.existsSync(scriptPath))
+                fs.unlinkSync(scriptPath);
+            removeModHookFromSettings(settings, hookFile);
+            console.log(chalk_1.default.dim(`  removed .claude/hooks/${hookFile.filename} (${mod.title})`));
+        }
+    }
+    if (added.length > 0 || removed.length > 0) {
+        writeSettings(settingsPath, settings);
+    }
+    (0, detect_1.writeClaudeModsToConfig)(selectedIds, projectRoot);
+}
 async function promptPdrSurfacing() {
     const { confirm } = await Promise.resolve().then(() => __importStar(require('@inquirer/prompts')));
     return confirm({ message: 'Enable proactive PDR surfacing in skills? (Y/n)', default: true });
@@ -360,6 +504,37 @@ function installAgentSkills(agent, projectRoot, framework = 'openspec', pdrSurfa
             console.log(chalk_1.default.dim('  .qwen/ created — Qwen Code will discover these files automatically.'));
         }
     }
+    else if (agent === 'dsh') {
+        const dshDir = path.join(projectRoot, '.dsh');
+        const dirCreated = !fs.existsSync(dshDir);
+        const skillsBase = path.join(dshDir, 'skills');
+        for (const id of POOLSIDE_SKILL_WORKFLOW_IDS) {
+            const schema = (0, workflow_schema_1.loadWorkflowSchema)(id, projectRoot);
+            if (!schema.dsh.skill || !schema.skillName)
+                continue;
+            (0, scaffold_1.writeFile)(path.join(skillsBase, schema.skillName, 'SKILL.md'), (0, workflow_renderer_1.renderSkillBody)(id, projectRoot));
+            console.log(chalk_1.default.green('✓') + ` .dsh/skills/${schema.skillName}/SKILL.md`);
+        }
+        const dshSpecSkillPath = path.join(skillsBase, 'oprim-spec', 'SKILL.md');
+        if (framework === 'native') {
+            (0, scaffold_1.writeFile)(dshSpecSkillPath, (0, workflow_renderer_1.renderSkillBody)('spec-authoring', projectRoot));
+            console.log(chalk_1.default.green('✓') + ' .dsh/skills/oprim-spec/SKILL.md');
+        }
+        else if (fs.existsSync(dshSpecSkillPath)) {
+            fs.unlinkSync(dshSpecSkillPath);
+            try {
+                fs.rmdirSync(path.dirname(dshSpecSkillPath));
+            }
+            catch { /* not empty or already gone */ }
+            console.log(chalk_1.default.dim('  removed .dsh/skills/oprim-spec/SKILL.md'));
+        }
+        const agentsFile = path.join(projectRoot, 'AGENTS.md');
+        writeAgentInstructionFile(agentsFile, dshInstructions());
+        console.log(chalk_1.default.green('✓') + ' AGENTS.md (oprim section written)');
+        if (dirCreated) {
+            console.log(chalk_1.default.dim('  .dsh/ created — DeepSeek Harness will discover these files automatically.'));
+        }
+    }
     else if (agent === 'kimi') {
         // Kimi CLI is a split-path install: .kimi/ is the detection signal, but skills are
         // discovered from a project-root .skills/ directory, not .kimi/skills/ — see
@@ -573,6 +748,10 @@ exports.KIMI_SKILLS = Object.fromEntries(POOLSIDE_SKILL_WORKFLOW_IDS.map((id) =>
     const schema = (0, workflow_schema_1.loadWorkflowSchema)(id);
     return [schema.skillName, (0, workflow_renderer_1.renderSkillBody)(id)];
 }));
+exports.DSH_SKILLS = Object.fromEntries(POOLSIDE_SKILL_WORKFLOW_IDS.map((id) => {
+    const schema = (0, workflow_schema_1.loadWorkflowSchema)(id);
+    return [schema.skillName, (0, workflow_renderer_1.renderSkillBody)(id)];
+}));
 exports.CURSOR_SKILLS = Object.fromEntries(CURSOR_SKILL_WORKFLOW_IDS.map((id) => {
     const schema = (0, workflow_schema_1.loadWorkflowSchema)(id);
     return [schema.skillName, (0, workflow_renderer_1.renderSkillBody)(id)];
@@ -773,3 +952,6 @@ function qwenInstructions() {
 function kimiInstructions() {
     return (0, workflow_renderer_1.renderAgentInstructions)();
 }
+function dshInstructions() {
+    return (0, workflow_renderer_1.renderAgentInstructions)();
+}

package/dist/lib/templates.js

@@ -10,6 +10,7 @@ function configTemplate(projectName, openspecEnabled, graphifyEnabled, okfEnable
 project:
   name: "${projectName}"
 agents: []
+claude_mods: []
 integrations:
   openspec:
     enabled: ${openspecEnabled}

package/dist/lib/workflow-schema.d.ts

@@ -22,6 +22,9 @@ export interface WorkflowSchema {
     kimi: {
         skill: boolean;
     };
+    dsh: {
+        skill: boolean;
+    };
     inline: boolean;
     variants: string[] | null;
 }

package/dist/lib/workflow-schema.js

@@ -68,12 +68,14 @@ function parseSchema(raw, filePath) {
     const claude = requireField(obj, 'claude', filePath);
     const cursor = requireField(obj, 'cursor', filePath);
     const poolside = requireField(obj, 'poolside', filePath);
-    // vibe/qwen/kimi are optional and mirror poolside by default — see mistral-vibe-agent-support,
-    // qwen-code-agent-support, and kimi-cli-agent-support specs. This keeps existing bundled/forked
-    // schemas (none declare a `vibe:`/`qwen:`/`kimi:` key) working unchanged.
+    // vibe/qwen/kimi/dsh are optional and mirror poolside by default — see mistral-vibe-agent-support,
+    // qwen-code-agent-support, kimi-cli-agent-support, and deepseek-harness-agent-support specs. This
+    // keeps existing bundled/forked schemas (none declare a `vibe:`/`qwen:`/`kimi:`/`dsh:` key) working
+    // unchanged.
     const vibe = obj.vibe ?? poolside;
     const qwen = obj.qwen ?? poolside;
     const kimi = obj.kimi ?? poolside;
+    const dsh = obj.dsh ?? poolside;
     requireField(obj, 'inline', filePath);
     return {
         id: obj.id,
@@ -87,6 +89,7 @@ function parseSchema(raw, filePath) {
         vibe: { skill: Boolean(vibe.skill) },
         qwen: { skill: Boolean(qwen.skill) },
         kimi: { skill: Boolean(kimi.skill) },
+        dsh: { skill: Boolean(dsh.skill) },
         inline: Boolean(obj.inline),
         variants: obj.variants ?? null,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-product-primer/cli",
-  "version": "2.9.0",
+  "version": "2.11.0",
   "description": "Open Product Primer CLI — product decisions, sequencing, and KPI tracking for repositories",
   "keywords": [
     "product",