@anyi61/codex-claude-delegate-mcp 0.1.0

package/dist/schema.d.ts

@@ -0,0 +1,779 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+export type EnvStatus = "set" | "set-redacted" | "present-in-parent-stripped" | "unset";
+export interface ClaudeStatusInput {
+    cwd: string;
+}
+export interface ClaudeQueryInput {
+    task: string;
+    cwd: string;
+    instruction_files?: string[];
+    timeout_sec?: number;
+    max_turns?: number;
+    fast?: boolean;
+    resume?: boolean;
+}
+export interface ClaudeReviewInput {
+    task: string;
+    cwd: string;
+    diff?: string;
+    instruction_files?: string[];
+    files?: string[];
+    timeout_sec?: number;
+    max_turns?: number;
+}
+export interface ClaudeImplementInput {
+    task: string;
+    cwd: string;
+    instruction_files?: string[];
+    files?: string[];
+    constraints?: string[];
+    timeout_sec?: number;
+    max_turns?: number;
+    session_key?: string;
+    fork_session?: boolean;
+    resume_latest?: boolean;
+    max_cost_usd?: number;
+    max_changed_files?: number;
+    worktreeName?: string;
+    dirty_policy?: "ask" | "committed" | "snapshot";
+}
+export type ClaudeTaskMode = "auto" | "read" | "review" | "write";
+export interface ClaudeTaskInput {
+    cwd: string;
+    task: string;
+    mode?: ClaudeTaskMode;
+    background?: boolean;
+    resume_latest?: boolean;
+    instruction_files?: string[];
+    /** @deprecated claude_task treats files as instruction_files, not apply scope. */
+    files?: string[];
+    constraints?: string[];
+    diff?: string;
+    timeout_sec?: number;
+    dirty_policy?: "ask" | "committed" | "snapshot";
+}
+export type BackgroundJobType = "query" | "review" | "implement" | "apply" | "cleanup";
+export type BackgroundJobStatus = "queued" | "running" | "succeeded" | "failed" | "cancelled";
+export type BackgroundJobStaleState = "fresh" | "stale_candidate" | "stale";
+export interface BackgroundJobSummary {
+    job_id: string;
+    type: BackgroundJobType;
+    status: BackgroundJobStatus;
+    result_status?: RunLogStatus;
+    cwd: string;
+    created_at: string;
+    updated_at: string;
+    heartbeat_at?: string;
+    last_wait_at?: string;
+    last_wait_recommended_delay_ms?: number;
+    fingerprint?: string;
+    pid?: number;
+    run_id?: string;
+    worktree_name?: string;
+    summary?: string;
+    error?: string;
+}
+export interface BackgroundJobEnqueueResult {
+    job: BackgroundJobSummary;
+    deduped?: boolean;
+    do_not_start_duplicate_job?: boolean;
+    message?: string;
+    next_actions?: WorkflowNextAction[];
+}
+export interface ClaudeJobsInput {
+    cwd: string;
+    limit?: number;
+    status?: BackgroundJobStatus;
+    type?: BackgroundJobType;
+}
+export interface ClaudeJobsResult {
+    entries: BackgroundJobSummary[];
+}
+export interface ClaudeJobResultInput {
+    cwd: string;
+    job_id: string;
+}
+export type ClaudeResultPrefer = "latest-job" | "latest-run" | "latest-implement" | "latest-review";
+export interface ClaudeResultInput {
+    cwd: string;
+    job_id?: string;
+    run_id?: string;
+    prefer?: ClaudeResultPrefer;
+}
+export interface ClaudeJobWaitInput {
+    cwd: string;
+    job_id: string;
+    not_before?: string;
+}
+export interface ClaudeJobWaitResult {
+    job: BackgroundJobSummary;
+    result?: Record<string, unknown>;
+    status: BackgroundJobStatus;
+    summary: string;
+    waiting: boolean;
+    timed_out: boolean;
+    do_not_start_duplicate_job: boolean;
+    poll_too_soon?: boolean;
+    recommended_delay_ms?: number;
+    remaining_delay_ms?: number;
+    next_allowed_poll_at?: string;
+    age_ms: number;
+    heartbeat_age_ms?: number;
+    stale_state: BackgroundJobStaleState;
+    next_actions: WorkflowNextAction[];
+}
+export interface ClaudeJobCancelInput {
+    cwd: string;
+    job_id: string;
+}
+export interface ClaudeJobCleanupInput {
+    cwd: string;
+    older_than_hours?: number;
+    dry_run?: boolean;
+    limit?: number;
+}
+export interface BackgroundJobCleanupEntry {
+    job_id: string;
+    type: BackgroundJobType;
+    status: BackgroundJobStatus;
+    updated_at: string;
+    removed: boolean;
+    summary?: string;
+    error?: string;
+}
+export interface ClaudeJobCleanupResult {
+    dry_run: boolean;
+    matched_count: number;
+    removed_count: number;
+    failed_count: number;
+    entries: BackgroundJobCleanupEntry[];
+}
+export interface WorkflowSessionSummary {
+    session_id: string;
+    type: "query" | "review" | "implement";
+    repo_path?: string;
+    last_used?: string;
+    use_count?: number;
+    summary?: string;
+    requested_session_id?: string | null;
+    returned_session_id?: string | null;
+    resumed?: boolean;
+    forked?: boolean;
+    source: "run" | "store";
+}
+export interface WorkflowNextAction {
+    tool: string;
+    reason: string;
+    args?: Record<string, unknown>;
+}
+export interface ClaudeResultResult {
+    source_type: "job" | "run";
+    summary: string;
+    job?: BackgroundJobSummary;
+    run?: RunLogEntrySummary;
+    session?: WorkflowSessionSummary;
+    result?: Record<string, unknown>;
+    related_runs?: {
+        apply_run_id?: string;
+        cleanup_run_id?: string;
+    };
+    do_not_start_duplicate_job?: boolean;
+    next_actions: WorkflowNextAction[];
+}
+export interface ClaudeWorkspaceStatusInput {
+    cwd: string;
+    limit?: number;
+    include_terminal?: boolean;
+}
+export interface ClaudeSetupInput {
+    cwd: string;
+    configure_allow_root?: boolean;
+}
+export type ClaudeReviewGateAction = "status" | "enable" | "disable";
+export interface ClaudeReviewGateInput {
+    cwd: string;
+    action?: ClaudeReviewGateAction;
+}
+export interface DelegatedWorktreeSummary {
+    worktree_name: string;
+    worktree_path: string;
+    updated_at?: string;
+    stale: boolean;
+    orphaned?: boolean;
+}
+export interface WorkspaceAttentionItem {
+    kind: "queued_job" | "apply_blocked" | "stale_worktree" | "orphan_worktree";
+    severity: "info" | "warning";
+    message: string;
+}
+export interface ClaudeWorkspaceStatusResult {
+    workspace_root: string;
+    running_jobs: BackgroundJobSummary[];
+    queued_jobs: BackgroundJobSummary[];
+    recent_terminal_jobs: BackgroundJobSummary[];
+    recent_runs: RunLogEntrySummary[];
+    latest_sessions: WorkflowSessionSummary[];
+    delegated_worktrees: DelegatedWorktreeSummary[];
+    counts: {
+        running_jobs: number;
+        queued_jobs: number;
+        terminal_jobs: number;
+        recent_runs: number;
+        delegated_worktrees: number;
+        stale_worktrees: number;
+        orphan_worktrees: number;
+        apply_blocked_runs: number;
+    };
+    do_not_start_duplicate_job?: boolean;
+    next_actions?: WorkflowNextAction[];
+    attention_items: WorkspaceAttentionItem[];
+}
+export interface ReviewGateState {
+    workspace_root: string;
+    config_path: string;
+    hook_manifest_path: string;
+    hook_script_path: string;
+    hook_installed: boolean;
+    enabled: boolean;
+    mode: "soft-stop";
+    pending_review: boolean;
+    updated_at?: string;
+    last_write_at?: string;
+    last_review_at?: string;
+}
+export interface ClaudeReviewGateResult extends ReviewGateState {
+    action: ClaudeReviewGateAction;
+    changed: boolean;
+    summary: string;
+    next_steps: string[];
+}
+export interface ClaudeSetupResult {
+    workspace_root: string;
+    allow_root_configuration?: Record<string, unknown>;
+    review_gate: ReviewGateState;
+    claude_available: boolean;
+    claude_version: string | null;
+    auth_status: "ok" | "missing" | "unknown";
+    git_available: boolean;
+    worktree_capable: boolean;
+    cwd_valid: boolean;
+    cwd_is_git_repo: boolean;
+    errors: string[];
+    next_steps: string[];
+}
+export interface ClaudeTaskResult {
+    delegated_mode: Exclude<ClaudeTaskMode, "auto">;
+    summary: string;
+    job?: BackgroundJobSummary;
+    result?: Record<string, unknown>;
+    session?: WorkflowSessionSummary;
+    deduped?: boolean;
+    do_not_start_duplicate_job?: boolean;
+    warnings?: string[];
+    next_actions: WorkflowNextAction[];
+}
+export interface TestResult {
+    ran: boolean;
+    command?: string;
+    passed?: boolean;
+    output_tail?: string;
+}
+export interface ClaudeReport {
+    status: "success" | "failed" | "partial" | "needs_user";
+    summary: string;
+    changed_files: string[];
+    commands_run: string[];
+    tests: TestResult;
+    risks: string[];
+    next_steps: string[];
+}
+export interface ResourceLimits {
+    max_cost_usd?: number;
+    max_changed_files?: number;
+    actual_changed_files: number;
+    changed_files_exceeded: boolean;
+    warnings: string[];
+}
+export interface ObserveScope {
+    requested_files?: string[];
+    out_of_scope_files: string[];
+    scope_exceeded: boolean;
+    warnings: string[];
+}
+export interface ServerObserved {
+    repo_root?: string;
+    worktree_name?: string;
+    changed_files: string[];
+    diff_stat: string;
+    diff_name_only: string;
+    base_commit?: string;
+    head_commit?: string;
+    git_status_short?: string;
+    worktree_path?: string;
+    resource_limits?: ResourceLimits;
+    scope?: ObserveScope;
+}
+export interface ExecutionMetadata {
+    exit_code: number | null;
+    duration_ms: number;
+    timed_out: boolean;
+    stdout_tail: string;
+    stderr_tail: string;
+    timings?: Record<string, number>;
+}
+export interface ToolEnvelope<T> {
+    status: "success" | "failed" | "partial" | "needs_user";
+    data?: T;
+    claude_report?: unknown;
+    server_observed?: unknown;
+    execution: ExecutionMetadata;
+    warnings: string[];
+}
+export declare function localExecution(startTime: number): ExecutionMetadata;
+export type ClaudeResult = ToolEnvelope<undefined>;
+export interface EnvironmentDiagnostics {
+    proxy_env_present: boolean;
+    http_proxy: EnvStatus;
+    https_proxy: EnvStatus;
+    no_proxy: EnvStatus;
+    anthropic_base_url: EnvStatus;
+    anthropic_auth_token: EnvStatus;
+    anthropic_api_key: EnvStatus;
+    local_proxy_host?: string;
+    local_proxy_port?: number;
+    local_proxy_reachable?: boolean;
+    local_proxy_error?: string;
+    likely_sandbox_blocked: boolean;
+    recommendation?: string;
+}
+export interface ClaudeStatusResult {
+    claude_available: boolean;
+    claude_version: string | null;
+    auth_status: string | null;
+    git_available: boolean;
+    worktree_capable: boolean;
+    cwd_valid: boolean;
+    cwd_is_git_repo: boolean;
+    delegated_worktrees_count: number;
+    delegated_worktrees: string[];
+    stale_worktrees_count: number;
+    errors: string[];
+    environment_diagnostics?: EnvironmentDiagnostics;
+    recent_runs?: RecentRunsSummary;
+}
+export interface SessionLog {
+    requested_session_id: string | null;
+    resumed: boolean;
+    forked: boolean;
+    returned_session_id: string | null;
+}
+export interface ClaudeApplyInput {
+    cwd: string;
+    worktree_path: string;
+    cleanup?: boolean;
+    preview?: boolean;
+    background?: boolean;
+    confirmed_by_user?: boolean;
+}
+export interface ApplyPlannedChange {
+    status: string;
+    file: string;
+}
+export interface ClaudeApplyResult {
+    applied_files: string[];
+    diff_stat: string;
+    cleanup_performed: boolean;
+    conflicts: string[];
+    error?: string;
+    preview?: boolean;
+    planned_changes?: ApplyPlannedChange[];
+}
+export interface ClaudeCleanupInput {
+    cwd: string;
+    older_than_hours?: number;
+    dry_run?: boolean;
+    background?: boolean;
+}
+export interface CleanupEntry {
+    worktree_name: string;
+    removed: boolean;
+    error?: string;
+}
+export interface ClaudeCleanupResult {
+    dry_run: boolean;
+    removed_count: number;
+    failed_count: number;
+    entries: CleanupEntry[];
+}
+export type RunLogType = "query" | "review" | "implement" | "apply" | "cleanup";
+export type RunLogStatus = "success" | "failed" | "partial" | "needs_user" | "unknown";
+export type RunLifecycle = "queued" | "running" | "success" | "partial" | "failed" | "apply_blocked" | "applied" | "cleaned" | "unknown";
+export interface ClaudeRunsInput {
+    cwd: string;
+    limit?: number;
+    type?: RunLogType;
+    status?: RunLogStatus;
+    worktree_name?: string;
+}
+export interface ClaudeRunInspectInput {
+    cwd: string;
+    run_id: string;
+}
+export interface RunLogEntrySummary {
+    run_id: string;
+    type: string;
+    status: RunLogStatus;
+    lifecycle: RunLifecycle;
+    cwd?: string;
+    summary?: string;
+    error?: string;
+    worktree_path?: string;
+    worktree_name?: string;
+    requested_session_id?: string | null;
+    returned_session_id?: string | null;
+    retried_after_session_expired?: boolean;
+    started_at?: string;
+    updated_at?: string;
+}
+export interface ClaudeRunsResult {
+    entries: RunLogEntrySummary[];
+    total_entries: number;
+}
+export interface ClaudeRunInspectResult {
+    entry: RunLogEntrySummary;
+    raw: Record<string, unknown>;
+    related_runs?: {
+        apply_run_id?: string;
+        cleanup_run_id?: string;
+    };
+}
+export interface RunSummaryCounts {
+    [key: string]: number;
+}
+export interface RecentRunsSummary {
+    entries: RunLogEntrySummary[];
+    lifecycle_counts: RunSummaryCounts;
+}
+export declare const claudeStatusInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+}, z.core.$strip>;
+export declare const claudeSetupInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    configure_allow_root: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare const claudeQueryInputSchema: z.ZodObject<{
+    task: z.ZodString;
+    cwd: z.ZodString;
+    instruction_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timeout_sec: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    max_turns: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    fast: z.ZodOptional<z.ZodBoolean>;
+    resume: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const claudeReviewInputSchema: z.ZodObject<{
+    task: z.ZodString;
+    cwd: z.ZodString;
+    diff: z.ZodOptional<z.ZodString>;
+    instruction_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timeout_sec: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    max_turns: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const claudeImplementInputSchema: z.ZodObject<{
+    task: z.ZodString;
+    cwd: z.ZodString;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timeout_sec: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    max_turns: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    session_key: z.ZodOptional<z.ZodString>;
+    fork_session: z.ZodOptional<z.ZodBoolean>;
+    resume_latest: z.ZodOptional<z.ZodBoolean>;
+    max_cost_usd: z.ZodOptional<z.ZodNumber>;
+    max_changed_files: z.ZodOptional<z.ZodNumber>;
+    worktreeName: z.ZodOptional<z.ZodString>;
+    dirty_policy: z.ZodOptional<z.ZodEnum<{
+        ask: "ask";
+        committed: "committed";
+        snapshot: "snapshot";
+    }>>;
+}, z.core.$strip>;
+export declare const claudeTaskInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    task: z.ZodString;
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        read: "read";
+        review: "review";
+        write: "write";
+    }>>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    resume_latest: z.ZodOptional<z.ZodBoolean>;
+    instruction_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    diff: z.ZodOptional<z.ZodString>;
+    timeout_sec: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    dirty_policy: z.ZodOptional<z.ZodEnum<{
+        ask: "ask";
+        committed: "committed";
+        snapshot: "snapshot";
+    }>>;
+}, z.core.$strip>;
+export declare const claudeApplyInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    worktree_path: z.ZodString;
+    cleanup: z.ZodOptional<z.ZodBoolean>;
+    preview: z.ZodOptional<z.ZodBoolean>;
+    background: z.ZodOptional<z.ZodBoolean>;
+    confirmed_by_user: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const claudeCleanupInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    older_than_hours: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    dry_run: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    background: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const claudeRunsInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        review: "review";
+        query: "query";
+        implement: "implement";
+        apply: "apply";
+        cleanup: "cleanup";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        success: "success";
+        partial: "partial";
+        needs_user: "needs_user";
+        unknown: "unknown";
+    }>>;
+    worktree_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const claudeRunInspectInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    run_id: z.ZodString;
+}, z.core.$strip>;
+export declare const claudeJobsInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        review: "review";
+        query: "query";
+        implement: "implement";
+        apply: "apply";
+        cleanup: "cleanup";
+    }>>;
+}, z.core.$strip>;
+export declare const claudeJobResultInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    job_id: z.ZodString;
+}, z.core.$strip>;
+export declare const claudeResultInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    job_id: z.ZodOptional<z.ZodString>;
+    run_id: z.ZodOptional<z.ZodString>;
+    prefer: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        "latest-job": "latest-job";
+        "latest-run": "latest-run";
+        "latest-implement": "latest-implement";
+        "latest-review": "latest-review";
+    }>>>;
+}, z.core.$strip>;
+export declare const claudeJobWaitInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    job_id: z.ZodString;
+    not_before: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const claudeJobCancelInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    job_id: z.ZodString;
+}, z.core.$strip>;
+export declare const claudeJobCleanupInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    older_than_hours: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    dry_run: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const claudeWorkspaceStatusInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    include_terminal: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare const claudeReviewGateInputSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    action: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        status: "status";
+        enable: "enable";
+        disable: "disable";
+    }>>>;
+}, z.core.$strip>;
+export declare function validationErrorMessage(err: unknown): string;
+export declare const QUERY_SCHEMA: {
+    readonly type: "object";
+    readonly required: readonly ["answer"];
+    readonly properties: {
+        readonly answer: {
+            readonly type: "string";
+            readonly description: "The full, detailed answer to the question. Include all relevant information.";
+        };
+    };
+};
+export declare const REVIEW_SCHEMA: {
+    readonly type: "object";
+    readonly required: readonly ["findings", "recommendations", "severity"];
+    readonly properties: {
+        readonly findings: {
+            readonly type: "string";
+            readonly description: "Detailed review findings: bugs, design issues, security concerns, performance problems.";
+        };
+        readonly recommendations: {
+            readonly type: "string";
+            readonly description: "Specific, actionable recommendations for each finding.";
+        };
+        readonly severity: {
+            readonly type: "string";
+            readonly enum: readonly ["critical", "high", "medium", "low", "none"];
+            readonly description: "Overall severity of issues found.";
+        };
+    };
+};
+export declare const IMPLEMENT_SCHEMA: {
+    readonly type: "object";
+    readonly required: readonly ["status", "summary", "changed_files", "commands_run", "tests", "risks", "next_steps"];
+    readonly properties: {
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["success", "failed", "partial", "needs_user"];
+        };
+        readonly summary: {
+            readonly type: "string";
+        };
+        readonly changed_files: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly commands_run: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly tests: {
+            readonly type: "object";
+            readonly required: readonly ["ran"];
+            readonly properties: {
+                readonly ran: {
+                    readonly type: "boolean";
+                };
+                readonly command: {
+                    readonly type: "string";
+                };
+                readonly passed: {
+                    readonly type: "boolean";
+                };
+                readonly output_tail: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly risks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly next_steps: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+};
+export declare const RESULT_SCHEMA: {
+    readonly type: "object";
+    readonly required: readonly ["status", "summary", "changed_files", "commands_run", "tests", "risks", "next_steps"];
+    readonly properties: {
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["success", "failed", "partial", "needs_user"];
+        };
+        readonly summary: {
+            readonly type: "string";
+        };
+        readonly changed_files: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly commands_run: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly tests: {
+            readonly type: "object";
+            readonly required: readonly ["ran"];
+            readonly properties: {
+                readonly ran: {
+                    readonly type: "boolean";
+                };
+                readonly command: {
+                    readonly type: "string";
+                };
+                readonly passed: {
+                    readonly type: "boolean";
+                };
+                readonly output_tail: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly risks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly next_steps: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+};
+export declare function buildImplementPrompt(input: ClaudeImplementInput): string;
+export declare function buildReviewPrompt(input: ClaudeReviewInput): string;
+export declare function buildQueryPrompt(input: ClaudeQueryInput): string;
+export declare function jsonResult(data: unknown): CallToolResult;
+export declare class StructuredToolError extends Error {
+    payload: Record<string, unknown>;
+    constructor(message: string, payload: Record<string, unknown>);
+}
+export declare function errorResult(error: string | Record<string, unknown>): CallToolResult;
+export declare function formatDuration(ms: number): string;
+export interface InteractionBlock {
+    headline: string;
+    state: string;
+    next_step: string;
+}
+export declare function withInteraction<T extends object>(result: T, interaction: InteractionBlock): T & {
+    interaction: InteractionBlock;
+};