@lucasreiners/lead 0.1.0

package/dist/features/workflow/context.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowInstance, WorkflowStepDefinition, WorkflowDefinition } from "./types";
+/**
+ * Substitute template variables in a prompt string.
+ * Supported variables:
+ *   {{instance.goal}}          — user's stated goal
+ *   {{instance.slug}}          — URL-safe slug of goal
+ *   {{instance.instance_id}}   — workflow instance ID
+ *   {{artifacts.X}}            — artifact value by name
+ *   {{step.id}}                — current step ID
+ *   {{step.name}}              — current step name
+ */
+export declare function substituteTemplateVars(template: string, instance: WorkflowInstance, stepDef: WorkflowStepDefinition): string;
+/**
+ * Build the full step context prompt including goal, step info, and previous artifacts.
+ */
+export declare function buildStepContext(instance: WorkflowInstance, stepDef: WorkflowStepDefinition, definition: WorkflowDefinition): string;

package/dist/features/workflow/discovery.d.ts

@@ -0,0 +1,19 @@
+import type { DiscoveredWorkflow } from "./types";
+/**
+ * Parse and validate a workflow definition from a JSONC file.
+ * Returns null if invalid.
+ */
+export declare function parseWorkflowFile(filePath: string, scope: DiscoveredWorkflow["scope"]): DiscoveredWorkflow | null;
+export interface DiscoverWorkflowsOptions {
+    projectDirectory: string;
+    customDirs?: string[];
+}
+/**
+ * Discover workflow definitions from:
+ * 1. User: ~/.config/opencode/workflows/
+ * 2. Project: {project}/.opencode/workflows/
+ * 3. Custom dirs (from config)
+ *
+ * Later scopes override earlier ones by workflow name.
+ */
+export declare function discoverWorkflows(options: DiscoverWorkflowsOptions): DiscoveredWorkflow[];

package/dist/features/workflow/engine.d.ts

@@ -0,0 +1,19 @@
+import type { WorkflowDefinition, EngineAction, CompletionContext } from "./types";
+export interface StartWorkflowInput {
+    definition: WorkflowDefinition;
+    definitionPath: string;
+    goal: string;
+    sessionId: string;
+    directory: string;
+}
+export declare function startWorkflow(input: StartWorkflowInput): EngineAction;
+export interface CheckAndAdvanceInput {
+    directory: string;
+    context: Omit<CompletionContext, "config" | "artifacts">;
+    definition: WorkflowDefinition;
+}
+export declare function checkAndAdvance(input: CheckAndAdvanceInput): EngineAction;
+export declare function pauseWorkflow(directory: string, reason?: string): boolean;
+export declare function resumeWorkflow(directory: string, definition: WorkflowDefinition): EngineAction;
+export declare function skipStep(directory: string, definition: WorkflowDefinition): EngineAction;
+export declare function abortWorkflow(directory: string): boolean;

package/dist/features/workflow/hook.d.ts

@@ -0,0 +1,45 @@
+import type { EngineAction } from "./types";
+export interface RunWorkflowInput {
+    promptText: string;
+    sessionId: string;
+    directory: string;
+    customDirs?: string[];
+}
+export interface RunWorkflowResult {
+    handled: boolean;
+    action?: EngineAction;
+    message?: string;
+}
+/**
+ * Parse /run-workflow args: `<workflow-name> "goal text"` or `<workflow-name> goal text`
+ */
+export declare function parseWorkflowArgs(args: string): {
+    workflowName: string | null;
+    goal: string | null;
+};
+/**
+ * Handle /run-workflow command.
+ * Supports starting new workflows and resuming active ones.
+ */
+export declare function handleRunWorkflow(input: RunWorkflowInput): Promise<RunWorkflowResult>;
+export interface WorkflowContinuationInput {
+    sessionId: string;
+    directory: string;
+    lastAssistantMessage?: string;
+    lastUserMessage?: string;
+    customDirs?: string[];
+}
+export interface WorkflowContinuationResult {
+    continuationPrompt: string | null;
+    switchAgent: string | null;
+}
+/**
+ * Check if active workflow step is complete and advance.
+ * Called on session.idle hook.
+ */
+export declare function checkWorkflowContinuation(input: WorkflowContinuationInput): Promise<WorkflowContinuationResult>;
+/**
+ * Handle inline workflow commands in user messages.
+ * Returns a result message or null if not a workflow command.
+ */
+export declare function handleWorkflowCommand(message: string, directory: string): string | null;

package/dist/features/workflow/index.d.ts

@@ -0,0 +1,9 @@
+export type { StepType, CompletionMethod, StepStatus, WorkflowStatus, OnRejectAction, CompletionConfig, StepArtifactRef, StepArtifacts, WorkflowStepDefinition, WorkflowDefinition, StepState, WorkflowInstance, ActiveInstancePointer, CompletionContext, CompletionCheckResult, EngineAction, DiscoveredWorkflow, } from "./types";
+export { WorkflowDefinitionSchema } from "./schema";
+export { discoverWorkflows } from "./discovery";
+export { saveWorkflowInstance, loadWorkflowInstance, loadActiveInstance, setActiveInstance, clearActiveInstance, listInstanceIds, } from "./storage";
+export { buildStepContext, substituteTemplateVars } from "./context";
+export { checkStepCompletion } from "./completion";
+export { startWorkflow, checkAndAdvance, pauseWorkflow, resumeWorkflow, skipStep, abortWorkflow, } from "./engine";
+export { handleRunWorkflow, checkWorkflowContinuation, handleWorkflowCommand, parseWorkflowArgs, } from "./hook";
+export { executeWorkflowCommand } from "./commands";

package/dist/features/workflow/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export declare const WorkflowDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodLiteral<1>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            interactive: "interactive";
+            autonomous: "autonomous";
+            gate: "gate";
+        }>;
+        agent: z.ZodString;
+        prompt: z.ZodString;
+        completion: z.ZodObject<{
+            method: z.ZodEnum<{
+                user_confirm: "user_confirm";
+                plan_created: "plan_created";
+                plan_complete: "plan_complete";
+                review_verdict: "review_verdict";
+                agent_signal: "agent_signal";
+            }>;
+            plan_name: z.ZodOptional<z.ZodString>;
+            keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        artifacts: z.ZodOptional<z.ZodObject<{
+            inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            outputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        on_reject: z.ZodOptional<z.ZodEnum<{
+            pause: "pause";
+            fail: "fail";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkflowDefinitionInput = z.input<typeof WorkflowDefinitionSchema>;

package/dist/features/workflow/storage.d.ts

@@ -0,0 +1,7 @@
+import type { WorkflowInstance } from "./types";
+export declare function saveWorkflowInstance(dir: string, instance: WorkflowInstance): void;
+export declare function loadWorkflowInstance(dir: string, instanceId: string): WorkflowInstance | null;
+export declare function loadActiveInstance(dir: string): WorkflowInstance | null;
+export declare function setActiveInstance(dir: string, instanceId: string): void;
+export declare function clearActiveInstance(dir: string): void;
+export declare function listInstanceIds(dir: string): string[];

package/dist/features/workflow/types.d.ts

@@ -0,0 +1,89 @@
+export type StepType = "interactive" | "autonomous" | "gate";
+export type CompletionMethod = "user_confirm" | "plan_created" | "plan_complete" | "review_verdict" | "agent_signal";
+export type StepStatus = "pending" | "active" | "awaiting_user" | "completed" | "failed" | "skipped";
+export type WorkflowStatus = "running" | "paused" | "completed" | "failed" | "cancelled";
+export type OnRejectAction = "pause" | "fail";
+export interface CompletionConfig {
+    method: CompletionMethod;
+    plan_name?: string;
+    keywords?: string[];
+}
+export interface StepArtifactRef {
+    name: string;
+    description?: string;
+}
+export interface StepArtifacts {
+    inputs?: StepArtifactRef[];
+    outputs?: StepArtifactRef[];
+}
+export interface WorkflowStepDefinition {
+    id: string;
+    name: string;
+    type: StepType;
+    agent: string;
+    prompt: string;
+    completion: CompletionConfig;
+    artifacts?: StepArtifacts;
+    on_reject?: OnRejectAction;
+}
+export interface WorkflowDefinition {
+    name: string;
+    description?: string;
+    version: number;
+    steps: WorkflowStepDefinition[];
+}
+export interface StepState {
+    id: string;
+    status: StepStatus;
+    started_at?: string;
+    completed_at?: string;
+    verdict?: "approve" | "reject";
+    error?: string;
+    artifacts?: Record<string, string>;
+    summary?: string;
+}
+export interface WorkflowInstance {
+    instance_id: string;
+    definition_id: string;
+    definition_name: string;
+    definition_path: string;
+    goal: string;
+    slug: string;
+    status: WorkflowStatus;
+    started_at: string;
+    ended_at?: string;
+    session_ids: string[];
+    current_step_id: string;
+    steps: Record<string, StepState>;
+    artifacts: Record<string, string>;
+    pause_reason?: string;
+}
+export interface ActiveInstancePointer {
+    instance_id: string;
+}
+export interface CompletionContext {
+    lastAssistantMessage?: string;
+    lastUserMessage?: string;
+    directory: string;
+    config: CompletionConfig;
+    artifacts: Record<string, string>;
+}
+export interface CompletionCheckResult {
+    complete: boolean;
+    verdict?: "approve" | "reject";
+    artifacts?: Record<string, string>;
+    summary?: string;
+    reason?: string;
+}
+export type EngineActionType = "inject_prompt" | "switch_agent" | "pause" | "complete" | "none";
+export interface EngineAction {
+    type: EngineActionType;
+    prompt?: string;
+    agent?: string;
+    reason?: string;
+}
+export interface DiscoveredWorkflow {
+    definition: WorkflowDefinition;
+    path: string;
+    scope: "project" | "user";
+}

package/dist/hooks/architect-md-only.d.ts

@@ -0,0 +1,11 @@
+import type { PolicyResult } from "../domain/policy/policy-result";
+export interface ArchitectGuardInput {
+    toolName: string;
+    args: Record<string, unknown>;
+    agentName?: string;
+}
+/**
+ * Check if an architect tool call violates the md-only rule.
+ * Returns deny if architect tries to write outside .lead/ or to non-.md files.
+ */
+export declare function checkArchitectWrite(input: ArchitectGuardInput): PolicyResult;

package/dist/hooks/compaction-recovery.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Compaction recovery hook.
+ * After context compaction, injects a recovery prompt with active work context.
+ * This ensures the agent doesn't lose track of ongoing work.
+ */
+export interface CompactionRecoveryOptions {
+    /** Current session ID */
+    sessionId: string;
+    /** Working directory */
+    directory: string;
+}
+export interface CompactionRecoveryResult {
+    /** Recovery prompt to inject, or null if no active work */
+    recoveryPrompt: string | null;
+}
+/**
+ * Build a recovery prompt after context compaction.
+ * Summarizes the current work state so the agent knows what it was doing.
+ */
+export declare function checkCompactionRecovery(options: CompactionRecoveryOptions): CompactionRecoveryResult;

package/dist/hooks/compaction-todo-preserver.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Compaction todo preserver.
+ * During session compaction, preserves active todo state so it isn't lost.
+ */
+import type { TodoItem } from "./todo-continuation-enforcer";
+/**
+ * Save the current todo state for a session before compaction.
+ */
+export declare function saveTodoStateForCompaction(sessionId: string, todos: TodoItem[]): void;
+/**
+ * Get the preserved todo state for a session after compaction.
+ */
+export declare function getPreservedTodoState(sessionId: string): TodoItem[] | null;
+/**
+ * Clear the preserved todo state for a session.
+ */
+export declare function clearPreservedTodoState(sessionId: string): void;
+/**
+ * Build a prompt that reminds the agent of its preserved todo state after compaction.
+ */
+export declare function buildTodoPreservationPrompt(sessionId: string): string | null;

package/dist/hooks/context-window-monitor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Context window monitor.
+ * Warns when token usage approaches model context limits.
+ */
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    contextWindow: number;
+}
+export type ContextWindowSeverity = "ok" | "warning" | "critical";
+export interface ContextWindowCheckResult {
+    severity: ContextWindowSeverity;
+    usagePercent: number;
+    message?: string;
+}
+export interface ContextWindowThresholds {
+    /** Percentage at which to warn (default 0.75) */
+    warningPercent?: number;
+    /** Percentage at which to issue critical warning (default 0.9) */
+    criticalPercent?: number;
+}
+/**
+ * Check if token usage is approaching context window limits.
+ * Returns severity and an optional warning message.
+ */
+export declare function checkContextWindow(usage: TokenUsage, thresholds?: ContextWindowThresholds): ContextWindowCheckResult;

package/dist/hooks/create-hooks.d.ts

@@ -0,0 +1,45 @@
+import { checkContextWindow } from "./context-window-monitor";
+import { createWriteGuard } from "./write-existing-file-guard";
+import { shouldApplyVariant, markApplied, markSessionCreated, clearSession } from "./first-message-variant";
+import { processMessageForKeywords } from "./keyword-detector";
+import { checkArchitectWrite } from "./architect-md-only";
+import { handleStartImplementation } from "./start-implementation-hook";
+import { checkContinuation } from "./work-continuation";
+import { checkCompactionRecovery } from "./compaction-recovery";
+import { buildVerificationReminder } from "./verification-reminder";
+import { applyTodoDescriptionOverride } from "./todo-description-override";
+import { checkStaleTodos } from "./todo-continuation-enforcer";
+import { buildTodoPreservationPrompt } from "./compaction-todo-preserver";
+import { captureToDoWrite } from "./todo-writer";
+import { updateTokenState } from "./session-token-state";
+import type { LeadConfig } from "../config/schema";
+import type { ResolvedContinuationConfig } from "../config/continuation";
+export interface CreateHooksArgs {
+    pluginConfig: LeadConfig;
+    continuation: ResolvedContinuationConfig;
+    directory: string;
+}
+export interface CreatedHooks {
+    checkContextWindow: typeof checkContextWindow;
+    createWriteGuard: typeof createWriteGuard;
+    shouldApplyVariant: typeof shouldApplyVariant;
+    markApplied: typeof markApplied;
+    markSessionCreated: typeof markSessionCreated;
+    clearSession: typeof clearSession;
+    processMessageForKeywords: typeof processMessageForKeywords;
+    checkArchitectWrite: typeof checkArchitectWrite;
+    handleStartImplementation: typeof handleStartImplementation;
+    checkContinuation: typeof checkContinuation;
+    checkCompactionRecovery: typeof checkCompactionRecovery;
+    buildVerificationReminder: typeof buildVerificationReminder;
+    applyTodoDescriptionOverride: typeof applyTodoDescriptionOverride;
+    checkStaleTodos: typeof checkStaleTodos;
+    buildTodoPreservationPrompt: typeof buildTodoPreservationPrompt;
+    captureToDoWrite: typeof captureToDoWrite;
+    updateTokenState: typeof updateTokenState;
+}
+/**
+ * Create all hook instances, respecting disabled_hooks configuration.
+ * Disabled hooks return null in the returned object.
+ */
+export declare function createHooks(args: CreateHooksArgs): CreatedHooks;

package/dist/hooks/first-message-variant.d.ts

@@ -0,0 +1,23 @@
+/**
+ * First message variant.
+ * Applies variant prompts to the first message in a session.
+ * Ensures that special context is only injected once per session.
+ */
+/**
+ * Check if a variant prompt should be applied for this session and agent.
+ * Returns true only on the first message in a new session.
+ */
+export declare function shouldApplyVariant(sessionId: string, _agentName?: string): boolean;
+/** Mark that the variant has been applied for this session */
+export declare function markApplied(sessionId: string): void;
+/** Mark that a session has been created (becomes eligible for variant) */
+export declare function markSessionCreated(sessionId: string): void;
+/** Clear tracking state for a session (e.g., when session ends) */
+export declare function clearSession(sessionId: string): void;
+/** Get the current state of session tracking (for testing) */
+export declare function getSessionState(): {
+    appliedSessions: Set<string>;
+    createdSessions: Set<string>;
+};
+/** Reset all state (for testing) */
+export declare function resetSessionState(): void;

package/dist/hooks/index.d.ts

@@ -0,0 +1,28 @@
+export { createHooks } from "./create-hooks";
+export type { CreateHooksArgs, CreatedHooks } from "./create-hooks";
+export { checkContextWindow } from "./context-window-monitor";
+export type { TokenUsage, ContextWindowSeverity, ContextWindowCheckResult, ContextWindowThresholds, } from "./context-window-monitor";
+export { createWriteGuard } from "./write-existing-file-guard";
+export type { WriteGuard, WriteGuardCheckResult } from "./write-existing-file-guard";
+export { shouldInjectRules, getRulesForFile } from "./rules-injector";
+export { shouldApplyVariant, markApplied, markSessionCreated, clearSession, } from "./first-message-variant";
+export { processMessageForKeywords } from "./keyword-detector";
+export type { DetectedKeyword, KeywordDetectionResult } from "./keyword-detector";
+export { checkArchitectWrite } from "./architect-md-only";
+export type { ArchitectGuardInput } from "./architect-md-only";
+export { handleStartImplementation } from "./start-implementation-hook";
+export type { StartImplementationOptions, StartImplementationResult } from "./start-implementation-hook";
+export { checkContinuation } from "./work-continuation";
+export type { WorkContinuationOptions, WorkContinuationResult } from "./work-continuation";
+export { checkCompactionRecovery } from "./compaction-recovery";
+export type { CompactionRecoveryOptions, CompactionRecoveryResult } from "./compaction-recovery";
+export { buildVerificationReminder } from "./verification-reminder";
+export type { VerificationReminderOptions, VerificationReminderResult, } from "./verification-reminder";
+export { applyTodoDescriptionOverride } from "./todo-description-override";
+export { checkStaleTodos } from "./todo-continuation-enforcer";
+export type { TodoItem, TodoContinuationResult } from "./todo-continuation-enforcer";
+export { saveTodoStateForCompaction, getPreservedTodoState, clearPreservedTodoState, buildTodoPreservationPrompt, } from "./compaction-todo-preserver";
+export { updateTokenState, getTokenState, resetTokenState } from "./session-token-state";
+export type { TokenStateEntry } from "./session-token-state";
+export { captureToDoWrite } from "./todo-writer";
+export type { TodoWriterHookInput, TodoWriterHookResult } from "./todo-writer";

package/dist/hooks/keyword-detector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Keyword detector.
+ * Detects workflow-related keywords in user messages.
+ */
+export type DetectedKeyword = "run-workflow" | "implement" | "workflow-pause" | "workflow-skip" | "workflow-abort" | "workflow-status" | "workflow-resume";
+export interface KeywordDetectionResult {
+    /** All detected keywords */
+    keywords: DetectedKeyword[];
+    /** The primary (first detected) keyword */
+    primary?: DetectedKeyword;
+    /** Arguments following the primary keyword */
+    args?: string;
+}
+/**
+ * Process a user message and detect workflow-related keywords.
+ */
+export declare function processMessageForKeywords(message: string): KeywordDetectionResult;

package/dist/hooks/rules-injector.d.ts

@@ -0,0 +1,16 @@
+export interface RulesInjectorResult {
+    /** Combined rules content to inject */
+    content: string;
+    /** Paths of rules files that matched */
+    matchedRules: string[];
+}
+/**
+ * Check if a tool/file combination should receive rules injection.
+ * Rules are injected for file-reading and file-writing tools.
+ */
+export declare function shouldInjectRules(toolName: string, _filePath?: string): boolean;
+/**
+ * Get rules content matching the given file path from the rules directory.
+ * Rules files in `.opencode/rules/` with names that match the file's extension or path.
+ */
+export declare function getRulesForFile(filePath: string, directory: string): Promise<RulesInjectorResult>;

package/dist/hooks/session-token-state.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Session token state tracker.
+ * Tracks token usage per session for context window monitoring.
+ */
+export interface TokenStateEntry {
+    sessionId: string;
+    inputTokens: number;
+    outputTokens: number;
+    contextWindow: number;
+    lastUpdatedAt: Date;
+}
+/**
+ * Update token usage for a session.
+ */
+export declare function updateTokenState(sessionId: string, delta: {
+    inputTokens?: number;
+    outputTokens?: number;
+    contextWindow?: number;
+}): TokenStateEntry;
+/**
+ * Get current token state for a session.
+ */
+export declare function getTokenState(sessionId: string): TokenStateEntry | null;
+/**
+ * Reset token state for a session.
+ */
+export declare function resetTokenState(sessionId: string): void;
+/**
+ * Get all tracked sessions.
+ */
+export declare function getAllTokenStates(): TokenStateEntry[];

package/dist/hooks/start-implementation-hook.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Start-implementation hook.
+ * Handles the `/implement` command.
+ * Finds the plan file, creates work state, and returns a prompt directing executor to begin.
+ */
+export interface StartImplementationOptions {
+    /** The command arguments (plan name or path) */
+    args: string;
+    /** Current session ID */
+    sessionId: string;
+    /** Working directory */
+    directory: string;
+    /** Optional git SHA at start */
+    startSha?: string;
+}
+export interface StartImplementationResult {
+    /** Prompt to inject into the session */
+    prompt: string | null;
+    /** Error message if the command failed */
+    error?: string;
+}
+/**
+ * Handle the /implement command.
+ * Finds the plan file and creates work state with reference to it.
+ */
+export declare function handleStartImplementation(options: StartImplementationOptions): Promise<StartImplementationResult>;

package/dist/hooks/start-work-hook.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Start-work hook.
+ * Handles the `/implement` command.
+ * Finds the plan file, creates work state, and returns a prompt directing executor to begin.
+ */
+export interface StartWorkOptions {
+    /** The command arguments (plan name or path) */
+    args: string;
+    /** Current session ID */
+    sessionId: string;
+    /** Working directory */
+    directory: string;
+    /** Optional git SHA at start */
+    startSha?: string;
+}
+export interface StartWorkResult {
+    /** Prompt to inject into the session */
+    prompt: string | null;
+    /** Error message if the command failed */
+    error?: string;
+}
+/**
+ * Handle the /implement command.
+ * Finds the plan file and creates work state with reference to it.
+ */
+export declare function handleStartWork(options: StartWorkOptions): Promise<StartWorkResult>;

package/dist/hooks/todo-continuation-enforcer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Todo continuation enforcer.
+ * Detects stale in_progress todos and prompts the agent to complete or update them.
+ */
+export interface TodoItem {
+    content: string;
+    status: "pending" | "in_progress" | "completed" | "cancelled";
+    priority: "high" | "medium" | "low";
+}
+export interface TodoContinuationResult {
+    /** Whether stale in_progress todos were detected */
+    hasStale: boolean;
+    /** Prompt to inject if stale todos detected */
+    prompt: string | null;
+    /** The stale todos that were found */
+    staleTodos: TodoItem[];
+}
+/**
+ * Check for stale in_progress todos and return a prompt if found.
+ * A stale todo is one that has been in_progress but the agent hasn't completed it.
+ */
+export declare function checkStaleTodos(todos: TodoItem[]): TodoContinuationResult;

package/dist/hooks/todo-description-override.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Todo description override.
+ * Overrides the TodoWrite tool description with more specific guidance
+ * for the executor agent's todo discipline.
+ */
+/**
+ * Apply todo description override for the TodoWrite tool.
+ * Returns the modified description if applicable.
+ */
+export declare function applyTodoDescriptionOverride(toolName: string, originalDescription: string): string;

package/dist/hooks/todo-writer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Todo writer hook.
+ * Intercepts todo write operations for state tracking and validation.
+ */
+import type { TodoItem } from "./todo-continuation-enforcer";
+export interface TodoWriterHookInput {
+    toolName: string;
+    args: Record<string, unknown>;
+    sessionId: string;
+}
+export interface TodoWriterHookResult {
+    /** Whether this was a todo write operation */
+    captured: boolean;
+    /** The todo items that were written */
+    todos?: TodoItem[];
+}
+/**
+ * Intercept a tool call and capture todo state if it's a TodoWrite operation.
+ */
+export declare function captureToDoWrite(input: TodoWriterHookInput): TodoWriterHookResult;

package/dist/hooks/verification-reminder.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Verification reminder.
+ * Reminds agents to run verification steps after implementation tasks.
+ */
+export interface VerificationReminderOptions {
+    /** The tool that was just executed */
+    toolName: string;
+    /** The agent that executed it */
+    agentName?: string;
+    /** Working directory */
+    directory: string;
+}
+export interface VerificationReminderResult {
+    /** Reminder text to inject, or null if not applicable */
+    reminderText: string | null;
+}
+/**
+ * Build a verification reminder after implementation tool use.
+ * Only fires for lead-dev/engineer agents after write/edit/bash tools.
+ */
+export declare function buildVerificationReminder(options: VerificationReminderOptions): VerificationReminderResult;