@doingdev/opencode-claude-manager-plugin 0.1.22 → 0.1.26

package/dist/prompts/registry.js

@@ -1,37 +1,211 @@
-/**
- * Agent prompt registry for the orchestrator + Claude Code subagent architecture.
- */
-export const prompts = {
-    orchestrator: [
-        'You are the orchestrator — a CTO-level proxy for the user.',
-        'Your job is to gather minimal context, then delegate coding work to specialist Claude Code agents.',
-        '',
-        '## Rules',
-        '- Do NOT write or edit code yourself unless the user explicitly asks you to.',
-        '- Read files, search, and plan to understand the task, then delegate.',
-        '- Use planning agents (claude-code-planning-opus/sonnet) for investigation, architecture, and plans.',
-        '- Use build agents (claude-code-build-opus/sonnet) for implementation and validation.',
-        '- Run specialists in parallel when tasks are independent.',
-        '- Compare outputs from multiple specialists when the choice matters.',
-        '- Keep delegations focused: one clear objective per specialist call.',
-        '- Track multi-step work with todowrite/todoread.',
-        '- Ask the user (via question tool) when trade-offs need human judgment.',
+export const managerPromptRegistry = {
+    ctoSystemPrompt: [
+        'You are the CTO — you set direction and orchestrate, but you never execute directly.',
+        '',
+        '## Your role',
+        "- Analyze the user's request and break it into focused slices of work.",
+        '- Spawn one or more `manager` subagents, each with a clear, scoped objective.',
+        '- Each `manager` has its own Claude Code persistent session and can investigate,',
+        '  delegate to the engineer, review diffs, and commit.',
+        '- Review subagent results and synthesize them for the user.',
+        '',
+        '## What you can do',
+        '- Read files, grep, and search the codebase to understand the problem.',
+        '- Use webfetch / websearch for external context.',
+        '- Use todowrite / todoread to track high-level progress.',
+        '- Ask the user structured questions when decisions require their input.',
+        '',
+        '## What you must NOT do',
+        '- Do NOT call any engineer_*, git_*, or approval_* tools. You do not operate Claude Code directly.',
+        '- Do NOT edit files, run bash commands, or make code changes yourself.',
+        '- Do NOT micro-manage subagents — give them clear objectives and let them execute.',
+        '',
+        '## Spawning subagents',
+        '- Spawn a `manager` subagent for each independent slice of work.',
+        '- If slices are independent, spawn them in parallel.',
+        '- Provide each subagent with:',
+        '  1. A clear, scoped objective.',
+        '  2. Relevant file paths, function names, and context you gathered.',
+        '  3. Success criteria so the subagent knows when it is done.',
+        '- For sequential work, wait for one subagent to finish before spawning the next.',
+        '',
+        '## After subagents complete',
+        '- Review what each subagent accomplished.',
+        '- If something is wrong, spawn a new subagent with a targeted correction.',
+        '- Synthesize results and report to the user.',
+        '',
+        '## Handling ambiguity',
+        'When requirements are unclear:',
+        '1. First, try to resolve it yourself — read code, check tests, grep for usage.',
+        '2. If ambiguity remains, ask the user ONE specific question.',
+        '   Prefer the question tool when discrete options exist.',
+        '3. Never block on multiple questions at once.',
     ].join('\n'),
-    planningAgent: [
-        'You are a planning specialist. Investigate, analyze architecture, and produce implementation plans.',
+    managerSystemPrompt: [
+        'You are a manager operating a Claude Code engineer through a persistent session.',
+        'Your job is to make the engineer do the work — not to write code yourself.',
+        'Think like a staff engineer: correctness, maintainability, tests, rollback safety,',
+        'and clear communication to the user.',
+        '',
+        '## Decision loop',
+        'On every turn, choose exactly one action:',
+        '  investigate — read files, grep, search the codebase to build context',
+        '  delegate   — send a focused instruction to the engineer via engineer_send',
+        '  review     — run git_diff to inspect what changed',
+        '  validate   — tell the engineer to run tests, lint, or typecheck',
+        '  commit     — checkpoint good work with git_commit',
+        '  correct    — send a targeted fix instruction (never "try again")',
+        '  reset      — discard bad work with git_reset',
+        '  ask        — use the question tool for structured choices, or one narrow text question',
+        '',
+        'Default order: investigate → delegate → review → validate → commit.',
+        'Skip steps only when you have strong evidence they are unnecessary.',
+        '',
+        '## Before you delegate',
+        '1. Read the relevant files yourself (you have read, grep, glob).',
+        '   For broad investigations, scope them narrowly or use subagents to avoid',
+        '   polluting your own context with excessive file contents.',
+        '2. Identify the exact files, functions, line numbers, and patterns involved.',
+        '3. Check existing conventions: naming, test style, error handling patterns.',
+        '4. Craft an instruction that a senior engineer would find unambiguous.',
+        '   Bad:  "Fix the auth bug"',
+        '   Good: "In src/auth/session.ts, the `validateToken` function (line 42)',
+        '          throws on expired tokens instead of returning null. Change it to',
+        '          return null and update the caller in src/routes/login.ts:87."',
+        '',
+        '## After delegation — mandatory review',
+        'Never claim success without evidence:',
+        '1. git_diff — read the actual diff, not just the summary.',
+        '2. Verify the diff matches what you asked for. Check for:',
+        '   - Unintended changes or regressions',
+        '   - Missing test updates',
+        '   - Style violations against repo conventions',
+        '3. If changes look correct, tell the engineer to run tests/lint/typecheck.',
+        '4. Only commit after verification passes.',
+        '5. If the diff is wrong: send a specific correction or reset.',
         '',
-        '- Read code, grep, search — build full context before answering.',
-        '- Produce concrete plans: files to change, functions to modify, test strategy, risks.',
-        '- Do NOT edit files or run destructive commands unless explicitly asked.',
-        '- Be concise. End with a numbered action plan.',
+        '## Handling ambiguity',
+        'When requirements are unclear:',
+        '1. First, try to resolve it yourself — read code, check tests, grep for usage.',
+        '2. If ambiguity remains, ask the user ONE specific question.',
+        '   Prefer the question tool when discrete options exist (OpenCode shows choices in the UI).',
+        '   Bad:  "What should I do?"',
+        '   Good: "The `UserService` has both `deactivate()` and `softDelete()` —',
+        '          should the new endpoint use deactivation (reversible) or',
+        '          soft-delete (audit-logged)?"',
+        '3. Never block on multiple questions at once.',
+        '',
+        '## Correction and recovery',
+        'If the engineer produces wrong output:',
+        '1. First correction: send a specific, targeted fix instruction.',
+        '2. Second correction on the same issue: reset, clear the session,',
+        '   and rewrite the prompt incorporating lessons from both failures.',
+        'Never send three corrections for the same problem in one session.',
+        '',
+        '## Multi-step tasks',
+        '- Use todowrite / todoread to track steps in OpenCode; keep items concrete and few.',
+        '- Decompose large tasks into sequential focused instructions.',
+        '- Commit after each successful step (checkpoint for rollback).',
+        '- Tell the engineer to use subagents for independent parallel work.',
+        '- For complex design decisions, tell the engineer to "think hard".',
+        '- Prefer small diffs — they are easier to review and safer to ship.',
+        '',
+        '## Context management',
+        'Check the context snapshot returned by each send:',
+        '- Under 50%: proceed freely.',
+        '- 50–70%: finish current step, then evaluate if a fresh session is needed.',
+        '- Over 70%: use engineer_compact to reclaim context if the session',
+        '  still has useful state. Only clear if compaction is insufficient.',
+        '- Over 85%: clear the session immediately.',
+        'Use freshSession:true on engineer_send when switching to an unrelated',
+        'task or when the session context is contaminated. Prefer this over a manual',
+        'clear+send sequence — it is atomic and self-documenting.',
+        '',
+        '## Model and effort selection',
+        'Choose model and effort deliberately before each delegation:',
+        '- claude-opus-4-6 + high effort: default for most coding tasks.',
+        '- claude-sonnet-4-6 or claude-sonnet-4-5: faster/lighter work (simple renames,',
+        '  formatting, test scaffolding, quick investigations).',
+        '- effort "medium": acceptable for lighter tasks that do not require deep reasoning.',
+        '- effort "max": reserve for unusually hard problems (complex refactors,',
+        '  subtle concurrency bugs, large cross-cutting changes).',
+        "- Do not use Haiku for this plugin's coding-agent role.",
+        '',
+        '## Plan mode',
+        'When delegating with mode:"plan", the engineer returns a read-only',
+        'implementation plan. The plan MUST be returned inline in the assistant',
+        'response — do NOT write plan artifacts to disk, create files, or rely on',
+        'ExitPlanMode. Treat the returned finalText as the plan. If the plan is',
+        'acceptable, switch to mode:"free" and delegate the implementation steps.',
+        '',
+        '## Tools reference',
+        'todowrite / todoread — OpenCode session todo list (track multi-step work)',
+        'question             — OpenCode user prompt with options (clarify trade-offs)',
+        'engineer_send        — send instruction (creates or resumes session)',
+        '  freshSession:true  — clear session first (use for unrelated tasks)',
+        '  model / effort     — choose deliberately (see "Model and effort selection")',
+        'engineer_compact     — compress session context (preserves session state)',
+        'engineer_clear       — drop session, next send starts fresh',
+        'engineer_status      — context health snapshot',
+        'engineer_metadata    — inspect repo Claude config',
+        'engineer_sessions    — list sessions or read transcripts',
+        'engineer_runs        — list or inspect run records',
+        'git_diff             — review all uncommitted changes',
+        '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',
+        'Be candid about what you cannot do autonomously:',
+        '- 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).',
+        '- Access to external services or environments you cannot reach.',
+        'State the blocker, what you need, and a concrete suggestion to unblock.',
     ].join('\n'),
-    buildAgent: [
-        'You are a build specialist. Implement, test, and validate changes.',
+    engineerSessionPrompt: [
+        'You are directed by a manager acting as your technical lead.',
+        'Treat each message as a precise instruction from your manager.',
+        '',
+        '## Execution rules',
+        '- Execute instructions directly. Do not ask for clarification.',
+        '- Be concise — no preamble, no restating the task.',
+        '- Prefer targeted file reads over reading entire files.',
+        '- Use the Agent tool for independent parallel work.',
         '',
-        '- Execute instructions precisely. Follow existing repo conventions.',
-        '- Consider edge cases and include relevant tests.',
+        '## Quality expectations',
+        '- Follow existing repo conventions (naming, style, patterns).',
+        '- When creating or modifying code, consider edge cases and error handling.',
+        '- When modifying existing code, preserve surrounding style and structure.',
+        '- If asked to implement a feature, include relevant tests unless told otherwise.',
         '- Run tests/lint/typecheck when instructed; report exact output on failure.',
-        '- Do NOT run git commit, git push, git reset, git checkout, or git stash.',
+        '',
+        '## Git boundary — do NOT run these commands:',
+        'git commit, git push, git reset, git checkout, git stash.',
+        'The manager handles all git operations externally.',
+        '',
+        '## Reporting',
         '- End with a brief verification summary: what was done, what was verified.',
+        '- Report blockers immediately with specifics: file, line, error message.',
+        '- If a task is partially complete, state exactly what remains.',
     ].join('\n'),
+    modePrefixes: {
+        plan: [
+            '[PLAN MODE] You are in read-only planning mode. Do NOT create or edit any files.',
+            'Do NOT use ExitPlanMode or write plan 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 potential risks. End with a numbered step-by-step plan.',
+            'Return the entire plan inline in your response text.',
+        ].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.',
+    },
 };

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

@@ -0,0 +1,14 @@
+import type { PersistentRunRecord } from '../types/contracts.js';
+export declare class FileRunStateStore {
+    private readonly baseDirectoryName;
+    private readonly writeQueues;
+    constructor(baseDirectoryName?: string);
+    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;
+    private enqueueWrite;
+}

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

@@ -0,0 +1,87 @@
+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();
+    constructor(baseDirectoryName = '.claude-manager') {
+        this.baseDirectoryName = baseDirectoryName;
+    }
+    async saveRun(run) {
+        await this.enqueueWrite(this.getRunKey(run.cwd, run.id), async () => {
+            const runPath = this.getRunPath(run.cwd, run.id);
+            await fs.mkdir(path.dirname(runPath), { recursive: true });
+            await writeJsonAtomically(runPath, run);
+        });
+    }
+    async getRun(cwd, runId) {
+        const runPath = this.getRunPath(cwd, runId);
+        try {
+            const content = await fs.readFile(runPath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async listRuns(cwd) {
+        const runsDirectory = this.getRunsDirectory(cwd);
+        try {
+            const entries = await fs.readdir(runsDirectory);
+            const runs = await Promise.all(entries
+                .filter((entry) => entry.endsWith('.json'))
+                .map(async (entry) => {
+                const content = await fs.readFile(path.join(runsDirectory, entry), 'utf8');
+                return JSON.parse(content);
+            }));
+            return runs.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async updateRun(cwd, runId, update) {
+        return this.enqueueWrite(this.getRunKey(cwd, runId), async () => {
+            const existingRun = await this.getRun(cwd, runId);
+            if (!existingRun) {
+                throw new Error(`Run ${runId} does not exist.`);
+            }
+            const updatedRun = update(existingRun);
+            const runPath = this.getRunPath(cwd, runId);
+            await fs.mkdir(path.dirname(runPath), { recursive: true });
+            await writeJsonAtomically(runPath, updatedRun);
+            return updatedRun;
+        });
+    }
+    getRunKey(cwd, runId) {
+        return `${cwd}:${runId}`;
+    }
+    getRunsDirectory(cwd) {
+        return path.join(cwd, this.baseDirectoryName, 'runs');
+    }
+    getRunPath(cwd, runId) {
+        return path.join(this.getRunsDirectory(cwd), `${runId}.json`);
+    }
+    async enqueueWrite(key, operation) {
+        const previousOperation = this.writeQueues.get(key) ?? Promise.resolve();
+        const resultPromise = previousOperation
+            .catch(() => undefined)
+            .then(operation);
+        const settledPromise = resultPromise.then(() => undefined, () => undefined);
+        this.writeQueues.set(key, settledPromise);
+        try {
+            return await resultPromise;
+        }
+        finally {
+            if (this.writeQueues.get(key) === settledPromise) {
+                this.writeQueues.delete(key);
+            }
+        }
+    }
+}

package/dist/state/transcript-store.d.ts

@@ -0,0 +1,15 @@
+import type { ClaudeSessionEvent } from '../types/contracts.js';
+export declare class TranscriptStore {
+    private readonly baseDirectoryName;
+    constructor(baseDirectoryName?: string);
+    /**
+     * Append new events to the transcript file for the given session.
+     * Creates the file if it does not exist. Strips trailing partials before persisting.
+     */
+    appendEvents(cwd: string, sessionId: string, newEvents: ClaudeSessionEvent[]): Promise<void>;
+    /**
+     * Read all persisted transcript events for a session.
+     */
+    readEvents(cwd: string, sessionId: string): Promise<ClaudeSessionEvent[]>;
+    private getTranscriptPath;
+}

package/dist/state/transcript-store.js

@@ -0,0 +1,44 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { appendTranscriptEvents, stripTrailingPartials, } from '../util/transcript-append.js';
+import { isFileNotFoundError, writeJsonAtomically, } from '../util/fs-helpers.js';
+export class TranscriptStore {
+    baseDirectoryName;
+    constructor(baseDirectoryName = '.claude-manager') {
+        this.baseDirectoryName = baseDirectoryName;
+    }
+    /**
+     * Append new events to the transcript file for the given session.
+     * Creates the file if it does not exist. Strips trailing partials before persisting.
+     */
+    async appendEvents(cwd, sessionId, newEvents) {
+        if (newEvents.length === 0) {
+            return;
+        }
+        const filePath = this.getTranscriptPath(cwd, sessionId);
+        const existing = await this.readEvents(cwd, sessionId);
+        const merged = appendTranscriptEvents(existing, newEvents);
+        const cleaned = stripTrailingPartials(merged);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await writeJsonAtomically(filePath, cleaned);
+    }
+    /**
+     * Read all persisted transcript events for a session.
+     */
+    async readEvents(cwd, sessionId) {
+        const filePath = this.getTranscriptPath(cwd, sessionId);
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (isFileNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    getTranscriptPath(cwd, sessionId) {
+        return path.join(cwd, this.baseDirectoryName, 'transcripts', `${sessionId}.json`);
+    }
+}

package/dist/types/contracts.d.ts

@@ -0,0 +1,216 @@
+export interface ManagerPromptRegistry {
+    ctoSystemPrompt: string;
+    managerSystemPrompt: string;
+    engineerSessionPrompt: string;
+    modePrefixes: {
+        plan: string;
+        free: string;
+    };
+    contextWarnings: {
+        moderate: string;
+        high: string;
+        critical: string;
+    };
+}
+export type ClaudeSettingSource = 'user' | 'project' | 'local';
+export type SessionMode = 'plan' | 'free';
+export interface ClaudeCommandMetadata {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    source: 'sdk' | 'skill' | 'command';
+    path?: string;
+}
+export interface ClaudeSkillMetadata {
+    name: string;
+    description: string;
+    path: string;
+    source: 'skill' | 'command';
+}
+export interface ClaudeHookMetadata {
+    name: string;
+    matcher?: string;
+    sourcePath: string;
+    commandCount: number;
+}
+export interface ClaudeAgentMetadata {
+    name: string;
+    description: string;
+    model?: string;
+    source: 'sdk' | 'filesystem';
+}
+export interface ClaudeMetadataSnapshot {
+    collectedAt: string;
+    cwd: string;
+    commands: ClaudeCommandMetadata[];
+    skills: ClaudeSkillMetadata[];
+    hooks: ClaudeHookMetadata[];
+    agents: ClaudeAgentMetadata[];
+    claudeMdPath?: string;
+    settingsPaths: string[];
+}
+export interface ClaudeSessionEvent {
+    type: 'init' | 'assistant' | 'partial' | 'user' | 'tool_call' | 'tool_progress' | 'tool_summary' | 'status' | 'system' | 'result' | 'error';
+    sessionId?: string;
+    text: string;
+    turns?: number;
+    totalCostUsd?: number;
+    /** Present on live SDK-normalized events; omitted when compact-persisted to save space. */
+    rawType?: string;
+}
+export interface RunClaudeSessionInput {
+    cwd: string;
+    prompt: string;
+    systemPrompt?: string;
+    model?: string;
+    effort?: 'low' | 'medium' | 'high' | 'max';
+    mode?: SessionMode;
+    permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk';
+    /** Merged with `Skill` by the SDK adapter unless `Skill` appears in `disallowedTools`. */
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    continueSession?: boolean;
+    resumeSessionId?: string;
+    forkSession?: boolean;
+    persistSession?: boolean;
+    includePartialMessages?: boolean;
+    settingSources?: ClaudeSettingSource[];
+    maxTurns?: number;
+    abortSignal?: AbortSignal;
+}
+export interface ClaudeSessionRunResult {
+    sessionId?: string;
+    events: ClaudeSessionEvent[];
+    finalText: string;
+    turns?: number;
+    totalCostUsd?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    contextWindowSize?: number;
+}
+export interface ClaudeSessionSummary {
+    sessionId: string;
+    summary: string;
+    cwd?: string;
+    gitBranch?: string;
+    createdAt?: number;
+    lastModified: number;
+}
+export interface ClaudeSessionTranscriptMessage {
+    role: 'user' | 'assistant';
+    sessionId: string;
+    messageId: string;
+    text: string;
+}
+export interface ClaudeCapabilitySnapshot {
+    commands: ClaudeCommandMetadata[];
+    agents: ClaudeAgentMetadata[];
+    models: string[];
+}
+export type ContextWarningLevel = 'ok' | 'moderate' | 'high' | 'critical';
+export interface SessionContextSnapshot {
+    sessionId: string | null;
+    totalTurns: number;
+    totalCostUsd: number;
+    latestInputTokens: number | null;
+    latestOutputTokens: number | null;
+    contextWindowSize: number | null;
+    estimatedContextPercent: number | null;
+    warningLevel: ContextWarningLevel;
+    compactionCount: number;
+}
+export interface GitDiffResult {
+    hasDiff: boolean;
+    diffText: string;
+    stats: {
+        filesChanged: number;
+        insertions: number;
+        deletions: number;
+    };
+}
+export interface GitOperationResult {
+    success: boolean;
+    output: string;
+    error?: string;
+}
+export interface ActiveSessionState {
+    sessionId: string;
+    cwd: string;
+    startedAt: string;
+    totalTurns: number;
+    totalCostUsd: number;
+    estimatedContextPercent: number | null;
+    contextWindowSize: number | null;
+    latestInputTokens: number | null;
+}
+export type PersistentRunStatus = 'running' | 'completed' | 'failed';
+export interface PersistentRunMessageRecord {
+    timestamp: string;
+    direction: 'sent' | 'received';
+    text: string;
+    turns?: number;
+    totalCostUsd?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+}
+export interface PersistentRunActionRecord {
+    timestamp: string;
+    type: 'git_diff' | 'git_commit' | 'git_reset' | 'compact' | 'clear';
+    result: string;
+}
+export interface PersistentRunRecord {
+    id: string;
+    cwd: string;
+    task: string;
+    status: PersistentRunStatus;
+    createdAt: string;
+    updatedAt: string;
+    sessionId: string | null;
+    sessionHistory: string[];
+    messages: PersistentRunMessageRecord[];
+    actions: PersistentRunActionRecord[];
+    commits: string[];
+    context: SessionContextSnapshot;
+    finalSummary?: string;
+}
+export interface PersistentRunResult {
+    run: PersistentRunRecord;
+}
+export interface LiveTailEvent {
+    type: 'line' | 'error' | 'end';
+    sessionId: string;
+    data?: unknown;
+    rawLine?: string;
+    error?: string;
+}
+export interface ToolOutputPreview {
+    toolUseId: string;
+    content: string;
+    isError: boolean;
+}
+export interface ToolApprovalRule {
+    id: string;
+    description?: string;
+    /** Tool name — exact match or glob with * wildcard */
+    toolPattern: string;
+    /** Optional substring match against JSON-serialized tool input */
+    inputPattern?: string;
+    action: 'allow' | 'deny';
+    denyMessage?: string;
+}
+export interface ToolApprovalPolicy {
+    rules: ToolApprovalRule[];
+    defaultAction: 'allow' | 'deny';
+    defaultDenyMessage?: string;
+    enabled: boolean;
+}
+export interface ToolApprovalDecision {
+    timestamp: string;
+    toolName: string;
+    inputPreview: string;
+    title?: string;
+    matchedRuleId: string;
+    action: 'allow' | 'deny';
+    denyMessage?: string;
+    agentId?: string;
+}

package/dist/types/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/util/fs-helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function writeJsonAtomically(filePath: string, data: unknown): Promise<void>;
+export declare function isFileNotFoundError(error: unknown): error is NodeJS.ErrnoException;

package/dist/util/fs-helpers.js

@@ -0,0 +1,12 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+export 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);
+}
+export function isFileNotFoundError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}

package/dist/util/transcript-append.d.ts

@@ -0,0 +1,7 @@
+import type { ClaudeSessionEvent } from '../types/contracts.js';
+export declare function stripTrailingPartials(events: ClaudeSessionEvent[]): ClaudeSessionEvent[];
+/**
+ * Append transcript events for run-state persistence: at most one trailing
+ * `partial`, dropped whenever a non-partial event is appended.
+ */
+export declare function appendTranscriptEvents(events: ClaudeSessionEvent[], incoming: ClaudeSessionEvent[]): ClaudeSessionEvent[];