@doingdev/opencode-claude-manager-plugin 0.1.46 → 0.1.49

package/dist/plugin/service-factory.d.ts

@@ -1,12 +1,29 @@
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
 import { SessionLiveTailer } from '../claude/session-live-tailer.js';
 import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
+import { TeamStateStore } from '../state/team-state-store.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
-interface ClaudeManagerPluginServices {
+import { TeamOrchestrator } from '../manager/team-orchestrator.js';
+import type { DiscoveredClaudeFile, EngineerName } from '../types/contracts.js';
+export interface ClaudeManagerPluginServices {
     manager: PersistentManager;
     sessions: ClaudeSessionService;
     approvalManager: ToolApprovalManager;
     liveTailer: SessionLiveTailer;
+    teamStore: TeamStateStore;
+    orchestrator: TeamOrchestrator;
 }
-export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
-export {};
+export declare function getOrCreatePluginServices(worktree: string, projectClaudeFiles?: DiscoveredClaudeFile[]): ClaudeManagerPluginServices;
+export declare function clearPluginServices(): void;
+export declare function setActiveTeamSession(worktree: string, teamId: string): void;
+export declare function getActiveTeamSession(worktree: string): string | null;
+export declare function getPersistedActiveTeam(worktree: string): Promise<string | null>;
+export declare function setPersistedActiveTeam(worktree: string, teamId: string): Promise<void>;
+export declare function setWrapperSessionMapping(worktree: string, wrapperSessionId: string, mapping: {
+    teamId: string;
+    engineer: EngineerName;
+}): void;
+export declare function getWrapperSessionMapping(worktree: string, wrapperSessionId: string): {
+    teamId: string;
+    engineer: EngineerName;
+} | null;

package/dist/plugin/service-factory.js

@@ -3,13 +3,22 @@ import { ClaudeSessionService } from '../claude/claude-session.service.js';
 import { SessionLiveTailer } from '../claude/session-live-tailer.js';
 import { ToolApprovalManager } from '../claude/tool-approval-manager.js';
 import { FileRunStateStore } from '../state/file-run-state-store.js';
+import { TeamStateStore } from '../state/team-state-store.js';
 import { TranscriptStore } from '../state/transcript-store.js';
 import { ContextTracker } from '../manager/context-tracker.js';
 import { GitOperations } from '../manager/git-operations.js';
 import { SessionController } from '../manager/session-controller.js';
 import { PersistentManager } from '../manager/persistent-manager.js';
 import { managerPromptRegistry } from '../prompts/registry.js';
-export function getOrCreatePluginServices(worktree) {
+import { TeamOrchestrator } from '../manager/team-orchestrator.js';
+const serviceRegistry = new Map();
+const activeTeamRegistry = new Map();
+const wrapperSessionRegistry = new Map();
+export function getOrCreatePluginServices(worktree, projectClaudeFiles = []) {
+    const existing = serviceRegistry.get(worktree);
+    if (existing) {
+        return existing;
+    }
     const approvalManager = new ToolApprovalManager();
     const sdkAdapter = new ClaudeAgentSdkAdapter(undefined, approvalManager);
     const sessionService = new ClaudeSessionService(sdkAdapter);
@@ -18,14 +27,50 @@ export function getOrCreatePluginServices(worktree) {
     'default', worktree, managerPromptRegistry.modePrefixes);
     const gitOps = new GitOperations(worktree);
     const stateStore = new FileRunStateStore();
+    const teamStore = new TeamStateStore();
     const transcriptStore = new TranscriptStore();
     const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker, transcriptStore);
     const liveTailer = new SessionLiveTailer();
+    const orchestrator = new TeamOrchestrator(sessionService, teamStore, transcriptStore, managerPromptRegistry.engineerSessionPrompt, projectClaudeFiles);
     const services = {
         manager,
         sessions: sessionService,
         approvalManager,
         liveTailer,
+        teamStore,
+        orchestrator,
     };
+    serviceRegistry.set(worktree, services);
     return services;
 }
+export function clearPluginServices() {
+    serviceRegistry.clear();
+    activeTeamRegistry.clear();
+    wrapperSessionRegistry.clear();
+}
+export function setActiveTeamSession(worktree, teamId) {
+    activeTeamRegistry.set(worktree, teamId);
+}
+export function getActiveTeamSession(worktree) {
+    return activeTeamRegistry.get(worktree) ?? null;
+}
+export async function getPersistedActiveTeam(worktree) {
+    const services = serviceRegistry.get(worktree);
+    if (!services) {
+        return null;
+    }
+    return services.teamStore.getActiveTeam(worktree);
+}
+export async function setPersistedActiveTeam(worktree, teamId) {
+    const services = serviceRegistry.get(worktree);
+    if (!services) {
+        return;
+    }
+    await services.teamStore.setActiveTeam(worktree, teamId);
+}
+export function setWrapperSessionMapping(worktree, wrapperSessionId, mapping) {
+    wrapperSessionRegistry.set(`${worktree}:${wrapperSessionId}`, mapping);
+}
+export function getWrapperSessionMapping(worktree, wrapperSessionId) {
+    return wrapperSessionRegistry.get(`${worktree}:${wrapperSessionId}`) ?? null;
+}

package/dist/prompts/registry.d.ts

@@ -1,11 +1,2 @@
-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;
+import type { ManagerPromptRegistry } from '../types/contracts.js';
 export declare const managerPromptRegistry: ManagerPromptRegistry;

package/dist/prompts/registry.js

@@ -1,274 +1,55 @@
-/**
- * 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}`;
-}
-/**
- * Build an engineer wrapper prompt from shared sections plus mode-specific overrides.
- */
-function buildEngineerWrapperPrompt(opts) {
-    return [
-        `You are a staff engineer managing a Claude Code session for ${opts.purpose}.`,
-        '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',
-        '- Use read/grep/glob sparingly — only for spot-checks to sharpen a delegation.',
-        '- Do NOT implement changes yourself — investigation only.',
-        '',
-        '## Behavior',
-        `- Send the objective to the engineer using ${opts.toolName}.`,
-        "- Return the engineer's response verbatim. Do not summarize.",
-        `- Use freshSession:true on ${opts.toolName} when the task is unrelated to prior work.`,
-        '',
-        '## Constructing the engineer session prompt',
-        `When you call \`${opts.toolName}\`, you MUST include a \`sessionSystemPrompt\` argument.`,
-        'This becomes the system prompt for the underlying Claude Code session.',
-        'Build it as a self-contained description that equips the engineer to execute precisely.',
-        '',
-        'Structure it as:',
-        `1. **Role**: "${opts.roleDescription}"`,
-        '2. **Project rules**: Extract only the rules from the Project Claude Files below that',
-        '   are relevant to this specific task. Synthesize — do not dump everything.',
-        '   Cite file paths when the source matters (e.g. "per packages/core/CLAUDE.md").',
-        '3. **Verification**: How to verify the work (tests, lint, typecheck, expected behavior).',
-        '',
-        'Keep it concise: 3-6 sentences for role + relevant rules + verification.',
-        'The task itself goes in `message`, not in `sessionSystemPrompt`.',
-        '',
-        '## Context management',
-        '- Check session_health before sending.',
-        '- Under 50%: proceed. Over 70%: compact_context. Over 85%: clear_session.',
-        '',
-        '## Model selection',
-        ...opts.modelDefaults,
-        '',
-        '## 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 constructing sessionSystemPrompt.',
-        '- 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 call git_*, approval_*, or any non-engineer tools.',
-        '- Do NOT add commentary to the engineer response.',
-    ].join('\n');
-}
 export const managerPromptRegistry = {
     ctoSystemPrompt: [
-        '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: delegation-first',
-        'Your default action is to delegate. Do not do broad repo exploration yourself',
-        'when an engineer can do it. Direct read/grep/glob is allowed only for:',
-        '- Spot-checks to sharpen a delegation.',
-        '- Verifying a result after an engineer returns.',
-        '- Resolving one high-leverage ambiguity before dispatching.',
-        'If you need more than 2 direct read/grep/glob lookups, stop and delegate',
-        'the investigation to `engineer_explore` instead.',
-        '',
-        '## 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.',
-        'Tests, expected outputs, lint/typecheck commands, or before/after behavior.',
-        'This is the single highest-leverage thing you do.',
-        'Never delegate without telling the engineer how to prove it worked.',
-        '',
-        '## Right-size your approach',
-        'Not every task needs a plan. Assess complexity, then act:',
-        '',
-        '**Simple tasks** (typo, rename, add a log line, one-file fix):',
-        '  Skip investigation. Delegate directly with specific context.',
-        '',
-        '**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.',
-        '  Prefer spawning `engineer_explore` for repo exploration rather than reading',
-        '  code yourself. Use at most 1-2 spot-check reads to sharpen the delegation.',
-        '  Then delegate with file paths, line numbers, patterns, and verification.',
-        '',
-        '**Complex tasks** (multi-file feature, large refactor):',
-        '  1. Spawn `engineer_explore` to explore the repo, map dependencies, and analyze impact.',
-        '  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:',
-        '- Exact files, functions, and line numbers to change.',
-        '- Current behavior and desired behavior.',
-        '- Code snippets showing the pattern or convention to follow.',
-        '- How to verify: "Run `npm test`, expect all green." or',
-        '  "The function should return null instead of throwing."',
-        '',
-        'Bad:  "Fix the auth bug"',
-        'Good: "In src/auth/session.ts, `validateToken` (line 42) throws on expired',
-        '       tokens instead of returning null. Change it to return null.',
-        '       Update the caller in src/routes/login.ts:87.',
-        '       Follow the pattern in src/auth/refresh.ts:23.',
-        '       Run `npm test -- --grep auth` to verify. All tests should pass."',
-        '',
-        '## Review every change',
-        'After each delegation:',
-        '1. git_diff — read the FULL diff. Check for unintended changes, missing tests,',
-        '   style violations.',
-        '2. git_status — check what files changed (quick overview)',
-        '3. git_log -n 5 — see recent commits (understand context)',
-        '4. If correct: spawn `engineer_implement` to run tests/lint/typecheck.',
-        '5. If tests pass: git_commit to checkpoint.',
-        '6. If wrong: spawn `engineer_implement` with a specific correction.',
-        '   On second failure: git_reset and rewrite the prompt from scratch.',
-        '   Never send three corrections for the same problem.',
-        '',
-        '## Engineers (via the Task tool)',
-        '- `engineer_explore` — read-only investigation. Use for: exploring unfamiliar code,',
-        '  mapping dependencies, analyzing impact, asking "how does X work?"',
-        '- `engineer_implement` — implementation. Use for: all code changes, test runs, fixes.',
-        '- `engineer_verify` — verification. Use for: running tests, lint, typecheck, build.',
-        '  Use after implementation to confirm correctness.',
-        '- You may run MULTIPLE `engineer_explore` agents in parallel for independent investigations.',
-        '- You may run MULTIPLE `engineer_verify` agents in parallel for independent verification tasks.',
-        '- Only run ONE `engineer_implement` agent at a time — it makes changes to the worktree.',
-        '- Coordinate so that only one implement/verify runs at a time to avoid git conflicts.',
-        '',
-        '## Context efficiency',
-        '- Use `engineer_explore` for broad exploration so your own context stays clean.',
-        '- When spawning engineers for unrelated tasks, tell them to use freshSession:true.',
-        '- Keep delegations focused — one concern per engineer invocation.',
-        '',
-        '## What you must NOT do',
-        '- Do NOT call any engineer_* tools directly. Use the Task tool.',
-        '- Do NOT edit files or run bash commands yourself.',
-        '- Do NOT skip review — always git_diff after delegation.',
-        '- Do NOT delegate without verification criteria.',
-        '',
-        '## Tools reference',
-        'todowrite / todoread — track multi-step work',
-        'question             — ask the user structured questions with options',
-        'git_diff             — review changes (filter with paths, staged, ref args)',
-        'git_status           — quick overview of changed files',
-        'git_log              — recent commits (default: last 5)',
-        'git_commit           — stage all + commit',
-        'git_reset            — hard reset + clean (destructive)',
-        'approval_policy      — view tool approval rules',
-        'approval_decisions   — view recent approval decisions',
-        'approval_update      — modify tool approval policy',
-        '',
-        '## Autonomy blockers',
-        'Surface these to the user immediately:',
-        '- Credentials, API keys, or secrets you do not have.',
-        '- Architectural decisions with trade-offs the user should weigh.',
-        '- Destructive actions on shared state (deploy, publish, force-push).',
-        'State the blocker, what you need, and a concrete suggestion to unblock.',
+        'You are the CTO. Own the outcome, not just the request.',
+        '',
+        'Default behavior:',
+        '- Find requirement gaps before implementation.',
+        '- Ask at most one high-leverage question when the answer changes architecture, scope, or destructive behavior.',
+        '- Use the Task tool to delegate to named engineer subagents.',
+        '- For medium or large work, spawn two engineers in parallel, compare both plans, and synthesize the strongest path.',
+        '- Reuse the same named engineer when follow-up work belongs to their prior context.',
+        '- Review diffs with `git_diff`, inspect changed files with `git_status`, and use `git_log` for recent context.',
+        '- Use the built-in `question` tool whenever you need a user decision and provide a recommendation.',
+        '',
+        'Team model:',
+        '- Tom, John, Maya, Sara, and Alex are persistent engineers.',
+        '- Each engineer keeps one Claude Code session for the active CTO team.',
+        '- The plugin maps engineer work back to the active CTO session automatically.',
+        '- Only one implementing engineer should modify the worktree at a time.',
+        '',
+        'Do not:',
+        '- Do not edit files or run bash directly.',
+        '- Do not expose session babysitting to the user.',
+        '- Do not delegate without clear success criteria.',
+    ].join('\n'),
+    engineerAgentPrompt: [
+        'You are a named engineer working for the CTO.',
+        'Use the `claude` tool for all real work.',
+        'The tool remembers prior turns for this engineer inside the active CTO team.',
+        'Your prior wrapper context is also reloaded automatically so you can frame Claude requests better over time.',
+        'Choose the mode that matches the assignment: explore, implement, or verify.',
+        'Return the tool result directly unless a short clarification is truly required.',
     ].join('\n'),
-    engineerExplorePrompt: buildEngineerWrapperPrompt({
-        purpose: 'read-only investigation',
-        toolName: 'explore',
-        roleDescription: 'You are an expert engineer performing read-only investigation. ' +
-            'Execute directly. No preamble. Follow existing repo conventions.',
-        modelDefaults: [
-            '- claude-opus-4-6 + high: complex analysis (default).',
-            '- claude-sonnet-4-6: lighter analysis.',
-            '- effort "medium": simple lookups.',
-        ],
-    }),
-    engineerImplementPrompt: buildEngineerWrapperPrompt({
-        purpose: 'implementation',
-        toolName: 'implement',
-        roleDescription: 'You are an expert engineer implementing changes. ' +
-            'Execute directly. No preamble. Follow existing repo conventions. ' +
-            'Do not run git commit, git push, git reset, git checkout, or git stash — git operations are handled externally.',
-        modelDefaults: [
-            '- claude-opus-4-6 + high: most coding tasks (default).',
-            '- claude-sonnet-4-6: simple renames, formatting, scaffolding.',
-            '- effort "max": complex refactors, subtle bugs, cross-cutting changes.',
-        ],
-    }),
-    engineerVerifyPrompt: buildEngineerWrapperPrompt({
-        purpose: 'verification',
-        toolName: 'verify',
-        roleDescription: 'You are an expert engineer verifying changes. ' +
-            'Execute directly. No preamble. Follow existing repo conventions. ' +
-            'Do not run git commit, git push, git reset, git checkout, or git stash — git operations are handled externally.',
-        modelDefaults: [
-            '- claude-opus-4-6 + high: most verification tasks (default).',
-            '- claude-sonnet-4-6: simple test runs, lint checks.',
-            '- effort "medium": straightforward verification.',
-        ],
-    }),
     engineerSessionPrompt: [
-        'You are an expert engineer. Execute instructions precisely.',
-        '',
-        '## Rules',
-        '- Execute directly. No preamble, no restating the task.',
-        '- Follow existing repo conventions.',
-        '- Report exact output on failure.',
-        '',
-        '## Verification',
-        '- Always verify your own work before reporting done.',
-        '- If no verification was specified, still run relevant tests if they exist.',
-        '',
-        '## Git boundary — do NOT run:',
-        'git commit, git push, git reset, git checkout, git stash.',
-        'Git operations are handled externally.',
-        '',
-        '## Reporting',
-        '- End with: what was done, what was verified, what passed/failed.',
-        '- Report blockers immediately with specifics.',
+        'You are an expert software engineer working inside Claude Code.',
+        'Execute directly. No preamble.',
+        'Follow repository conventions and relevant project instructions.',
+        'Use the minimum necessary investigation before acting.',
+        'Verify your own work before reporting done.',
+        'Report blockers clearly and include exact command output on failure.',
+        'Do not run git commit, git push, git reset, git checkout, or git stash.',
     ].join('\n'),
     modePrefixes: {
         plan: [
-            '[PLAN MODE] Read-only. Do NOT create or edit any files.',
-            'Do NOT use ExitPlanMode or write artifacts to disk.',
-            'Use read, grep, glob, and search tools only.',
-            'Analyze the codebase and produce a detailed implementation plan:',
-            'files to change, functions to modify, new files to create, test strategy,',
-            'and risks. End with a numbered step-by-step plan.',
-            'Return the entire plan inline in your response.',
+            '[PLAN MODE] Read-only.',
+            'Do not create or edit files.',
+            'Analyze the codebase and return the plan inline.',
         ].join(' '),
         free: '',
     },
     contextWarnings: {
-        moderate: 'Session context is filling up ({percent}% estimated). Consider whether a fresh session would be more efficient.',
-        high: 'Session context is heavy ({percent}% estimated, {turns} turns, ${cost}). Start a new session or compact first.',
-        critical: 'Session context is near capacity ({percent}% estimated). Clear the session immediately before continuing.',
+        moderate: 'Engineer context is getting full ({percent}% estimated). Reuse is still fine, but keep the next prompt focused.',
+        high: 'Engineer context is heavy ({percent}% estimated, {turns} turns, ${cost}). Prefer a narrowly scoped follow-up or internal compaction.',
+        critical: 'Engineer context is near capacity ({percent}% estimated). Avoid piling unrelated work into this engineer session.',
     },
 };

package/dist/src/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,
@@ -409,7 +410,7 @@ function truncateJsonish(value, max) {
         return truncateString(JSON.stringify(value), max);
     }
     catch {
-        return truncateString(String(value), max);
+        return truncateString('[non-serializable]', max);
     }
 }
 function truncateString(s, max) {

package/dist/src/claude/session-live-tailer.js

@@ -99,7 +99,7 @@ export class SessionLiveTailer {
                 });
                 let chunk = '';
                 stream.on('data', (data) => {
-                    chunk += data;
+                    chunk += typeof data === 'string' ? data : data.toString('utf8');
                 });
                 stream.on('end', () => {
                     reading = false;
@@ -264,6 +264,6 @@ function stringifyContent(value) {
         return JSON.stringify(value);
     }
     catch {
-        return String(value);
+        return '[non-serializable]';
     }
 }

package/dist/src/index.d.ts

@@ -1,6 +1,6 @@
 import type { Plugin } from '@opencode-ai/plugin';
 import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
-export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ActiveSessionState, ContextWarningLevel, SessionMode, LiveTailEvent, ToolOutputPreview, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
+export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, PersistentRunRecord, PersistentRunResult, ContextWarningLevel, SessionMode, EngineerName, EngineerWorkMode, WrapperHistoryEntry, TeamEngineerRecord, TeamRecord, EngineerTaskResult, PlanDraft, SynthesizedPlanResult, LiveTailEvent, ToolOutputPreview, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
 export { SessionLiveTailer } from './claude/session-live-tailer.js';
 export { ClaudeManagerPlugin };
 export declare const plugin: Plugin;

package/dist/src/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/src/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/src/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.
      */
@@ -67,10 +83,6 @@ export declare class PersistentManager {
     executeTask(cwd: string, task: string, options?: {
         model?: string;
     }, onProgress?: PersistentManagerProgressHandler): Promise<PersistentRunResult>;
-    /**
-     * Try to restore session state from disk on startup.
-     */
-    tryRestore(cwd: string): Promise<boolean>;
     listRuns(cwd: string): Promise<PersistentRunRecord[]>;
     getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
 }