@doingdev/opencode-claude-manager-plugin 0.1.10 → 0.1.12

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

@@ -2,11 +2,15 @@ import { tool } from '@opencode-ai/plugin';
 import { managerPromptRegistry } from '../prompts/registry.js';
 import { getOrCreatePluginServices } from './service-factory.js';
 const MANAGER_TOOL_IDS = [
-    'claude_manager_run',
+    'claude_manager_send',
+    'claude_manager_git_diff',
+    'claude_manager_git_commit',
+    'claude_manager_git_reset',
+    'claude_manager_clear',
+    'claude_manager_status',
     'claude_manager_metadata',
     'claude_manager_sessions',
     'claude_manager_runs',
-    'claude_manager_cleanup_run',
 ];
 export const ClaudeManagerPlugin = async ({ worktree }) => {
     const services = getOrCreatePluginServices(worktree);
@@ -16,37 +20,29 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             config.command ??= {};
             config.permission ??= {};
             const globalPermissions = config.permission;
-            const managerPermissions = {
-                claude_manager_run: 'allow',
-                claude_manager_metadata: 'allow',
-                claude_manager_sessions: 'allow',
-                claude_manager_runs: 'allow',
-                claude_manager_cleanup_run: 'allow',
-            };
-            const researchPermissions = {
-                claude_manager_run: 'deny',
-                claude_manager_metadata: 'allow',
-                claude_manager_sessions: 'allow',
-                claude_manager_runs: 'allow',
-                claude_manager_cleanup_run: 'deny',
-            };
+            const managerPermissions = {};
+            const researchPermissions = {};
             for (const toolId of MANAGER_TOOL_IDS) {
                 globalPermissions[toolId] ??= 'deny';
+                managerPermissions[toolId] = 'allow';
+                // Research agent can inspect but not send or modify
+                researchPermissions[toolId] =
+                    toolId === 'claude_manager_send' ||
+                        toolId === 'claude_manager_git_commit' ||
+                        toolId === 'claude_manager_git_reset' ||
+                        toolId === 'claude_manager_clear'
+                        ? 'deny'
+                        : 'allow';
             }
             config.agent['claude-manager'] ??= {
-                description: 'Primary agent that manages Claude Code sessions through the bundled plugin tools.',
+                description: 'Primary agent that operates Claude Code through a persistent session, reviews work via git diff, and commits/resets changes.',
                 mode: 'primary',
                 color: 'accent',
                 permission: {
                     '*': 'deny',
                     ...managerPermissions,
                 },
-                prompt: [
-                    managerPromptRegistry.managerSystemPrompt,
-                    'When Claude Code delegation is useful, prefer the claude_manager_run tool instead of simulating the work yourself.',
-                    'Use claude_manager_metadata to inspect available Claude commands, skills, and hooks before making assumptions.',
-                    'Use claude_manager_sessions and claude_manager_runs to inspect prior work before starting a new Claude session.',
-                ].join(' '),
+                prompt: managerPromptRegistry.managerSystemPrompt,
             };
             config.agent['claude-manager-research'] ??= {
                 description: 'Subagent that inspects Claude metadata, prior sessions, and manager runs without changing repository state.',
@@ -57,11 +53,20 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     ...researchPermissions,
                 },
                 prompt: [
-                    managerPromptRegistry.subagentSystemPrompt,
                     'Focus on inspection and summarization.',
-                    'Prefer claude_manager_metadata, claude_manager_sessions, and claude_manager_runs over guesswork.',
+                    'Use claude_manager_status, claude_manager_metadata, claude_manager_sessions, and claude_manager_runs to gather information.',
                 ].join(' '),
             };
+            config.command['claude-run'] ??= {
+                description: 'Send a task to the persistent Claude Code session.',
+                agent: 'claude-manager',
+                subtask: true,
+                template: [
+                    'Use claude_manager_send to send the following task to Claude Code:',
+                    '$ARGUMENTS',
+                    'After it completes, review the result and use claude_manager_git_diff if changes were expected. Commit or reset accordingly.',
+                ].join('\n\n'),
+            };
             config.command['claude-metadata'] ??= {
                 description: 'Inspect bundled Claude commands, skills, hooks, and agents.',
                 agent: 'claude-manager-research',
@@ -71,16 +76,6 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     'Summarize Claude commands, skills, hooks, discovered agents, and important config files.',
                 ].join(' '),
             };
-            config.command['claude-run'] ??= {
-                description: 'Delegate a task to Claude Code through the manager plugin.',
-                agent: 'claude-manager',
-                subtask: true,
-                template: [
-                    'Call claude_manager_run immediately for the following task:',
-                    '$ARGUMENTS',
-                    'Avoid planning narration before the tool call. After it completes, return a concise result summary.',
-                ].join('\n\n'),
-            };
             config.command['claude-sessions'] ??= {
                 description: 'Inspect Claude session history and manager run records.',
                 agent: 'claude-manager-research',
@@ -99,41 +94,153 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
             }
         },
         tool: {
-            claude_manager_run: tool({
-                description: 'Delegate a task to Claude Code with optional subagents and worktrees.',
+            claude_manager_send: tool({
+                description: 'Send a message to the persistent Claude Code session. ' +
+                    'Auto-creates a session on first call. Resumes the existing session on subsequent calls. ' +
+                    'Returns the assistant response and current context health snapshot.',
                 args: {
-                    task: tool.schema.string().min(1),
-                    mode: tool.schema.enum(['auto', 'single', 'split']).default('auto'),
-                    maxSubagents: tool.schema.number().int().min(1).max(8).default(3),
-                    useWorktrees: tool.schema.boolean().default(true),
-                    includeProjectSettings: tool.schema.boolean().default(true),
+                    message: tool.schema.string().min(1),
                     model: tool.schema.string().optional(),
                     cwd: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
-                    annotateToolRun(context, 'Delegating task to Claude manager', {
-                        task: args.task,
-                        mode: args.mode,
+                    const cwd = args.cwd ?? context.worktree;
+                    const hasActiveSession = services.manager.getStatus().sessionId !== null;
+                    context.metadata({
+                        title: hasActiveSession
+                            ? 'Claude Code: Resuming session...'
+                            : 'Claude Code: Initializing...',
+                        metadata: { sessionId: services.manager.getStatus().sessionId },
                     });
-                    let lastProgressSignature = '';
-                    const result = await services.manager.run({
-                        cwd: args.cwd ?? context.worktree,
-                        task: args.task,
-                        mode: args.mode,
-                        maxSubagents: args.maxSubagents,
-                        useWorktrees: args.useWorktrees,
-                        includeProjectSettings: args.includeProjectSettings,
-                        model: args.model,
-                    }, async (run) => {
-                        const progressView = buildRunProgressView(run);
-                        const signature = JSON.stringify(progressView);
-                        if (signature === lastProgressSignature) {
-                            return;
+                    let turnsSoFar = 0;
+                    let costSoFar = 0;
+                    const result = await services.manager.sendMessage(cwd, args.message, { model: args.model }, (event) => {
+                        if (event.turns !== undefined) {
+                            turnsSoFar = event.turns;
+                        }
+                        if (event.totalCostUsd !== undefined) {
+                            costSoFar = event.totalCostUsd;
+                        }
+                        const costLabel = `$${costSoFar.toFixed(4)}`;
+                        if (event.type === 'tool_call') {
+                            let toolName = 'tool';
+                            try {
+                                toolName = JSON.parse(event.text).name ?? 'tool';
+                            }
+                            catch {
+                                // ignore parse errors
+                            }
+                            context.metadata({
+                                title: `Claude Code: Running ${toolName}... (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    preview: event.text.slice(0, 200),
+                                },
+                            });
                         }
-                        lastProgressSignature = signature;
-                        context.metadata(progressView);
+                        else if (event.type === 'assistant') {
+                            context.metadata({
+                                title: `Claude Code: Thinking... (${turnsSoFar} turns, ${costLabel})`,
+                                metadata: {
+                                    sessionId: event.sessionId,
+                                    type: event.type,
+                                    preview: event.text.slice(0, 200),
+                                },
+                            });
+                        }
+                    });
+                    const costLabel = `$${(result.totalCostUsd ?? 0).toFixed(4)}`;
+                    const turns = result.turns ?? 0;
+                    const contextWarning = formatContextWarning(result.context);
+                    if (contextWarning) {
+                        context.metadata({
+                            title: `Claude Code: Context at ${result.context.estimatedContextPercent}% (${turns} turns)`,
+                            metadata: { sessionId: result.sessionId, contextWarning },
+                        });
+                    }
+                    else {
+                        context.metadata({
+                            title: `Claude Code: Complete (${turns} turns, ${costLabel})`,
+                            metadata: { sessionId: result.sessionId },
+                        });
+                    }
+                    return JSON.stringify({
+                        sessionId: result.sessionId,
+                        finalText: result.finalText,
+                        turns: result.turns,
+                        totalCostUsd: result.totalCostUsd,
+                        context: result.context,
+                        contextWarning,
+                    }, null, 2);
+                },
+            }),
+            claude_manager_git_diff: tool({
+                description: 'Run git diff to see all current changes (staged + unstaged) relative to HEAD.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Running git diff', {});
+                    const result = await services.manager.gitDiff();
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            claude_manager_git_commit: tool({
+                description: 'Stage all changes and commit with the given message.',
+                args: {
+                    message: tool.schema.string().min(1),
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Committing changes', {
+                        message: args.message,
+                    });
+                    const result = await services.manager.gitCommit(args.message);
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            claude_manager_git_reset: tool({
+                description: 'Run git reset --hard HEAD and git clean -fd to discard ALL uncommitted changes and untracked files.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Resetting working directory', {});
+                    const result = await services.manager.gitReset();
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            claude_manager_clear: tool({
+                description: 'Clear the active Claude Code session. The next send will start a fresh session. ' +
+                    'Use when context is full, the session is confused, or starting a different task.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                    reason: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    annotateToolRun(context, 'Clearing session', {
+                        reason: args.reason,
                     });
-                    return formatManagerRunToolResult(result.run);
+                    const clearedId = await services.manager.clearSession(args.cwd ?? context.worktree);
+                    return JSON.stringify({ clearedSessionId: clearedId });
+                },
+            }),
+            claude_manager_status: tool({
+                description: 'Get the current persistent session status: context usage %, turns, cost, active session ID.',
+                args: {
+                    cwd: tool.schema.string().optional(),
+                },
+                async execute(_args, context) {
+                    annotateToolRun(context, 'Checking session status', {});
+                    const status = services.manager.getStatus();
+                    return JSON.stringify({
+                        ...status,
+                        transcriptFile: status.sessionId
+                            ? `.claude-manager/transcripts/${status.sessionId}.json`
+                            : null,
+                        contextWarning: formatContextWarning(status),
+                    }, null, 2);
                 },
             }),
             claude_manager_metadata: tool({
@@ -153,23 +260,31 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                 },
             }),
             claude_manager_sessions: tool({
-                description: 'List Claude sessions or inspect a saved transcript.',
+                description: 'List Claude sessions or inspect a saved transcript. ' +
+                    'When sessionId is provided, returns both SDK transcript and local manager events.',
                 args: {
                     cwd: tool.schema.string().optional(),
                     sessionId: tool.schema.string().optional(),
                 },
                 async execute(args, context) {
                     annotateToolRun(context, 'Inspecting Claude session history', {});
+                    const cwd = args.cwd ?? context.worktree;
                     if (args.sessionId) {
-                        const transcript = await services.sessions.getTranscript(args.sessionId, args.cwd ?? context.worktree);
-                        return JSON.stringify(transcript, null, 2);
+                        const [sdkTranscript, localEvents] = await Promise.all([
+                            services.sessions.getTranscript(args.sessionId, cwd),
+                            services.manager.getTranscriptEvents(cwd, args.sessionId),
+                        ]);
+                        return JSON.stringify({
+                            sdkTranscript,
+                            localEvents: localEvents.length > 0 ? localEvents : undefined,
+                        }, null, 2);
                     }
-                    const sessions = await services.sessions.listSessions(args.cwd ?? context.worktree);
+                    const sessions = await services.sessions.listSessions(cwd);
                     return JSON.stringify(sessions, null, 2);
                 },
             }),
             claude_manager_runs: tool({
-                description: 'List manager runs previously recorded for this repo.',
+                description: 'List persistent manager run records.',
                 args: {
                     cwd: tool.schema.string().optional(),
                     runId: tool.schema.string().optional(),
@@ -184,20 +299,6 @@ export const ClaudeManagerPlugin = async ({ worktree }) => {
                     return JSON.stringify(runs, null, 2);
                 },
             }),
-            claude_manager_cleanup_run: tool({
-                description: 'Explicitly remove git worktrees created for a recorded manager run.',
-                args: {
-                    runId: tool.schema.string().min(1),
-                    cwd: tool.schema.string().optional(),
-                },
-                async execute(args, context) {
-                    annotateToolRun(context, 'Cleaning manager worktrees', {
-                        runId: args.runId,
-                    });
-                    const run = await services.manager.cleanupRunWorktrees(args.cwd ?? context.worktree, args.runId);
-                    return JSON.stringify(run, null, 2);
-                },
-            }),
         },
     };
 };
@@ -208,11 +309,11 @@ function buildCommandText(command, rawArguments) {
     const argumentsText = rawArguments.trim();
     if (command === 'claude-run') {
         return [
-            'Call `claude_manager_run` immediately.',
+            'Use `claude_manager_send` to send the following task to Claude Code:',
             argumentsText
-                ? `Task: ${argumentsText}`
-                : 'Task: Inspect the current repository and wait for follow-up instructions.',
-            'Do not add planning text before the tool call. After it completes, give a short result summary.',
+                ? argumentsText
+                : 'Inspect the current repository and wait for follow-up instructions.',
+            'After it completes, review the result. If code changes were expected, use `claude_manager_git_diff` to review, then `claude_manager_git_commit` or `claude_manager_git_reset` accordingly.',
         ].join('\n\n');
     }
     if (command === 'claude-metadata') {
@@ -237,125 +338,27 @@ function buildCommandText(command, rawArguments) {
 }
 function rewriteCommandParts(parts, text) {
     let hasRewrittenText = false;
-    const rewrittenParts = parts.map((part) => {
+    return parts.map((part) => {
         if (part.type !== 'text' || hasRewrittenText) {
             return part;
         }
         hasRewrittenText = true;
-        return {
-            ...part,
-            text,
-        };
+        return { ...part, text };
     });
-    return rewrittenParts;
 }
-export function formatManagerRunToolResult(run) {
-    const finalSummary = run.finalSummary ?? summarizeSessionOutputs(run.sessions);
-    const output = run.sessions.length === 1
-        ? resolveSessionOutput(run.sessions[0])
-        : finalSummary;
-    return JSON.stringify({
-        runId: run.id,
-        status: run.status,
-        output,
-        finalSummary,
-        sessions: run.sessions.map((session) => ({
-            title: session.title,
-            status: session.status,
-            output: resolveSessionOutput(session),
-            claudeSessionId: session.claudeSessionId,
-            worktreeMode: session.worktreeMode,
-            branchName: session.branchName,
-            turns: session.turns,
-            totalCostUsd: session.totalCostUsd,
-        })),
-        inspectRun: {
-            tool: 'claude_manager_runs',
-            runId: run.id,
-        },
-    }, null, 2);
-}
-function buildRunProgressView(run) {
-    const completed = run.sessions.filter((session) => session.status === 'completed').length;
-    const failed = run.sessions.filter((session) => session.status === 'failed').length;
-    const running = run.sessions.filter((session) => session.status === 'running').length;
-    const pending = run.sessions.filter((session) => session.status === 'pending').length;
-    const total = run.sessions.length;
-    return {
-        title: buildRunProgressTitle(run, { completed, failed, running, total }),
-        metadata: {
-            runId: run.id,
-            status: run.status,
-            progress: `${completed}/${total} completed`,
-            active: running,
-            pending,
-            failed,
-            sessions: run.sessions.map(formatSessionActivity),
-        },
-    };
-}
-function buildRunProgressTitle(run, counts) {
-    const suffix = `(${counts.completed}/${counts.total} complete` +
-        (counts.running > 0 ? `, ${counts.running} active` : '') +
-        (counts.failed > 0 ? `, ${counts.failed} failed` : '') +
-        ')';
-    if (run.status === 'completed') {
-        return `Claude manager completed ${suffix}`;
-    }
-    if (run.status === 'failed') {
-        return `Claude manager failed ${suffix}`;
-    }
-    if (counts.running > 0) {
-        return `Claude manager running ${suffix}`;
-    }
-    return `Claude manager queued ${suffix}`;
-}
-function formatSessionActivity(session) {
-    const parts = [session.title, session.status];
-    if (session.claudeSessionId) {
-        parts.push(session.claudeSessionId);
+function formatContextWarning(context) {
+    const { warningLevel, estimatedContextPercent, totalTurns, totalCostUsd } = context;
+    if (warningLevel === 'ok' || estimatedContextPercent === null) {
+        return null;
     }
-    const latestEvent = findLatestDisplayEvent(session.events);
-    if (session.finalText) {
-        parts.push(truncateForDisplay(session.finalText, 120));
-    }
-    else if (session.error) {
-        parts.push(truncateForDisplay(session.error, 120));
-    }
-    else if (latestEvent) {
-        parts.push(`${latestEvent.type}: ${truncateForDisplay(latestEvent.text, 120)}`);
-    }
-    return parts.join(' | ');
-}
-function findLatestDisplayEvent(events) {
-    const reversedEvents = [...events].reverse();
-    const preferredEvent = reversedEvents.find((event) => (event.type === 'result' ||
-        event.type === 'error' ||
-        event.type === 'assistant') &&
-        Boolean(event.text.trim()));
-    if (preferredEvent) {
-        return preferredEvent;
-    }
-    return [...events]
-        .reverse()
-        .find((event) => event.type !== 'partial' && Boolean(event.text.trim()));
-}
-function truncateForDisplay(text, maxLength) {
-    const normalized = text.replace(/\s+/g, ' ').trim();
-    if (normalized.length <= maxLength) {
-        return normalized;
-    }
-    return `${normalized.slice(0, maxLength - 3)}...`;
-}
-function summarizeSessionOutputs(sessions) {
-    return sessions
-        .map((session) => `${session.title}: ${resolveSessionOutput(session)}`)
-        .join('\n');
-}
-function resolveSessionOutput(session) {
-    const latestEvent = findLatestDisplayEvent(session.events);
-    return (session.finalText?.trim() ||
-        session.error?.trim() ||
-        latestEvent?.text.trim() ||
-        session.status);
+    const templates = managerPromptRegistry.contextWarnings;
+    const template = warningLevel === 'critical'
+        ? templates.critical
+        : warningLevel === 'high'
+            ? templates.high
+            : templates.moderate;
+    return template
+        .replace('{percent}', String(estimatedContextPercent))
+        .replace('{turns}', String(totalTurns))
+        .replace('{cost}', totalCostUsd.toFixed(2));
 }

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

@@ -1,7 +1,8 @@
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
-import { ManagerOrchestrator } from '../manager/manager-orchestrator.js';
-export interface ClaudeManagerPluginServices {
-    manager: ManagerOrchestrator;
+import { PersistentManager } from '../manager/persistent-manager.js';
+interface ClaudeManagerPluginServices {
+    manager: PersistentManager;
     sessions: ClaudeSessionService;
 }
 export declare function getOrCreatePluginServices(worktree: string): ClaudeManagerPluginServices;
+export {};

package/dist/plugin/service-factory.js

@@ -1,11 +1,14 @@
 import { ClaudeAgentSdkAdapter } from '../claude/claude-agent-sdk-adapter.js';
 import { ClaudeSessionService } from '../claude/claude-session.service.js';
-import { ManagerOrchestrator } from '../manager/manager-orchestrator.js';
-import { TaskPlanner } from '../manager/task-planner.js';
 import { ClaudeMetadataService } from '../metadata/claude-metadata.service.js';
 import { RepoClaudeConfigReader } from '../metadata/repo-claude-config-reader.js';
 import { FileRunStateStore } from '../state/file-run-state-store.js';
-import { WorktreeCoordinator } from '../worktree/worktree-coordinator.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';
 const serviceCache = new Map();
 export function getOrCreatePluginServices(worktree) {
     const cachedServices = serviceCache.get(worktree);
@@ -15,7 +18,14 @@ export function getOrCreatePluginServices(worktree) {
     const sdkAdapter = new ClaudeAgentSdkAdapter();
     const metadataService = new ClaudeMetadataService(new RepoClaudeConfigReader(), sdkAdapter);
     const sessionService = new ClaudeSessionService(sdkAdapter, metadataService);
-    const manager = new ManagerOrchestrator(sessionService, new FileRunStateStore(), new WorktreeCoordinator(), new TaskPlanner());
+    const contextTracker = new ContextTracker();
+    const sessionController = new SessionController(sdkAdapter, contextTracker, managerPromptRegistry.claudeCodeSessionPrompt);
+    const gitOps = new GitOperations(worktree);
+    const stateStore = new FileRunStateStore();
+    const transcriptStore = new TranscriptStore();
+    const manager = new PersistentManager(sessionController, gitOps, stateStore, contextTracker, transcriptStore);
+    // Try to restore active session state (fire and forget)
+    manager.tryRestore(worktree).catch(() => { });
     const services = {
         manager,
         sessions: sessionService,

package/dist/prompts/registry.js

@@ -1,11 +1,45 @@
 export const managerPromptRegistry = {
     managerSystemPrompt: [
-        'You are the OpenCode manager for Claude Code sessions.',
-        'Plan first, delegate carefully, and keep user-visible progress concise.',
-        'Prefer deterministic orchestration in code over prompt-only control flow.',
-    ].join(' '),
-    subagentSystemPrompt: [
-        'You are a Claude execution worker managed by OpenCode.',
-        'Stay within assigned scope, report blockers explicitly, and summarize changes with verification notes.',
-    ].join(' '),
+        'You orchestrate Claude Code through a persistent session. You are a user proxy —',
+        'your job is to make Claude Code do the work, not to do it yourself.',
+        '',
+        '## Workflow',
+        '1. claude_manager_send — send clear, specific instructions',
+        '2. claude_manager_git_diff — review what changed',
+        '3. claude_manager_git_commit — checkpoint good work',
+        '4. claude_manager_git_reset — discard bad work',
+        '5. claude_manager_clear — fresh session when needed',
+        '',
+        '## Context management',
+        'Check the context snapshot in each send result:',
+        '- Under 50%: proceed freely',
+        '- 50-70%: consider if next task should reuse or start fresh',
+        '- Over 70%: compact or clear before heavy work',
+        '- Over 85% or 200k tokens: clear immediately',
+        '',
+        '## Delegation principles',
+        '- Write specific task descriptions with file paths, function names, error messages',
+        '- For large features, send sequential focused instructions',
+        '- Tell Claude Code to use subagents for parallel/independent parts',
+        '- After implementation, always review with git diff before committing',
+        '- If work is wrong, send a correction (specific, not "try again") or reset',
+    ].join('\n'),
+    claudeCodeSessionPrompt: [
+        'You are being directed by an expert automated operator. Treat each message',
+        'as a precise instruction from a skilled Claude Code user.',
+        '',
+        'Key behaviors:',
+        '- Execute instructions directly without asking for clarification',
+        '- Use the Agent tool to spawn subagents for parallel/independent work',
+        '- Be concise — no preamble, no restating the task',
+        '- Do NOT run git commit, git push, or git reset — the operator handles git',
+        '- After completing work, end with a brief verification summary',
+        '- When context is heavy, prefer targeted file reads over reading entire files',
+        '- Report blockers immediately and specifically',
+    ].join('\n'),
+    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.',
+    },
 };

package/dist/state/file-run-state-store.d.ts

@@ -1,12 +1,12 @@
-import type { ManagerRunRecord } from '../types/contracts.js';
+import type { PersistentRunRecord } from '../types/contracts.js';
 export declare class FileRunStateStore {
     private readonly baseDirectoryName;
     private readonly writeQueues;
     constructor(baseDirectoryName?: string);
-    saveRun(run: ManagerRunRecord): Promise<void>;
-    getRun(cwd: string, runId: string): Promise<ManagerRunRecord | null>;
-    listRuns(cwd: string): Promise<ManagerRunRecord[]>;
-    updateRun(cwd: string, runId: string, update: (run: ManagerRunRecord) => ManagerRunRecord): Promise<ManagerRunRecord>;
+    saveRun(run: PersistentRunRecord): Promise<void>;
+    getRun(cwd: string, runId: string): Promise<PersistentRunRecord | null>;
+    listRuns(cwd: string): Promise<PersistentRunRecord[]>;
+    updateRun(cwd: string, runId: string, update: (run: PersistentRunRecord) => PersistentRunRecord): Promise<PersistentRunRecord>;
     private getRunKey;
     private getRunsDirectory;
     private getRunPath;

package/dist/state/file-run-state-store.js

@@ -1,6 +1,6 @@
-import { randomUUID } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { isFileNotFoundError, writeJsonAtomically, } from '../util/fs-helpers.js';
 export class FileRunStateStore {
     baseDirectoryName;
     writeQueues = new Map();
@@ -85,13 +85,3 @@ export class FileRunStateStore {
         }
     }
 }
-async function writeJsonAtomically(filePath, data) {
-    const tempPath = `${filePath}.${randomUUID()}.tmp`;
-    await fs.writeFile(tempPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
-    await fs.rename(tempPath, filePath);
-}
-function isFileNotFoundError(error) {
-    return (error instanceof Error &&
-        'code' in error &&
-        error.code === 'ENOENT');
-}