@doingdev/opencode-claude-manager-plugin 0.1.35 → 0.1.43

package/dist/claude/claude-agent-sdk-adapter.js

@@ -162,6 +162,7 @@ export class ClaudeAgentSdkAdapter {
             forkSession: input.forkSession,
             persistSession: input.persistSession,
             includePartialMessages: input.includePartialMessages,
+            enableFileCheckpointing: false,
             settingSources: input.settingSources,
             maxTurns: input.maxTurns,
             model: input.model,

package/dist/manager/git-operations.d.ts

@@ -2,10 +2,19 @@ import type { GitDiffResult, GitOperationResult } from '../types/contracts.js';
 export declare class GitOperations {
     private readonly cwd;
     constructor(cwd: string);
-    diff(): Promise<GitDiffResult>;
+    diff(options?: {
+        paths?: string[];
+        staged?: boolean;
+        ref?: string;
+    }): Promise<GitDiffResult>;
     diffStat(): Promise<string>;
     commit(message: string): Promise<GitOperationResult>;
     resetHard(): Promise<GitOperationResult>;
+    status(): Promise<{
+        output: string;
+        isClean: boolean;
+    }>;
+    log(count?: number): Promise<string>;
     currentBranch(): Promise<string>;
     recentCommits(count?: number): Promise<string>;
     private git;

package/dist/manager/git-operations.js

@@ -6,10 +6,15 @@ export class GitOperations {
     constructor(cwd) {
         this.cwd = cwd;
     }
-    async diff() {
+    async diff(options = {}) {
+        const ref = options.staged ? '--cached' : (options.ref ?? 'HEAD');
+        const args = ['diff', ref];
+        if (options.paths && options.paths.length > 0) {
+            args.push('--', ...options.paths);
+        }
         const [diffText, statOutput] = await Promise.all([
-            this.git(['diff', 'HEAD']),
-            this.git(['diff', 'HEAD', '--stat']),
+            this.git(args),
+            this.git([...args, '--stat']),
         ]);
         const stats = parseStatLine(statOutput);
         return {
@@ -50,6 +55,16 @@ export class GitOperations {
             };
         }
     }
+    async status() {
+        const output = await this.git(['status', '-s']);
+        return {
+            output,
+            isClean: output.trim().length === 0,
+        };
+    }
+    async log(count = 5) {
+        return this.git(['log', '--oneline', `-${count}`]);
+    }
     async currentBranch() {
         const branch = await this.git(['rev-parse', '--abbrev-ref', 'HEAD']);
         return branch.trim();

package/dist/manager/persistent-manager.d.ts

@@ -21,6 +21,7 @@ export declare class PersistentManager {
         model?: string;
         effort?: 'low' | 'medium' | 'high' | 'max';
         mode?: 'plan' | 'free';
+        sessionSystemPrompt?: string;
         abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<{
         sessionId: string | undefined;
@@ -35,11 +36,26 @@ export declare class PersistentManager {
     /**
      * Get the current git diff.
      */
-    gitDiff(): Promise<GitDiffResult>;
+    gitDiff(options?: {
+        paths?: string[];
+        staged?: boolean;
+        ref?: string;
+    }): Promise<GitDiffResult>;
     /**
      * Commit all current changes.
      */
     gitCommit(message: string): Promise<GitOperationResult>;
+    /**
+     * Get git status summary.
+     */
+    gitStatus(): Promise<{
+        output: string;
+        isClean: boolean;
+    }>;
+    /**
+     * Get recent commit log.
+     */
+    gitLog(count?: number): Promise<string>;
     /**
      * Hard reset to discard all uncommitted changes.
      */
@@ -51,7 +67,7 @@ export declare class PersistentManager {
     /**
      * Clear the active session. Next send creates a fresh one.
      */
-    clearSession(cwd: string): Promise<string | null>;
+    clearSession(): Promise<string | null>;
     /**
      * Compact the current session to free context.
      */
@@ -70,7 +86,7 @@ export declare class PersistentManager {
     /**
      * Try to restore session state from disk on startup.
      */
-    tryRestore(cwd: string): Promise<boolean>;
+    tryRestore(): Promise<boolean>;
     listRuns(cwd: string): Promise<PersistentRunRecord[]>;
     getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
 }

package/dist/manager/persistent-manager.js

@@ -17,7 +17,7 @@ export class PersistentManager {
      * Creates a new session if none exists.
      */
     async sendMessage(cwd, message, options, onEvent) {
-        const result = await this.sessionController.sendMessage(cwd, message, options, onEvent);
+        const result = await this.sessionController.sendMessage(message, options, onEvent);
         if (result.sessionId && result.events.length > 0) {
             await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
         }
@@ -35,8 +35,8 @@ export class PersistentManager {
     /**
      * Get the current git diff.
      */
-    async gitDiff() {
-        return this.gitOps.diff();
+    async gitDiff(options = {}) {
+        return this.gitOps.diff(options);
     }
     /**
      * Commit all current changes.
@@ -44,6 +44,18 @@ export class PersistentManager {
     async gitCommit(message) {
         return this.gitOps.commit(message);
     }
+    /**
+     * Get git status summary.
+     */
+    async gitStatus() {
+        return this.gitOps.status();
+    }
+    /**
+     * Get recent commit log.
+     */
+    async gitLog(count = 5) {
+        return this.gitOps.log(count);
+    }
     /**
      * Hard reset to discard all uncommitted changes.
      */
@@ -59,14 +71,14 @@ export class PersistentManager {
     /**
      * Clear the active session. Next send creates a fresh one.
      */
-    async clearSession(cwd) {
-        return this.sessionController.clearSession(cwd);
+    async clearSession() {
+        return this.sessionController.clearSession();
     }
     /**
      * Compact the current session to free context.
      */
     async compactSession(cwd, onEvent) {
-        const result = await this.sessionController.compactSession(cwd, onEvent);
+        const result = await this.sessionController.compactSession(onEvent);
         if (result.sessionId && result.events.length > 0) {
             await this.transcriptStore.appendEvents(cwd, result.sessionId, result.events);
         }
@@ -108,7 +120,7 @@ export class PersistentManager {
         await this.stateStore.saveRun(runRecord);
         await onProgress?.(runRecord);
         try {
-            const result = await this.sessionController.sendMessage(cwd, task, options, async (event) => {
+            const result = await this.sessionController.sendMessage(task, options, async (event) => {
                 // Update run record with progress events
                 const currentRun = await this.stateStore.getRun(cwd, runId);
                 if (currentRun) {
@@ -158,8 +170,8 @@ export class PersistentManager {
     /**
      * Try to restore session state from disk on startup.
      */
-    async tryRestore(cwd) {
-        return this.sessionController.tryRestore(cwd);
+    async tryRestore() {
+        return this.sessionController.tryRestore();
     }
     listRuns(cwd) {
         return this.stateStore.listRuns(cwd);

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

@@ -5,9 +5,11 @@ export declare class SessionController {
     private readonly sdkAdapter;
     private readonly contextTracker;
     private readonly sessionPrompt;
+    private readonly wrapperType;
+    private readonly worktree;
     private readonly modePrefixes;
     private activeSessionId;
-    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string, modePrefixes?: {
+    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string | undefined, wrapperType: string, worktree: string, modePrefixes?: {
         plan: string;
         free: string;
     });
@@ -17,20 +19,21 @@ export declare class SessionController {
      * Send a message to the persistent session. Creates one if none exists.
      * Returns the session result including usage data.
      */
-    sendMessage(cwd: string, message: string, options?: {
+    sendMessage(message: string, options?: {
         model?: string;
         effort?: 'low' | 'medium' | 'high' | 'max';
         mode?: SessionMode;
+        sessionSystemPrompt?: string;
         abortSignal?: AbortSignal;
     }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     /**
      * Send /compact to the current session to compress context.
      */
-    compactSession(cwd: string, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
+    compactSession(onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
     /**
      * Clear the current session. The next sendMessage will create a fresh one.
      */
-    clearSession(cwd: string): Promise<string | null>;
+    clearSession(): Promise<string | null>;
     /**
      * Get current context tracking snapshot.
      */
@@ -38,7 +41,7 @@ export declare class SessionController {
     /**
      * Try to restore active session from persisted state on startup.
      */
-    tryRestore(cwd: string): Promise<boolean>;
+    tryRestore(): Promise<boolean>;
     private persistActiveSession;
     private removeActiveSession;
 }

package/dist/manager/session-controller.js

@@ -1,19 +1,25 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-const ACTIVE_SESSION_FILE = '.claude-manager/active-session.json';
+import { dirname } from 'node:path';
+function activeSessionFile(_wrapperType) {
+    return `.claude-manager/active-session.json`;
+}
 export class SessionController {
     sdkAdapter;
     contextTracker;
     sessionPrompt;
+    wrapperType;
+    worktree;
     modePrefixes;
     activeSessionId = null;
-    constructor(sdkAdapter, contextTracker, sessionPrompt, modePrefixes = {
+    constructor(sdkAdapter, contextTracker, sessionPrompt, wrapperType, worktree, modePrefixes = {
         plan: '',
         free: '',
     }) {
         this.sdkAdapter = sdkAdapter;
         this.contextTracker = contextTracker;
         this.sessionPrompt = sessionPrompt;
+        this.wrapperType = wrapperType;
+        this.worktree = worktree;
         this.modePrefixes = modePrefixes;
     }
     get isActive() {
@@ -26,12 +32,12 @@ export class SessionController {
      * Send a message to the persistent session. Creates one if none exists.
      * Returns the session result including usage data.
      */
-    async sendMessage(cwd, message, options, onEvent) {
+    async sendMessage(message, options, onEvent) {
         const mode = options?.mode ?? 'free';
         const prefix = this.modePrefixes[mode];
         const prompt = prefix ? `${prefix}\n\n${message}` : message;
         const input = {
-            cwd,
+            cwd: this.worktree,
             prompt,
             persistSession: true,
             permissionMode: mode === 'plan' ? 'plan' : 'acceptEdits',
@@ -46,8 +52,8 @@ export class SessionController {
             input.resumeSessionId = this.activeSessionId;
         }
         else {
-            // New session — use the base session prompt (project context is in the wrapper)
-            input.systemPrompt = this.sessionPrompt;
+            // New session — prefer dynamically constructed prompt from wrapper, fall back to static default
+            input.systemPrompt = options?.sessionSystemPrompt ?? this.sessionPrompt;
             input.model ??= 'claude-opus-4-6';
             input.effort ??= 'high';
         }
@@ -66,28 +72,28 @@ export class SessionController {
             contextWindowSize: result.contextWindowSize,
         });
         // Persist active session state
-        await this.persistActiveSession(cwd);
+        await this.persistActiveSession();
         return result;
     }
     /**
      * Send /compact to the current session to compress context.
      */
-    async compactSession(cwd, onEvent) {
+    async compactSession(onEvent) {
         if (!this.activeSessionId) {
             throw new Error('No active session to compact');
         }
-        const result = await this.sendMessage(cwd, '/compact', undefined, onEvent);
+        const result = await this.sendMessage('/compact', undefined, onEvent);
         this.contextTracker.recordCompaction();
         return result;
     }
     /**
      * Clear the current session. The next sendMessage will create a fresh one.
      */
-    async clearSession(cwd) {
+    async clearSession() {
         const clearedId = this.activeSessionId;
         this.activeSessionId = null;
         this.contextTracker.reset();
-        await this.removeActiveSession(cwd);
+        await this.removeActiveSession();
         return clearedId;
     }
     /**
@@ -99,12 +105,12 @@ export class SessionController {
     /**
      * Try to restore active session from persisted state on startup.
      */
-    async tryRestore(cwd) {
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
+    async tryRestore() {
+        const filePath = activeSessionFile(this.wrapperType);
         try {
             const raw = await readFile(filePath, 'utf-8');
             const state = JSON.parse(raw);
-            if (state.sessionId && state.cwd === cwd) {
+            if (state.sessionId) {
                 this.activeSessionId = state.sessionId;
                 this.contextTracker.restore(state);
                 return true;
@@ -115,14 +121,13 @@ export class SessionController {
         }
         return false;
     }
-    async persistActiveSession(cwd) {
+    async persistActiveSession() {
         if (!this.activeSessionId) {
             return;
         }
         const snap = this.contextTracker.snapshot();
         const state = {
             sessionId: this.activeSessionId,
-            cwd,
             startedAt: new Date().toISOString(),
             totalTurns: snap.totalTurns,
             totalCostUsd: snap.totalCostUsd,
@@ -130,12 +135,12 @@ export class SessionController {
             contextWindowSize: snap.contextWindowSize,
             latestInputTokens: snap.latestInputTokens,
         };
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
+        const filePath = activeSessionFile(this.wrapperType);
         await mkdir(dirname(filePath), { recursive: true });
         await writeFile(filePath, JSON.stringify(state, null, 2));
     }
-    async removeActiveSession(cwd) {
-        const filePath = join(cwd, ACTIVE_SESSION_FILE);
+    async removeActiveSession() {
+        const filePath = activeSessionFile(this.wrapperType);
         try {
             const { unlink } = await import('node:fs/promises');
             await unlink(filePath);

package/dist/metadata/claude-metadata.service.d.ts

@@ -0,0 +1,12 @@
+import type { ClaudeMetadataSnapshot, ClaudeSettingSource } from '../types/contracts.js';
+import type { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
+import type { RepoClaudeConfigReader } from './repo-claude-config-reader.js';
+export declare class ClaudeMetadataService {
+    private readonly configReader;
+    private readonly sdkAdapter;
+    constructor(configReader: RepoClaudeConfigReader, sdkAdapter: ClaudeAgentSdkAdapter);
+    collect(cwd: string, options?: {
+        includeSdkProbe?: boolean;
+        settingSources?: ClaudeSettingSource[];
+    }): Promise<ClaudeMetadataSnapshot>;
+}

package/dist/metadata/claude-metadata.service.js

@@ -0,0 +1,38 @@
+export class ClaudeMetadataService {
+    configReader;
+    sdkAdapter;
+    constructor(configReader, sdkAdapter) {
+        this.configReader = configReader;
+        this.sdkAdapter = sdkAdapter;
+    }
+    async collect(cwd, options = {}) {
+        const baseSnapshot = await this.configReader.read(cwd);
+        if (!options.includeSdkProbe) {
+            return dedupeSnapshot(baseSnapshot);
+        }
+        const capabilities = await this.sdkAdapter.probeCapabilities(cwd, options.settingSources);
+        return dedupeSnapshot({
+            ...baseSnapshot,
+            commands: [...baseSnapshot.commands, ...capabilities.commands],
+            agents: capabilities.agents,
+        });
+    }
+}
+function dedupeSnapshot(snapshot) {
+    return {
+        ...snapshot,
+        commands: dedupeByName(snapshot.commands),
+        skills: dedupeByName(snapshot.skills),
+        hooks: dedupeByName(snapshot.hooks),
+        agents: dedupeByName(snapshot.agents),
+    };
+}
+function dedupeByName(items) {
+    const seen = new Map();
+    for (const item of items) {
+        if (!seen.has(item.name)) {
+            seen.set(item.name, item);
+        }
+    }
+    return [...seen.values()].sort((left, right) => left.name.localeCompare(right.name));
+}

package/dist/metadata/repo-claude-config-reader.d.ts

@@ -0,0 +1,7 @@
+import type { ClaudeMetadataSnapshot } from '../types/contracts.js';
+export declare class RepoClaudeConfigReader {
+    read(cwd: string): Promise<ClaudeMetadataSnapshot>;
+    private readSkills;
+    private readCommands;
+    private readSettings;
+}

package/dist/metadata/repo-claude-config-reader.js

@@ -0,0 +1,154 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import JSON5 from 'json5';
+export class RepoClaudeConfigReader {
+    async read(cwd) {
+        const claudeDirectory = path.join(cwd, '.claude');
+        const skillsDirectory = path.join(claudeDirectory, 'skills');
+        const commandsDirectory = path.join(claudeDirectory, 'commands');
+        const claudeMdCandidates = [
+            path.join(cwd, 'CLAUDE.md'),
+            path.join(claudeDirectory, 'CLAUDE.md'),
+        ];
+        const collectedAt = new Date().toISOString();
+        const [skills, commands, settingsResult, claudeMdPath] = await Promise.all([
+            this.readSkills(skillsDirectory),
+            this.readCommands(commandsDirectory),
+            this.readSettings(claudeDirectory),
+            findFirstExistingPath(claudeMdCandidates),
+        ]);
+        return {
+            collectedAt,
+            cwd,
+            commands: [...skillsToCommands(skills), ...commands],
+            skills,
+            hooks: settingsResult.hooks,
+            agents: [],
+            claudeMdPath: claudeMdPath ?? undefined,
+            settingsPaths: settingsResult.settingsPaths,
+        };
+    }
+    async readSkills(directory) {
+        if (!(await pathExists(directory))) {
+            return [];
+        }
+        const entries = await fs.readdir(directory, { withFileTypes: true });
+        const skills = await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            const skillPath = path.join(directory, entry.name, 'SKILL.md');
+            if (!(await pathExists(skillPath))) {
+                return null;
+            }
+            const content = await fs.readFile(skillPath, 'utf8');
+            return {
+                name: entry.name,
+                description: extractMarkdownDescription(content),
+                path: skillPath,
+                source: 'skill',
+            };
+        }));
+        return skills.filter((skill) => skill !== null);
+    }
+    async readCommands(directory) {
+        if (!(await pathExists(directory))) {
+            return [];
+        }
+        const commandFiles = await collectMarkdownFiles(directory);
+        const commands = await Promise.all(commandFiles.map(async (commandPath) => {
+            const content = await fs.readFile(commandPath, 'utf8');
+            return {
+                name: path.basename(commandPath, path.extname(commandPath)),
+                description: extractMarkdownDescription(content),
+                source: 'command',
+                path: commandPath,
+            };
+        }));
+        return commands.sort((left, right) => left.name.localeCompare(right.name));
+    }
+    async readSettings(claudeDirectory) {
+        const candidatePaths = [
+            path.join(claudeDirectory, 'settings.json'),
+            path.join(claudeDirectory, 'settings.local.json'),
+        ];
+        const settingsPaths = [];
+        const hooks = [];
+        for (const candidatePath of candidatePaths) {
+            if (!(await pathExists(candidatePath))) {
+                continue;
+            }
+            settingsPaths.push(candidatePath);
+            const content = await fs.readFile(candidatePath, 'utf8');
+            const parsed = JSON5.parse(content);
+            const hookEntries = Object.entries(parsed.hooks ?? {});
+            for (const [hookName, hookValue] of hookEntries) {
+                const hookMatchers = Array.isArray(hookValue) ? hookValue : [hookValue];
+                for (const hookMatcher of hookMatchers) {
+                    if (!hookMatcher || typeof hookMatcher !== 'object') {
+                        continue;
+                    }
+                    const matcher = typeof hookMatcher.matcher === 'string'
+                        ? hookMatcher.matcher
+                        : undefined;
+                    const commandCount = Array.isArray(hookMatcher.hooks)
+                        ? (hookMatcher.hooks?.length ?? 0)
+                        : 0;
+                    hooks.push({
+                        name: hookName,
+                        matcher,
+                        sourcePath: candidatePath,
+                        commandCount,
+                    });
+                }
+            }
+        }
+        return {
+            settingsPaths,
+            hooks,
+        };
+    }
+}
+function extractMarkdownDescription(markdown) {
+    const lines = markdown
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const descriptionLine = lines.find((line) => !line.startsWith('#') && !line.startsWith('---'));
+    return descriptionLine ?? 'No description provided.';
+}
+async function collectMarkdownFiles(directory) {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const resolvedPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return collectMarkdownFiles(resolvedPath);
+        }
+        return entry.name.endsWith('.md') ? [resolvedPath] : [];
+    }));
+    return files.flat();
+}
+async function pathExists(candidatePath) {
+    try {
+        await fs.access(candidatePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function findFirstExistingPath(candidatePaths) {
+    for (const candidatePath of candidatePaths) {
+        if (await pathExists(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return null;
+}
+function skillsToCommands(skills) {
+    return skills.map((skill) => ({
+        name: skill.name,
+        description: skill.description,
+        source: 'skill',
+        path: skill.path,
+    }));
+}

package/dist/plugin/agent-hierarchy.d.ts

@@ -1,17 +1,17 @@
 /**
  * Agent hierarchy configuration for the CTO + Engineer Wrapper architecture.
  *
- * CTO (cto)                      — pure orchestrator, spawns engineers, reviews diffs, commits
- * Engineer Plan (engineer_plan)   — manages a Claude Code session for read-only investigation
- * Engineer Build (engineer_build) — manages a Claude Code session for implementation
- * Claude Code session             — the underlying AI session (prompt only, no OpenCode agent)
+ * CTO (cto)                            — pure orchestrator, spawns engineers, reviews diffs, commits
+ * Engineer Explore (engineer_explore)   — manages a Claude Code session for read-only investigation
+ * Engineer Implement (engineer_implement) — manages a Claude Code session for implementation
+ * Claude Code session                   — the underlying AI session (prompt only, no OpenCode agent)
  */
 import type { ManagerPromptRegistry } from '../types/contracts.js';
 export declare const AGENT_CTO = "cto";
-export declare const AGENT_ENGINEER_PLAN = "engineer_plan";
-export declare const AGENT_ENGINEER_BUILD = "engineer_build";
+export declare const AGENT_ENGINEER_EXPLORE = "engineer_explore";
+export declare const AGENT_ENGINEER_IMPLEMENT = "engineer_implement";
 /** All restricted tool IDs (union of all domain groups) */
-export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["explore", "implement", "compact_context", "clear_session", "session_health", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "approval_policy", "approval_decisions", "approval_update"];
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["explore", "implement", "compact_context", "clear_session", "session_health", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
 type ToolPermission = 'allow' | 'ask' | 'deny';
 type AgentPermission = {
     '*'?: ToolPermission;
@@ -41,14 +41,14 @@ export declare function buildCtoAgentConfig(prompts: ManagerPromptRegistry): {
     permission: AgentPermission;
     prompt: string;
 };
-export declare function buildEngineerPlanAgentConfig(prompts: ManagerPromptRegistry): {
+export declare function buildEngineerExploreAgentConfig(prompts: ManagerPromptRegistry): {
     description: string;
     mode: "subagent";
     color: string;
     permission: AgentPermission;
     prompt: string;
 };
-export declare function buildEngineerBuildAgentConfig(prompts: ManagerPromptRegistry): {
+export declare function buildEngineerImplementAgentConfig(prompts: ManagerPromptRegistry): {
     description: string;
     mode: "subagent";
     color: string;