@doingdev/opencode-claude-manager-plugin 0.1.32 → 0.1.33

package/dist/manager/session-controller.d.ts

@@ -21,7 +21,6 @@ export declare class SessionController {
         model?: string;
         effort?: 'low' | 'medium' | 'high' | 'max';
         mode?: SessionMode;
-        settingSources?: Array<'user' | 'project' | 'local'>;
         abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     /**

package/dist/manager/session-controller.js

@@ -38,7 +38,7 @@ export class SessionController {
             includePartialMessages: true,
             model: options?.model,
             effort: options?.effort,
-            settingSources: options?.settingSources ?? ['user', 'project', 'local'],
+            settingSources: ['user'],
             abortSignal: options?.abortSignal,
         };
         if (this.activeSessionId) {
@@ -46,7 +46,7 @@ export class SessionController {
             input.resumeSessionId = this.activeSessionId;
         }
         else {
-            // New session — apply the expert operator system prompt and defaults
+            // New session — use the base session prompt (project context is in the wrapper)
             input.systemPrompt = this.sessionPrompt;
             input.model ??= 'claude-opus-4-6';
             input.effort ??= 'high';

package/dist/plugin/agent-hierarchy.js

@@ -87,7 +87,7 @@ function buildCtoPermissions() {
         },
     };
 }
-/** Engineer plan wrapper: engineer_send_plan + shared session tools. */
+/** Engineer plan wrapper: read-only investigation + engineer_send_plan + shared session tools. */
 function buildEngineerPlanPermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
@@ -99,11 +99,12 @@ function buildEngineerPlanPermissions() {
     }
     return {
         '*': 'deny',
+        ...READONLY_TOOLS,
         ...denied,
         ...allowed,
     };
 }
-/** Engineer build wrapper: engineer_send_build + shared session tools. */
+/** Engineer build wrapper: read-only investigation + engineer_send_build + shared session tools. */
 function buildEngineerBuildPermissions() {
     const denied = {};
     for (const toolId of ALL_RESTRICTED_TOOL_IDS) {
@@ -115,6 +116,7 @@ function buildEngineerBuildPermissions() {
     }
     return {
         '*': 'deny',
+        ...READONLY_TOOLS,
         ...denied,
         ...allowed,
     };

package/dist/plugin/claude-manager.plugin.js

@@ -1,5 +1,6 @@
 import { tool } from '@opencode-ai/plugin';
-import { managerPromptRegistry } from '../prompts/registry.js';
+import { composeWrapperPrompt, managerPromptRegistry } from '../prompts/registry.js';
+import { discoverProjectClaudeFiles } from '../util/project-context.js';
 import { AGENT_CTO, AGENT_ENGINEER_BUILD, AGENT_ENGINEER_PLAN, buildCtoAgentConfig, buildEngineerBuildAgentConfig, buildEngineerPlanAgentConfig, denyRestrictedToolsGlobally, } from './agent-hierarchy.js';
 import { getOrCreatePluginServices } from './service-factory.js';
 export const ClaudeManagerPlugin = async ({ worktree }) => {
@@ -183,9 +184,16 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             config.agent ??= {};
             config.permission ??= {};
             denyRestrictedToolsGlobally(config.permission);
+            // Discover project Claude files and build derived wrapper prompts.
+            const claudeFiles = await discoverProjectClaudeFiles(worktree);
+            const derivedPrompts = {
+                ...managerPromptRegistry,
+                engineerPlanPrompt: composeWrapperPrompt(managerPromptRegistry.engineerPlanPrompt, claudeFiles),
+                engineerBuildPrompt: composeWrapperPrompt(managerPromptRegistry.engineerBuildPrompt, claudeFiles),
+            };
             config.agent[AGENT_CTO] ??= buildCtoAgentConfig(managerPromptRegistry);
-            config.agent[AGENT_ENGINEER_PLAN] ??= buildEngineerPlanAgentConfig(managerPromptRegistry);
-            config.agent[AGENT_ENGINEER_BUILD] ??= buildEngineerBuildAgentConfig(managerPromptRegistry);
+            config.agent[AGENT_ENGINEER_PLAN] ??= buildEngineerPlanAgentConfig(derivedPrompts);
+            config.agent[AGENT_ENGINEER_BUILD] ??= buildEngineerBuildAgentConfig(derivedPrompts);
         },
         tool: {
             engineer_send: tool({

package/dist/prompts/registry.d.ts

@@ -1,2 +1,11 @@
-import type { ManagerPromptRegistry } from '../types/contracts.js';
+import type { DiscoveredClaudeFile, ManagerPromptRegistry } from '../types/contracts.js';
+/**
+ * Compose a wrapper agent prompt from the base prompt plus discovered
+ * project Claude files. Returns the base prompt unchanged when no
+ * files are provided.
+ *
+ * Each file is rendered under a clear path-labeled section so the
+ * wrapper agent knows exactly where each instruction came from.
+ */
+export declare function composeWrapperPrompt(basePrompt: string, claudeFiles: DiscoveredClaudeFile[]): string;
 export declare const managerPromptRegistry: ManagerPromptRegistry;

package/dist/prompts/registry.js

@@ -1,7 +1,28 @@
+/**
+ * Compose a wrapper agent prompt from the base prompt plus discovered
+ * project Claude files. Returns the base prompt unchanged when no
+ * files are provided.
+ *
+ * Each file is rendered under a clear path-labeled section so the
+ * wrapper agent knows exactly where each instruction came from.
+ */
+export function composeWrapperPrompt(basePrompt, claudeFiles) {
+    if (claudeFiles.length === 0) {
+        return basePrompt;
+    }
+    const sections = claudeFiles.map((f) => `### ${f.relativePath}\n${f.content}`).join('\n\n');
+    return `${basePrompt}\n\n## Project Claude Files\nThe following project-level instructions were discovered from the repository.\n\n${sections}`;
+}
 export const managerPromptRegistry = {
     ctoSystemPrompt: [
-        'You are a cracked AI-native engineer who uses Claude Code better than anyone.',
-        'You build the right thing, with the right quality, on the first try.',
+        'You are a staff+ technical owner who uses Claude Code better than anyone.',
+        'You own the outcome — discover the right problem before solving it.',
+        '',
+        '## Core principle: technical ownership',
+        'You are not a ticket-taker. Before acting, look for:',
+        '- Hidden assumptions and missing constraints.',
+        '- Ownership issues, abstraction leaks, and better boundaries.',
+        '- Root causes — prefer fixing root causes over patching symptoms.',
         '',
         '## Core principle: verification-first',
         'Every delegation MUST include how to verify success.',
@@ -15,17 +36,30 @@ export const managerPromptRegistry = {
         '**Simple tasks** (typo, rename, add a log line, one-file fix):',
         '  Skip investigation. Delegate directly with specific context.',
         '',
-        '**Medium tasks** (bug fix, small feature, refactor one module):',
-        '  Read the relevant code yourself. Understand the current state.',
+        '**Medium+ tasks** (bug fix, feature, refactor, architecture change):',
+        '  Before delegating, determine:',
+        '  1. What the user asked vs. what is actually needed.',
+        '  2. What is underspecified or conflicting.',
+        '  3. What the cleanest architecture is.',
+        '  4. What should be clarified before proceeding.',
+        '  Read relevant code yourself. Understand the current state.',
         '  Then delegate with file paths, line numbers, patterns, and verification.',
         '',
-        '**Complex tasks** (multi-file feature, architecture change, large refactor):',
+        '**Complex tasks** (multi-file feature, large refactor):',
         '  1. Investigate: read code, grep for patterns, spawn `engineer_plan` to explore.',
-        '  2. If requirements are unclear, ask the user ONE specific question.',
+        '  2. If requirements are unclear, ask the user ONE high-leverage question —',
+        '     only when it materially changes architecture, ownership, or destructive behavior.',
         '     Prefer the question tool when discrete options exist.',
         '  3. Write a plan to the todo list (todowrite). Share it with the user.',
         '  4. Execute steps sequentially, committing after each.',
         '',
+        '## Missed-opportunity check',
+        'Before finalizing any medium+ delegation, check:',
+        '- One cleaner alternative you considered.',
+        '- One risk the current approach carries.',
+        '- One thing the requester likely missed.',
+        'If any of these materially improve the outcome, surface them.',
+        '',
         '## How to delegate effectively',
         'The engineer does not have your context. Every instruction must be self-contained.',
         'Include:',
@@ -87,7 +121,21 @@ export const managerPromptRegistry = {
         'State the blocker, what you need, and a concrete suggestion to unblock.',
     ].join('\n'),
     engineerPlanPrompt: [
-        'You manage a Claude Code engineer for read-only investigation.',
+        'You are a staff engineer managing a Claude Code session for read-only investigation.',
+        'You are not a forwarding layer — interpret the task in repo context before delegating.',
+        '',
+        '## Staff-level framing',
+        '- Identify the real problem, not just the stated request.',
+        '- Look for missing architecture, ownership, or precedence issues before delegating.',
+        '- Rewrite weak or underspecified requests into precise prompts for the engineer.',
+        '- For medium+ tasks, determine: the actual problem, the cleanest architecture,',
+        '  and what needs clarification before work begins.',
+        '- Ask ONE clarification first if it materially improves architecture.',
+        '',
+        '## Repo-context investigation',
+        '- You MAY use read, grep, glob, and other search tools to investigate',
+        '  the repo before delegating. Build context so your delegation is precise.',
+        '- Do NOT implement changes yourself — investigation only.',
         '',
         '## Behavior',
         '- Send the objective to the engineer using engineer_send_plan.',
@@ -103,13 +151,34 @@ export const managerPromptRegistry = {
         '- claude-sonnet-4-6: lighter analysis.',
         '- effort "medium": simple lookups.',
         '',
+        '## Using appended Project Claude Files',
+        '- Treat appended Project Claude Files as project guidance for the engineer.',
+        '- Extract only the rules relevant to the current task when delegating.',
+        '- Prefer guidance from more specific/nested paths over root-level guidance on conflict.',
+        '- Direct user instructions override Claude-file guidance.',
+        '- Keep delegated instructions tight; do not dump the full file corpus unless needed.',
+        '- Cite file paths (e.g. "per packages/core/CLAUDE.md") when the source matters.',
+        '',
         '## What you must NOT do',
-        '- Do NOT investigate on your own — no read, grep, glob, or web tools.',
         '- Do NOT call git_*, approval_*, or any non-engineer tools.',
         '- Do NOT add commentary to the engineer response.',
     ].join('\n'),
     engineerBuildPrompt: [
-        'You manage a Claude Code engineer for implementation.',
+        'You are a staff engineer managing a Claude Code session for implementation.',
+        'You are not a forwarding layer — interpret the task in repo context before delegating.',
+        '',
+        '## Staff-level framing',
+        '- Identify the real problem, not just the stated request.',
+        '- Look for missing architecture, ownership, or precedence issues before delegating.',
+        '- Rewrite weak or underspecified requests into precise prompts for the engineer.',
+        '- For medium+ tasks, determine: the actual problem, the cleanest architecture,',
+        '  and what needs clarification before work begins.',
+        '- Ask ONE clarification first if it materially improves architecture.',
+        '',
+        '## Repo-context investigation',
+        '- You MAY use read, grep, glob, and other search tools to investigate',
+        '  the repo before delegating. Build context so your delegation is precise.',
+        '- Do NOT implement changes yourself — investigation only.',
         '',
         '## Behavior',
         '- Send the objective to the engineer using engineer_send_build.',
@@ -125,8 +194,15 @@ export const managerPromptRegistry = {
         '- claude-sonnet-4-6: simple renames, formatting, scaffolding.',
         '- effort "max": complex refactors, subtle bugs, cross-cutting changes.',
         '',
+        '## Using appended Project Claude Files',
+        '- Treat appended Project Claude Files as project guidance for the engineer.',
+        '- Extract only the rules relevant to the current task when delegating.',
+        '- Prefer guidance from more specific/nested paths over root-level guidance on conflict.',
+        '- Direct user instructions override Claude-file guidance.',
+        '- Keep delegated instructions tight; do not dump the full file corpus unless needed.',
+        '- Cite file paths (e.g. "per packages/core/CLAUDE.md") when the source matters.',
+        '',
         '## What you must NOT do',
-        '- Do NOT investigate on your own — no read, grep, glob, or web tools.',
         '- Do NOT call git_*, approval_*, or any non-engineer tools.',
         '- Do NOT add commentary to the engineer response.',
     ].join('\n'),

package/dist/types/contracts.d.ts

@@ -166,6 +166,12 @@ export interface ToolOutputPreview {
     content: string;
     isError: boolean;
 }
+export interface DiscoveredClaudeFile {
+    /** Relative path from the project root (forward slashes, deterministic order). */
+    relativePath: string;
+    /** Trimmed UTF-8 text content. */
+    content: string;
+}
 export interface ToolApprovalRule {
     id: string;
     description?: string;

package/dist/util/project-context.d.ts

@@ -0,0 +1,10 @@
+import type { DiscoveredClaudeFile } from '../types/contracts.js';
+/**
+ * Recursively discover all project-level Claude files:
+ *   - every `CLAUDE.md` found anywhere in the repo tree
+ *   - every file under `.claude/` recursively
+ *
+ * Returns a de-duplicated, deterministically sorted array of
+ * { relativePath, content } entries. Empty/blank files are skipped.
+ */
+export declare function discoverProjectClaudeFiles(cwd: string): Promise<DiscoveredClaudeFile[]>;

package/dist/util/project-context.js

@@ -0,0 +1,105 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { isFileNotFoundError } from './fs-helpers.js';
+/**
+ * Recursively discover all project-level Claude files:
+ *   - every `CLAUDE.md` found anywhere in the repo tree
+ *   - every file under `.claude/` recursively
+ *
+ * Returns a de-duplicated, deterministically sorted array of
+ * { relativePath, content } entries. Empty/blank files are skipped.
+ */
+export async function discoverProjectClaudeFiles(cwd) {
+    const seen = new Set();
+    const results = [];
+    // 1. Walk the entire tree for CLAUDE.md files.
+    await walkForClaudeMd(cwd, cwd, seen, results);
+    // 2. Walk .claude/ recursively for any file.
+    await walkDotClaudeDir(cwd, seen, results);
+    // Deterministic: sort by relativePath (lexicographic).
+    results.sort((a, b) => a.relativePath < b.relativePath ? -1 : a.relativePath > b.relativePath ? 1 : 0);
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/** Recursively walk `dir` looking for files named `CLAUDE.md`. */
+async function walkForClaudeMd(root, dir, seen, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (isFileNotFoundError(err))
+            return;
+        throw err;
+    }
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // Skip node_modules, .git, and hidden dirs other than .claude
+            if (entry.name === 'node_modules' || entry.name === '.git')
+                continue;
+            await walkForClaudeMd(root, fullPath, seen, out);
+        }
+        else if (entry.name === 'CLAUDE.md') {
+            const rel = toForwardSlash(relative(root, fullPath));
+            if (seen.has(rel))
+                continue;
+            const content = await tryReadText(fullPath);
+            if (content !== null) {
+                seen.add(rel);
+                out.push({ relativePath: rel, content });
+            }
+        }
+    }
+}
+/** Recursively walk `.claude/` and collect every file. */
+async function walkDotClaudeDir(root, seen, out) {
+    const dotClaudeDir = join(root, '.claude');
+    await walkAllFiles(root, dotClaudeDir, seen, out);
+}
+/** Recursively collect all files under `dir`. */
+async function walkAllFiles(root, dir, seen, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (isFileNotFoundError(err))
+            return;
+        throw err;
+    }
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walkAllFiles(root, fullPath, seen, out);
+        }
+        else if (entry.isFile()) {
+            const rel = toForwardSlash(relative(root, fullPath));
+            if (seen.has(rel))
+                continue;
+            const content = await tryReadText(fullPath);
+            if (content !== null) {
+                seen.add(rel);
+                out.push({ relativePath: rel, content });
+            }
+        }
+    }
+}
+/** Read a file as UTF-8, returning trimmed content or null if empty/missing. */
+async function tryReadText(filePath) {
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        const trimmed = raw.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    catch (err) {
+        if (isFileNotFoundError(err))
+            return null;
+        throw err;
+    }
+}
+function toForwardSlash(p) {
+    return p.replace(/\\/g, '/');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",