@lmctl-ai/lmctl 0.1.341 → 0.2.2

package/dist/db/index.d.ts

@@ -0,0 +1,1213 @@
+import Database from './sqlite.js';
+import { type AgentInflightAcquireOptions, type AgentInflightAcquireResult, type AgentInflightInput, type AgentInflightObservedHolder, type AgentInflightRow } from './delegation.js';
+import { type TrackedInvocationFinishPatch, type TrackedInvocationInput, type TrackedInvocationListFilter, type TrackedInvocationRow, type TrackedInvocationTerminalClaimFilter } from './tracked-invocation.js';
+import { type TerminalLockRecord } from './terminal-lock.js';
+import { ESCALATION_INVALID_DECISION } from './escalation_vocab.js';
+export type { TrackedInvocationFinishPatch, TrackedInvocationInput, TrackedInvocationKind, TrackedInvocationListFilter, TrackedInvocationOrigin, TrackedInvocationRow, TrackedInvocationStatus, TrackedInvocationTerminalClaimFilter, } from './tracked-invocation.js';
+export type { AgentInflightAcquireOptions, AgentInflightAcquireResult, AgentInflightInput, AgentInflightObservedHolder, AgentInflightRow, } from './delegation.js';
+export type { TerminalLockRecord } from './terminal-lock.js';
+export interface WorkflowRow {
+    id: number;
+    name: string;
+    version: number;
+    definition_schema_version: number;
+    definition: string;
+    active_version_id: number | null;
+    created_at: string;
+    source_uri: string | null;
+    source_sha256: string | null;
+}
+export interface WorkflowVersionRow {
+    id: number;
+    workflow_id: number;
+    version: number;
+    definition: string;
+    author: string | null;
+    created_at: string;
+}
+export interface TriggerInstanceRow {
+    id: number;
+    workflow_id: number;
+    trigger_id: string;
+    trigger_type: string;
+    parameters: string;
+    enabled: number;
+    cursor: string | null;
+    last_poll_at: string | null;
+    last_failure_at: string | null;
+    last_failure: string | null;
+    created_at: string;
+}
+export interface TeamRow {
+    id: number;
+    name: string;
+    created_at: string;
+}
+export interface TeamMemberRow {
+    id: number;
+    team_id: number;
+    alias: string;
+    role: string;
+    provider: string;
+    model: string | null;
+    sessionid: string | null;
+    sessiondir: string;
+    state: string;
+    state_reason: string | null;
+    state_updated_at: string | null;
+    role_prompt: string | null;
+    prompt_snapshot: string | null;
+    /**
+     * V4.5 managed-team abstraction: when `provider` is an abstract token
+     * (provider1|2|3), the concrete provider chosen at seed time is
+     * snapshotted here. NULL = unseeded, or `provider` is already concrete.
+     * Frozen at seed; a later workspace-mapping change never mutates it
+     * (mirrors prompt_snapshot).
+     */
+    provider_resolved: string | null;
+    created_at: string;
+}
+/**
+ * The provider a SEEDED member actually runs as. Prefer the seed-time
+ * snapshot (`provider_resolved`) over the possibly-abstract `provider`
+ * token, so display/audit reflect the concrete provider. Pure reader —
+ * no DB, no resolution; safe for any team_member-shaped row.
+ */
+export declare function effectiveProvider(m: {
+    provider: string;
+    provider_resolved?: string | null;
+}): string;
+export interface TeamMemberCompanionRow {
+    id: number;
+    interpreter_id: number;
+    companion_id: number;
+    created_at: string;
+}
+export interface ProjectRow {
+    id: number;
+    name: string;
+    description: string | null;
+    local_path: string;
+    workflow_name: string;
+    team_id: number;
+    default_branch: string | null;
+    intake_config: string | null;
+    test_argv: string | null;
+    /**
+     * DG-6 D-6 — per-project test command consumed by the `focused_test`
+     * shell-step in the bugfix-* workflows via `{{project.test_command}}`.
+     * NULL or empty falls back to `npm test` (backward-compat for projects
+     * created before the v31 migration). Set to a project-specific command
+     * (e.g. `go test ./...`, `cargo test --quiet`) to unlock non-Node
+     * projects without forking the workflow JSON.
+     */
+    test_command: string | null;
+    durable_memory_mode: string;
+    created_at: string;
+}
+export interface ProjectWorkflowRow {
+    id: number;
+    project_id: number;
+    workflow_id: number;
+    condition: string | null;
+    parameters_override: string | null;
+    enabled: number;
+    priority: number;
+    created_at: string;
+}
+export type IssueStatus = 'open' | 'assigned' | 'closed' | 'reopened';
+export type IssueSeverity = 'low' | 'medium' | 'high' | 'critical';
+export interface IssueRow {
+    id: number;
+    project_id: number;
+    title: string;
+    body: string;
+    status: IssueStatus;
+    severity: IssueSeverity;
+    labels: string | null;
+    ai_test_path: string | null;
+    source_run_id: number | null;
+    assigned_run_id: number | null;
+    closed_run_id: number | null;
+    commit_hash: string | null;
+    created_at: string;
+    updated_at: string;
+    closed_at: string | null;
+}
+export interface JobRow {
+    id: number;
+    project_id: number;
+    workflow_id_override: number | null;
+    source: string;
+    source_ref: string | null;
+    payload: string | null;
+    status: string;
+    priority: number;
+    available_at: string;
+    locked_by: string | null;
+    locked_until: string | null;
+    attempt_count: number;
+    last_error: string | null;
+    dedupe_key: string | null;
+    concurrency_key_resolved: string | null;
+    enqueued_at: string;
+    started_at: string | null;
+    ended_at: string | null;
+    run_id: number | null;
+}
+export type JobClaimFailureReason = 'not_found' | 'not_claimable' | 'locked' | 'concurrency_limit';
+export type JobClaimByIdResult = {
+    claimed: true;
+    job: JobRow;
+} | {
+    claimed: false;
+    reason: JobClaimFailureReason;
+    job_id: number;
+    status?: string;
+    locked_by?: string | null;
+    locked_until?: string | null;
+};
+export interface RunRow {
+    id: number;
+    job_id: number;
+    workflow_id: number;
+    team_id: number;
+    current_state: string | null;
+    terminal_state: string | null;
+    workflow_version_id: number | null;
+    started_at: string;
+    ended_at: string | null;
+    paused_at: string | null;
+    blocker: string | null;
+    parent_run_id: number | null;
+    /** DEF-1 — JSON map keyed by step.id: the operator's escalation-resume
+     *  decision (chosen declared outcome token, or the reserved `@abort`).
+     *  NULL when no escalation decision is pending. */
+    pending_escalation_decision: string | null;
+}
+export interface StepRow {
+    id: number;
+    run_id: number;
+    parent_step_id: number | null;
+    state_name: string;
+    outcome: string | null;
+    status_detail: string | null;
+    started_at: string;
+    ended_at: string | null;
+}
+export interface StepArtifactRow {
+    id: number;
+    step_id: number;
+    kind: string;
+    path: string | null;
+    content: string | null;
+    sha: string | null;
+    /** A2.5 audit-trail: 'library' | 'subprocess' | null. */
+    provider_call_mode: 'library' | 'subprocess' | null;
+    created_at: string;
+}
+export interface ExternalObjectRow {
+    id: number;
+    type: string;
+    provider: string;
+    project_id: number;
+    run_id: number | null;
+    external_id: string;
+    url: string | null;
+    status: string | null;
+    metadata: string | null;
+    last_seen_at: string | null;
+    created_at: string;
+}
+export interface ExternalSignalRow {
+    id: number;
+    object_id: number;
+    kind: string;
+    source: string | null;
+    occurred_at: string | null;
+    payload: string | null;
+    signal_hash: string | null;
+    handled_at: string | null;
+    created_at: string;
+}
+export interface AttentionRow {
+    id: number;
+    kind: string;
+    severity: string | null;
+    project_id: number | null;
+    run_id: number | null;
+    external_object_id: number | null;
+    requires_user: number;
+    payload: string | null;
+    created_at: string;
+    acknowledged_at: string | null;
+}
+export interface SubmittedPrRow {
+    id: number;
+    repo: string;
+    pr_url: string;
+    issue_url: string | null;
+    local_path: string | null;
+    branch: string | null;
+    head_sha: string | null;
+    status: string;
+    submitted_at: string;
+    last_scanned_at: string | null;
+    last_followup_at: string | null;
+    last_known_state: string | null;
+    last_known_checks: string | null;
+    last_known_review: string | null;
+    visibility_status: string | null;
+    created_by_run_id: number | null;
+}
+export interface DurableMemoryRow {
+    id: number;
+    project_id: number;
+    type: string;
+    name: string;
+    description: string | null;
+    body: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface SessionEventRow {
+    id: number;
+    run_id: number;
+    step_id: number | null;
+    kind: string;
+    timestamp_ms: number;
+    payload: string;
+    payload_truncated: number;
+    overflow_artifact_id: number | null;
+}
+export interface RollupStatRow {
+    id: number;
+    run_id: number;
+    step_id: number | null;
+    metric_kind: string;
+    value: number;
+    bucket_start_ms: number;
+    bucket_end_ms: number;
+    updated_at: number;
+}
+export interface DriftSignalRow {
+    id: number;
+    team_member_id: number;
+    project_id: number | null;
+    signal_kind: string;
+    severity: 'low' | 'medium' | 'high';
+    description: string;
+    detected_at: number;
+    expires_at: number | null;
+    acknowledged_at: number | null;
+    payload: string | null;
+}
+export interface SessionSizeRow {
+    id: number;
+    team_name: string;
+    alias: string;
+    sessionid: string;
+    input_tokens: number | null;
+    cache_tokens: number | null;
+    output_tokens: number | null;
+    total_tokens: number | null;
+    observed_at: string;
+}
+/** webui v2 / v19 — operator transition-graph session. */
+export interface WebuiSessionRow {
+    session_id: string;
+    user_id: string;
+    current_node: string;
+    node_params: string | null;
+    prev_node_stack: string | null;
+    pending_form: string | null;
+    chatbot_session_id: string | null;
+    auth_state: string;
+    last_transition_at: string;
+    created_at: string;
+}
+/** webui v2 / v19 — chatbot sidekick conversation. */
+export interface ChatbotSessionRow {
+    chatbot_session_id: string;
+    user_id: string;
+    title: string | null;
+    created_at: string;
+    last_active_at: string;
+    status: string;
+}
+/** webui v2 / v19 — chatbot conversation message. */
+export interface ChatbotMessageRow {
+    id: number;
+    chatbot_session_id: string;
+    role: string;
+    content: string;
+    tool_calls: string | null;
+    created_at: string;
+}
+/** Phase A / v20 — lmctl_config row (canonical config replacing env vars). */
+export interface LmctlConfigRow {
+    key: string;
+    value: string;
+    updated_at: string;
+}
+/** R2.3 — interactive_session row (schema v12). */
+export interface InteractiveSessionRow {
+    id: number;
+    run_id: number;
+    step_id: number;
+    state_name: string;
+    turn_count: number;
+    last_agent_output: string | null;
+    last_operator_input: string | null;
+    status: 'waiting_operator' | 'waiting_agent' | 'done' | 'timeout';
+    started_at: number;
+    last_activity_at: number;
+}
+export type InteractiveResumeResult = {
+    resumed: true;
+    session: InteractiveSessionRow;
+    run: RunRow;
+    job: JobRow;
+} | {
+    resumed: false;
+    reason: 'not_found' | 'not_waiting_operator' | 'run_not_found';
+};
+export interface InsertResult<T> {
+    row: T;
+    inserted: boolean;
+}
+export type ResumeRunResult = {
+    resumed: true;
+    run: RunRow;
+    job: JobRow;
+} | {
+    resumed: false;
+    reason: 'run_not_found' | 'workflow_not_found' | 'not_paused' | 'state_not_found' | 'invalid_outcome';
+    valid?: string[];
+};
+/**
+ * DEF-1 §1.3 — result of the session-FREE `resumeEscalationTxn` (parallel to
+ * `resumeInteractiveTxn` MINUS the `interactive_session` dependency). A
+ * `workflow_escalation` attention has no session row; the escalated step is
+ * identified by `payload.step.id`.
+ */
+export type EscalationResumeResult = {
+    resumed: true;
+    run: RunRow;
+    job: JobRow;
+} | {
+    resumed: false;
+    reason: 'not_found' | 'wrong_kind' | 'already_acked' | 'run_not_found' | 'no_step' | typeof ESCALATION_INVALID_DECISION;
+};
+/** L-7 / v28 — webui Prompt id → V4 job dispatch map. */
+export interface PromptDispatchRow {
+    prompt_id: string;
+    project_id: number;
+    job_id: number;
+    text: string;
+    context_json: string | null;
+    created_at: string;
+    completed_at: string | null;
+}
+/** L-8 Gap 4 / v29 — webui workspace (single per user per D7). */
+export interface WorkspaceRow {
+    id: string;
+    name: string;
+    idle_threshold_ms: number;
+    created_at: string;
+    deleted_at: string | null;
+}
+/** L-8 Gap 4 / v29 — webui project (K1: distinct from v27 `project`). */
+export interface WebProjectRow {
+    id: number;
+    workspace_id: string;
+    name: string;
+    repo_path: string;
+    config_json: string | null;
+    linked_v4_project_id: number | null;
+    last_active_at: string | null;
+    created_at: string;
+    deleted_at: string | null;
+}
+/**
+ * MX-9 final fixup / v30: per-user mailbox cursor row. The
+ * VersionedMailboxClient's `getCursor()` value (a S3 `VersionId` string) is
+ * persisted here at the end of each successfully-processed batch so an agent
+ * restart resumes from the last advanced cursor instead of re-walking the
+ * entire backlog. `last_processed_version_id` is nullable to represent the
+ * cold-start sentinel ("we've checkpointed at `last_processed_at` but no
+ * version has yet been processed" — the seed row written before the poll
+ * loop starts; see `agent-mailbox-bootstrap.ts`).
+ */
+export interface MailboxCursorRow {
+    user_id: string;
+    mailbox_key: string;
+    last_processed_version_id: string | null;
+    /**
+     * v35 — GET-sequence transport cursor: the highest peer stream sequence
+     * consumed. Null for legacy version-id rows / cold-start sentinels. The
+     * sequential client persists this; the versioned client uses version_id.
+     */
+    last_processed_seq?: number | null;
+    last_processed_at: string;
+}
+/** v36 — per-device monthly S3 usage counters for quota accounting. */
+export interface UsageMeterRow {
+    user_id: string;
+    device_id: string;
+    period: string;
+    put_count: number;
+    get_count: number;
+    list_count: number;
+    updated_at: string;
+}
+/** v32 — path-keyed root team registry. Dark substrate for team workflow unification. */
+export interface RootTeamRow {
+    teamfile_path: string;
+    name: string | null;
+    raw_text: string;
+    raw_sha256: string;
+    registered_at: string;
+    last_seeded_at: string | null;
+}
+/** v32 — append-only request/response audit row for cross/team sends. */
+export interface TeamChatLogRow {
+    id: number;
+    root_teamfile: string;
+    sender_teamfile: string | null;
+    sender_alias: string | null;
+    receiver_teamfile: string;
+    receiver_alias: string;
+    message: string;
+    response: string | null;
+    origin: 'agent' | 'operator' | 'mcp' | 'unknown';
+    status: string;
+    error_detail: string | null;
+    truncated: number;
+    /**
+     * v61 — batch-vs-individual framing: 'batch' for rows belonging to a batch
+     * run, NULL for individual chats. Distinct from message_pending.message_type
+     * (request/response lane semantics). Deliberately NOT propagated into
+     * backfill-event-log copies or export (their payload shapes predate it).
+     */
+    message_type: 'batch' | null;
+    created_at: string;
+}
+/** v34 — per-mailbox daemon push watermark for team_chat_log tailing. */
+export interface TeamChatLogCursorRow {
+    cursor_key: string;
+    last_pushed_id: number;
+    updated_at: string;
+}
+export interface RuntimeProcessLockRecord {
+    lock_id: string;
+    holder_pid: number;
+    holder_host: string;
+    started_at: string;
+    last_heartbeat: string;
+}
+export type RuntimeProcessLockAcquireResult = {
+    acquired: true;
+    lock: RuntimeProcessLockRecord;
+    previous: RuntimeProcessLockRecord | null;
+} | {
+    acquired: false;
+    current: RuntimeProcessLockRecord;
+};
+export type RootTeamInput = RootTeamRow;
+export type TeamChatLogInput = Omit<TeamChatLogRow, 'id' | 'message_type'> & {
+    /** v61 batch framing; omit for individual chats (stored as NULL). */
+    message_type?: 'batch' | null;
+    /** Event-only historical target attribution; not stored in team_chat_log. */
+    receiver_provider?: string | null;
+    receiver_session_id?: string | null;
+    /** Exact provider-visible prompt; unlike team_chat_log.message, this is not
+     * truncated before it is recorded in the CREATE event. */
+    provider_prompt?: string | null;
+};
+export type TeamChatLogResponsePatch = Pick<TeamChatLogRow, 'response' | 'status' | 'error_detail' | 'truncated'>;
+export declare function nowIso(): string;
+interface SalvagedEssentialConfig {
+    rootTeams: RootTeamRow[];
+    config: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+/**
+ * Reads whatever essential config a DB this build can't otherwise use still
+ * has on disk: `root_team` (the fleet's team/nudge registrations -- "name ->
+ * path" plus the raw teamfile text, everything a health/discovery sweep
+ * needs) and `lmctl_config` (canonical api.url/api.port/api.token +
+ * workspace provider mappings -- "config replacing env vars", per its own
+ * schema comment; losing it silently would break `serve`/`apicli`
+ * coordination the same way losing team registrations breaks nudge).
+ * Opened as an INDEPENDENT connection (not the failed handle, which may be
+ * half-broken) and each table wrapped in its OWN try/catch: a genuinely
+ * corrupt file, or one that predates a given table, can't even run that
+ * SELECT -- that's fine, it just means nothing to salvage from that table,
+ * not a reason to fail the whole recovery (root_team predates lmctl_config
+ * by several versions, so an old-enough db could have one but not the
+ * other).
+ *
+ * DELIBERATE EXCLUSION (localweb v2, #104): `state_ledger_identity` is NOT read
+ * here and must never be added. Salvaging into a freshly created database is a
+ * NEW ledger generation; it re-mints its own instance id via migrate() so that
+ * old references (which bind to the prior instance id) can never silently resolve
+ * against reused numeric IDs in the new db. Only a full-file backup restore — which
+ * copies the whole file, not this selective salvage — retains the original id.
+ * Exported for the recovery/generation tests.
+ */
+export declare function salvageEssentialConfig(dbPath: string): SalvagedEssentialConfig;
+export declare function createDal(opts: {
+    path: string;
+    allowSchemaSkew?: boolean;
+}): Dal;
+export declare class Dal {
+    readonly db: Database;
+    private readonly stmts;
+    private readonly claimTxn;
+    private readonly claimWithConcurrencyTxn;
+    private readonly claimByIdWithConcurrencyTxn;
+    private readonly resumeRunTxn;
+    private readonly resumeInteractiveTxn;
+    private readonly resumeEscalationTxn;
+    private readonly tryAcquireAgentInflightTxn;
+    constructor(db: Database);
+    close(): void;
+    query(sql: string, ...params: unknown[]): unknown[];
+    insertWorkflow(input: {
+        name: string;
+        version?: number;
+        definition_schema_version?: number;
+        definition: string;
+        author?: string | null;
+        source_uri?: string | null;
+        source_sha256?: string | null;
+    }): WorkflowRow;
+    /**
+     * project_issue #31 — UPSERT semantics for workflow definitions (originally
+     * for `lmctl workflow load`; that verb was RETIRED in 0.1.128, `1775400`).
+     * Retained for DAL/schema/test compatibility; no current production call
+     * site.
+     *
+     * If no workflow with `input.name` exists, INSERT a fresh row + first
+     * workflow_version (same as `insertWorkflow`).
+     *
+     * If one exists, KEEP the same `workflow.id` and:
+     *   - INSERT a new `workflow_version` row (auto-bumped version);
+     *   - UPDATE `workflow.active_version_id` to the new version row;
+     *   - UPDATE `workflow.definition` and `workflow.definition_schema_version`
+     *     so callers reading off `workflow` (e.g. queue/worker.ts resolving via
+     *     `workflow_id_override`) see the latest definition immediately;
+     *   - BUMP `workflow.version` (kept in sync with the new version row so
+     *     `findWorkflowLatest` returns the same row with a higher version).
+     *
+     * Without this, a second `workflow load` INSERTed a new `workflow` row;
+     * `submit-job --workflow <name>` resolved the wrong row and the engine ran
+     * the stale definition. Pre-existing INSERT-only path was correct for
+     * first-load and is preserved (backward-compat).
+     */
+    upsertWorkflow(input: {
+        name: string;
+        definition_schema_version?: number;
+        definition: string;
+        author?: string | null;
+        source_uri?: string | null;
+        source_sha256?: string | null;
+    }): WorkflowRow;
+    /**
+     * M1/M3 (#218) — record the composition-DSL source + its compiled
+     * workflow_version link (the template↔instance "template"; v25
+     * composition_unit, data-model.md §5). Additive accessor; no existing
+     * storage path forked. The compiled IR itself lives in
+     * workflow/workflow_version (stored via upsertWorkflow).
+     */
+    insertCompositionUnit(input: {
+        name: string;
+        version: number;
+        lang: string;
+        source: string;
+        source_sha: string;
+        compiled_workflow_version_id: number | null;
+    }): void;
+    getWorkflow(id: number): WorkflowRow | null;
+    getWorkflowByName(name: string, version?: number): WorkflowRow | null;
+    /** @deprecated use getWorkflowByName; retained as a compatibility alias. */
+    findWorkflowByName(name: string, version?: number): WorkflowRow | null;
+    insertWorkflowVersion(workflow_id: number, definition_json: string, author?: string | null): WorkflowVersionRow;
+    activateWorkflowVersion(workflow_id: number, workflow_version_id: number): WorkflowRow | null;
+    getWorkflowVersionById(id: number): WorkflowVersionRow | null;
+    listWorkflowVersions(workflow_id: number): WorkflowVersionRow[];
+    upsertTriggerInstance(input: {
+        workflow_id: number;
+        trigger_id: string;
+        trigger_type: string;
+        parameters: string;
+        enabled?: boolean;
+    }): TriggerInstanceRow;
+    listTriggerInstancesForWorkflow(workflow_id: number): TriggerInstanceRow[];
+    listEnabledTriggerInstances(): TriggerInstanceRow[];
+    setTriggerCursor(id: number, cursor: string | null): TriggerInstanceRow | null;
+    setTriggerFailure(id: number, error: string): TriggerInstanceRow | null;
+    private syncWorkflowTriggers;
+    insertTeam(input: {
+        name: string;
+    }): TeamRow;
+    getTeam(id: number): TeamRow | null;
+    findTeamByName(name: string): TeamRow | null;
+    listTeams(): TeamRow[];
+    insertTeamMember(input: {
+        team_id: number;
+        alias: string;
+        role?: string;
+        provider: string;
+        model?: string | null;
+        sessionid?: string | null;
+        sessiondir: string;
+    }): TeamMemberRow;
+    listTeamMembers(team_id: number): TeamMemberRow[];
+    findTeamMemberByAlias(team_id: number, alias: string): TeamMemberRow | null;
+    updateTeamMemberSession(id: number, sessionid: string): TeamMemberRow | null;
+    setMemberState(id: number, state: string, reason?: string | null): TeamMemberRow | null;
+    listMembersInState(state: string): TeamMemberRow[];
+    setMemberPromptSnapshot(id: number, snapshot: string | null): TeamMemberRow | null;
+    /**
+     * Snapshot the concrete provider chosen at seed time. Written by the
+     * seedMember chokepoint only; frozen thereafter (a workspace-mapping
+     * change does not retroactively re-resolve seeded members).
+     */
+    setMemberProviderResolved(id: number, concrete: string | null): TeamMemberRow | null;
+    setMemberRolePrompt(id: number, role_prompt: string | null): TeamMemberRow | null;
+    /**
+     * webui v2 — partial update of a team member's mutable metadata
+     * (role_prompt, model, provider). Only patches keys that are present;
+     * pass `null` for `role_prompt`/`model` to clear, leave a key undefined
+     * to preserve the current column value. Returns `null` if the member
+     * id does not exist.
+     */
+    updateTeamMemberMeta(id: number, patch: {
+        role_prompt?: string | null;
+        model?: string | null;
+        provider?: string;
+    }): TeamMemberRow | null;
+    insertTeamMemberCompanion(input: {
+        interpreter_id: number;
+        companion_id: number;
+    }): TeamMemberCompanionRow;
+    insertProject(input: {
+        name: string;
+        description?: string | null;
+        local_path: string;
+        workflow_name: string;
+        team_id: number;
+        default_branch?: string | null;
+        intake_config?: string | null;
+        test_argv?: string | null;
+        /**
+         * DG-6 D-6 — per-project test command surfaced as
+         * `{{project.test_command}}` in workflow templates. NULL → substituter
+         * returns `npm test` for backward-compat. See ProjectRow.test_command.
+         */
+        test_command?: string | null;
+        durable_memory_mode?: 'folder' | 'db';
+    }): ProjectRow;
+    listProjects(): ProjectRow[];
+    getProject(id: number): ProjectRow | null;
+    findProjectByName(name: string): ProjectRow | null;
+    setProjectIntakeConfig(project_id: number, intake_config: string | null): ProjectRow | null;
+    /**
+     * webui v2 — partial update of project settings (N15 page).
+     *
+     * Patch semantics: only fields present in `patch` are written. Each field
+     * uses `hasOwnProperty` checks so that a caller can set a value to `null`
+     * to clear (`default_branch`, `intake_config`) without affecting other
+     * columns. Returns `null` when the project does not exist.
+     */
+    updateProjectSettings(project_id: number, patch: {
+        local_path?: string;
+        durable_memory_mode?: 'folder' | 'db';
+        default_branch?: string | null;
+        intake_config?: string | null;
+    }): ProjectRow | null;
+    listProjectsWithIntakeEnabled(): ProjectRow[];
+    getProjectByJob(job_id: number): ProjectRow | null;
+    insertProjectWorkflow(input: {
+        project_id: number;
+        workflow_id: number;
+        condition?: string | null;
+        parameters_override?: string | null;
+        priority?: number;
+        enabled?: boolean;
+    }): ProjectWorkflowRow;
+    getProjectWorkflow(id: number): ProjectWorkflowRow | null;
+    listProjectWorkflows(project_id: number, opts?: {
+        enabled_only?: boolean;
+    }): ProjectWorkflowRow[];
+    removeProjectWorkflow(id: number): boolean;
+    setProjectWorkflowEnabled(id: number, enabled: boolean): ProjectWorkflowRow | null;
+    createIssue(input: {
+        project_id: number;
+        title: string;
+        body: string;
+        severity?: IssueSeverity;
+        labels?: string | null;
+        ai_test_path?: string | null;
+        source_run_id?: number | null;
+    }): IssueRow;
+    getIssue(id: number): IssueRow | null;
+    listIssues(project_id: number, opts?: {
+        status?: IssueStatus[];
+        severity?: IssueSeverity[];
+        ai_test_path?: string;
+    }): IssueRow[];
+    claimNextIssue(project_id: number, assigned_run_id: number): IssueRow | null;
+    claimIssue(id: number, assigned_run_id: number): IssueRow | null;
+    closeIssue(id: number, closed_run_id: number, commit_hash?: string | null): IssueRow;
+    reopenIssue(id: number, source_run_id: number): IssueRow;
+    updateIssue(id: number, patch: {
+        title?: string;
+        body?: string;
+        severity?: IssueSeverity;
+        labels?: string | null;
+        ai_test_path?: string | null;
+    }): IssueRow;
+    listWorkflows(): WorkflowRow[];
+    /**
+     * Idempotent get-or-create. If the session row exists it is returned
+     * unchanged (no transition mutation); otherwise a fresh row is inserted
+     * at the root node (N1) with no parameters.
+     */
+    getOrCreateWebuiSession(session_id: string, user_id: string): WebuiSessionRow;
+    getWebuiSession(session_id: string): WebuiSessionRow | null;
+    /**
+     * Persist a transition. Caller is responsible for stringifying JSON
+     * payloads; nullable fields accept explicit `null`. `last_transition_at`
+     * is stamped automatically.
+     */
+    updateWebuiSessionTransition(session_id: string, current_node: string, node_params: string | null, prev_node_stack: string | null, pending_form: string | null): WebuiSessionRow;
+    /** Attach (or detach when `null`) a chatbot conversation to the session. */
+    setWebuiSessionChatbot(session_id: string, chatbot_session_id: string | null): WebuiSessionRow;
+    /** Create a fresh chatbot conversation for `user_id`. Returns the row. */
+    createChatbotSession(user_id: string, title?: string | null): ChatbotSessionRow;
+    getChatbotSession(chatbot_session_id: string): ChatbotSessionRow | null;
+    listChatbotSessions(user_id: string): ChatbotSessionRow[];
+    /**
+     * Append a message and bump the parent conversation's `last_active_at`.
+     * Returns the inserted row. Throws on FK violation if `chatbot_session_id`
+     * is unknown.
+     */
+    appendChatbotMessage(chatbot_session_id: string, role: string, content: string, tool_calls?: string | null): ChatbotMessageRow;
+    /** Messages in insertion order (oldest first). */
+    listChatbotMessages(chatbot_session_id: string): ChatbotMessageRow[];
+    /** Returns the config value for `key`, or null if not set. */
+    getConfig(key: string): string | null;
+    /** Upsert a config value. Stamps `updated_at` to now. */
+    setConfig(key: string, value: string): void;
+    /** All config rows as a plain object (alphabetical key order). */
+    getConfigAll(): Record<string, string>;
+    enqueueJob(input: {
+        project_id: number;
+        workflow_id_override?: number | null;
+        source: string;
+        source_ref?: string | null;
+        payload?: string | null;
+        priority?: number;
+        available_at?: string;
+        dedupe_key?: string | null;
+        concurrency_key?: string | null;
+    }): JobRow;
+    claimNextJob(input: {
+        worker_id: string;
+        lease_ms: number;
+    }): JobRow | null;
+    claimNextJobWithConcurrency(input: {
+        worker_id: string;
+        lease_ms: number;
+        evaluator: (job: JobRow) => {
+            concurrency_key: string | null;
+            concurrent_limit: number;
+        };
+    }): JobRow | null;
+    claimJobByIdWithConcurrency(input: {
+        job_id: number;
+        worker_id: string;
+        lease_ms: number;
+        evaluator: (job: JobRow) => {
+            concurrency_key: string | null;
+            concurrent_limit: number;
+        };
+    }): JobClaimByIdResult;
+    releaseJob(id: number, status: string, last_error?: string | null): JobRow | null;
+    getJob(id: number): JobRow | null;
+    findJobBySourceAndDedupe(source: string, dedupe_key: string): JobRow | null;
+    insertRun(input: {
+        job_id: number;
+        workflow_id: number;
+        team_id: number;
+        current_state?: string | null;
+        parent_run_id?: number | null;
+    }): RunRow;
+    setJobRun(job_id: number, run_id: number): JobRow | null;
+    insertPromptDispatch(input: {
+        prompt_id: string;
+        project_id: number;
+        job_id: number;
+        text: string;
+        context_json?: string | null;
+    }): PromptDispatchRow;
+    getPromptDispatch(prompt_id: string): PromptDispatchRow | null;
+    setPromptDispatchCompleted(prompt_id: string, completed_at?: string): PromptDispatchRow | null;
+    /** Read the workspace row. Returns null if absent or soft-deleted. */
+    getWorkspace(id: string): WorkspaceRow | null;
+    /**
+     * Lazy-create the workspace (per L-MD §K6) if not present, then read it.
+     * Used by `Query.workspace` so a fresh DB always returns a row even before
+     * the operator creates any project. The "default" id matches the pre-L-8
+     * resolver constant; schema.sql + the v29 migration both seed this row,
+     * so this is a belt-and-braces upsert in the rare case the row was hand-
+     * deleted (e.g. test fixtures).
+     */
+    ensureWorkspace(opts?: {
+        id?: string;
+        name?: string;
+        idleThresholdMs?: number;
+    }): WorkspaceRow;
+    /** List active (not-soft-deleted) web_projects for a workspace. */
+    listWebProjectsActive(workspace_id: string): WebProjectRow[];
+    /** Read a web_project by id (returns soft-deleted rows too — callers filter). */
+    getWebProject(id: number): WebProjectRow | null;
+    insertWebProject(input: {
+        workspace_id: string;
+        name: string;
+        repo_path: string;
+        config_json?: string | null;
+        linked_v4_project_id?: number | null;
+    }): WebProjectRow;
+    updateWebProject(input: {
+        id: number;
+        name?: string;
+        config_json?: string | null;
+    }): WebProjectRow | null;
+    /** Soft-delete (sets `deleted_at`). Returns false if the row was absent or
+     *  already soft-deleted. Prompt history rows in `prompt_dispatch` retain
+     *  the FK reference; the UI is expected to hide deleted projects. */
+    softDeleteWebProject(id: number): boolean;
+    /** Read the cursor row for one resolved mailbox object, or null if absent (cold start). */
+    loadMailboxCursor(user_id: string, mailbox_key: string): MailboxCursorRow | null;
+    /**
+     * Upsert the cursor row. Caller pattern: invoke AFTER each
+     * successfully-processed message so partial failures don't advance the
+     * cursor. `last_processed_version_id` may be null to record the
+     * cold-start sentinel before the first version is processed.
+     */
+    saveMailboxCursor(row: MailboxCursorRow): void;
+    /** Increment this device's monthly op counters by the given deltas (upsert). */
+    addUsage(args: {
+        user_id: string;
+        device_id: string;
+        period: string;
+        put: number;
+        get: number;
+        list: number;
+        updated_at: string;
+    }): void;
+    /** Read one device's counters for a period, or null. */
+    loadUsage(user_id: string, device_id: string, period: string): UsageMeterRow | null;
+    /** Sum a user's op counts across all this-DB-local devices for a period. */
+    sumUsageForPeriod(user_id: string, period: string): {
+        put: number;
+        get: number;
+        list: number;
+    };
+    upsertRootTeam(row: RootTeamInput): void;
+    getRootTeam(teamfile_path: string): RootTeamRow | null;
+    listRootTeams(): RootTeamRow[];
+    insertTeamChatLog(row: TeamChatLogInput): number;
+    beginTeamChatLog(row: TeamChatLogInput): number;
+    finishTeamChatLog(id: number, row: TeamChatLogInput): void;
+    setCurrentlyHandlingMessage(teamfile: string, alias: string, messageId: string): void;
+    clearCurrentlyHandlingMessage(teamfile: string, alias: string, expectedMessageId: string): boolean;
+    listTeamChatLog(root_teamfile: string): TeamChatLogRow[];
+    listTeamChatLogSinceId(afterId: number, limit?: number): TeamChatLogRow[];
+    getMaxTeamChatLogId(): number;
+    loadTeamChatLogCursor(cursor_key: string): TeamChatLogCursorRow | null;
+    saveTeamChatLogCursor(row: TeamChatLogCursorRow): void;
+    startTrackedInvocation(input: TrackedInvocationInput): TrackedInvocationRow;
+    private startTrackedInvocationInner;
+    getTrackedInvocation(id: number): TrackedInvocationRow | null;
+    /**
+     * lmctl's own dispatch audit trail for a target (who dispatched, when,
+     * how it ended), joined alongside the provider-native message history
+     * rather than folded into it, since a `tracked_invocation` row and a
+     * provider turn are not guaranteed 1:1 (retries, aborts).
+     */
+    listTrackedInvocationsForTarget(targetTeamfile: string, targetAlias: string, opts?: {
+        sinceMs?: number;
+        untilMs?: number;
+        limit?: number;
+    }): TrackedInvocationRow[];
+    listAllRunningTrackedInvocations(): TrackedInvocationRow[];
+    listRecentlyFinishedTrackedInvocations(sinceIso: string): TrackedInvocationRow[];
+    /**
+     * Finished children (ended within `sinceIso`) of the given invocations --
+     * the lineage-completion query `lmctl running --tree` uses so a batch root
+     * renders ALL its per-turn children, not just the ones that survived the
+     * flat view's latest-per-target suppression. Point-in-time running/dead
+     * children need no retrieval here: the running snapshot already lists
+     * every status='running' row regardless of parentage.
+     */
+    listFinishedTrackedInvocationChildren(parentIds: number[], sinceIso: string): TrackedInvocationRow[];
+    finishTrackedInvocation(id: number, patch: TrackedInvocationFinishPatch): TrackedInvocationRow | null;
+    reclaimTrackedInvocationIfUnchanged(id: number, observed: Pick<TrackedInvocationRow, 'holder_pid' | 'holder_host' | 'started_at' | 'last_heartbeat_at'>, patch: TrackedInvocationFinishPatch): TrackedInvocationRow | null;
+    heartbeatTrackedInvocation(id: number, heartbeatAt?: string): TrackedInvocationRow | null;
+    updateTrackedInvocationRequestPayload(id: number, requestPayload: string): TrackedInvocationRow | null;
+    /**
+     * Slice A item 1 — persist the CREATE-time message linkage onto the still-
+     * running invocation: the legacy `team_chat_log_id` column AND the canonical
+     * `invocation_state.request_message_id` (`msg_tcl_<id>`), in one transaction.
+     * Set-once + running-only (CAS via the statement guard), so a process that
+     * dies moments later leaves a durable link the dead-holder reconciler can
+     * follow to terminalize the exact message. Returns null if the guard didn't
+     * match (not running, or already linked).
+     */
+    linkTrackedInvocationMessage(id: number, teamChatLogId: number): TrackedInvocationRow | null;
+    /**
+     * Slice A item 2 — dead-holder abort that ALSO terminalizes the linked
+     * message, atomically. The invocation abort CAS is the single gate: exactly
+     * one caller flips `running -> aborted` (later sweeps and a late normal
+     * finalizer all fail the guard), and only that winner terminalizes the linked
+     * chat-log message. The message terminalization is itself first-writer-wins
+     * (guarded on the chat-log row still being 'running') and idempotent (the
+     * HANDLED event has a deterministic id that dedupes), so an already-'ok'
+     * message is never overwritten and no duplicate terminal event is appended.
+     * Returns the aborted row, or null if the abort CAS lost.
+     */
+    abortTrackedInvocationAndTerminalizeMessage(id: number, observed: Pick<TrackedInvocationRow, 'holder_pid' | 'holder_host' | 'started_at' | 'last_heartbeat_at'>, errorDetail: string): TrackedInvocationRow | null;
+    /** Terminalize a still-running chat-log message to an error outcome and append
+     * its HANDLED event. Runs inside the abort transaction. No-op when the message
+     * is missing or already terminal (first-writer-wins). */
+    private terminalizeLinkedChatMessage;
+    listClaimableTerminalTrackedInvocations(filter: TrackedInvocationTerminalClaimFilter): TrackedInvocationRow[];
+    claimTrackedInvocationNotification(id: number, notifiedBy: string, notifiedAt?: string): TrackedInvocationRow | null;
+    listTrackedInvocations(filter?: TrackedInvocationListFilter): TrackedInvocationRow[];
+    maxTrackedInvocationId(filter?: Pick<TrackedInvocationListFilter, 'from' | 'scope_teamfile'>): number;
+    listRunningTrackedInvocations(filter?: Omit<TrackedInvocationListFilter, 'status'>): TrackedInvocationRow[];
+    updateTeamChatLogResponse(id: number, patch: TeamChatLogResponsePatch): void;
+    getAgentInflight(receiver_teamfile: string, receiver_alias: string): AgentInflightRow | null;
+    listAgentInflight(): AgentInflightRow[];
+    tryAcquireAgentInflight(row: AgentInflightInput, options?: AgentInflightAcquireOptions): AgentInflightAcquireResult;
+    heartbeatAgentInflight(row: AgentInflightInput, leaseId: string, heartbeatAt?: string): boolean;
+    clearAgentInflight(receiver_teamfile: string, receiver_alias: string): void;
+    clearObservedTerminalAgentInflight(receiver_teamfile: string, receiver_alias: string, observed: AgentInflightObservedHolder): boolean;
+    releaseAgentInflight(row: AgentInflightInput, leaseId?: string): boolean;
+    clearAgentInflightOlderThan(stale_before: string): number;
+    getTerminalLock(teamfile: string, alias: string): TerminalLockRecord | null;
+    setTerminalLock(lock: TerminalLockRecord): void;
+    heartbeatTerminalLock(teamfile: string, alias: string, lockId: string, heartbeatAt: string): boolean;
+    clearTerminalLock(teamfile: string, alias: string, lockId: string): boolean;
+    getRuntimeProcessLock(scope: string, key: string, kind: string): RuntimeProcessLockRecord | null;
+    tryAcquireRuntimeProcessLock(scope: string, key: string, kind: string, staleBefore: string, now?: string): RuntimeProcessLockAcquireResult;
+    clearRuntimeProcessLock(scope: string, key: string, kind: string, lockId: string): boolean;
+    getRun(id: number): RunRow | null;
+    setRunCurrentState(run_id: number, current_state: string | null): RunRow | null;
+    setRunPausedState(run_id: number, current_state: string, paused_at: string): RunRow | null;
+    /** DEF-1 §1.3 — set/clear `run.pending_escalation_decision` (the step.id-
+     *  keyed JSON map). Pass the serialized map, or `null` to clear it when the
+     *  engine consume-point has drained the last entry. */
+    setRunPendingEscalationDecision(run_id: number, value: string | null): RunRow | null;
+    setRunTerminalState(run_id: number, terminal_state: string): RunRow | null;
+    pauseJob(id: number): JobRow | null;
+    resumeRun(run_id: number, outcome: string): ResumeRunResult;
+    insertStep(input: {
+        run_id: number;
+        state_name: string;
+        parent_step_id?: number | null;
+        outcome?: string | null;
+        status_detail?: string | null;
+    }): StepRow;
+    finishStep(id: number, outcome?: string | null, status_detail?: string | null): StepRow | null;
+    /**
+     * All `step` rows for a run, ascending by id (= transition order; id is
+     * the autoincrement PK written once per state/node execution by
+     * `insertStep`). Additive read over existing rows — no schema change,
+     * no parallel event stream. The per-transition observable the
+     * workflow-microservice mediation core reads (design §3/§4).
+     */
+    listStepsForRun(run_id: number): StepRow[];
+    /**
+     * Return the most recent non-null outcome per state_name for a run.
+     * Used by the engine on resume to rehydrate ExecutionContext.outcomes so
+     * downstream `{{outcomes.<state_id>}}` substitutions resolve against the
+     * Pause's operator-chosen outcome (and any other completed steps).
+     */
+    listLatestStepOutcomesByState(run_id: number): Record<string, string>;
+    insertSubmittedPr(input: {
+        repo: string;
+        pr_url: string;
+        issue_url?: string | null;
+        local_path?: string | null;
+        branch?: string | null;
+        head_sha?: string | null;
+        status?: string;
+        submitted_at?: string;
+        last_known_state?: string | null;
+        created_by_run_id?: number | null;
+    }): SubmittedPrRow;
+    listSubmittedPrs(opts?: {
+        status?: string;
+    }): SubmittedPrRow[];
+    getSubmittedPr(id: number): SubmittedPrRow | null;
+    findSubmittedPrByUrl(pr_url: string): SubmittedPrRow | null;
+    insertStepArtifact(input: {
+        step_id: number;
+        kind: string;
+        path?: string | null;
+        content?: string | null;
+        sha?: string | null;
+        /** A2.5 audit-trail: 'library' | 'subprocess' | null (non-chat step). */
+        provider_call_mode?: 'library' | 'subprocess' | null;
+    }): StepArtifactRow;
+    insertExternalObject(input: {
+        type: string;
+        provider: string;
+        project_id: number;
+        run_id?: number | null;
+        external_id: string;
+        url?: string | null;
+        status?: string | null;
+        metadata?: string | null;
+        last_seen_at?: string | null;
+    }): InsertResult<ExternalObjectRow>;
+    insertExternalSignal(input: {
+        object_id: number;
+        kind: string;
+        source?: string | null;
+        occurred_at?: string | null;
+        payload?: string | null;
+        signal_hash?: string | null;
+    }): InsertResult<ExternalSignalRow>;
+    raiseAttention(input: {
+        kind: string;
+        severity?: string | null;
+        project_id?: number | null;
+        run_id?: number | null;
+        external_object_id?: number | null;
+        requires_user?: boolean;
+        payload?: string | null;
+    }): AttentionRow;
+    acknowledgeAttention(id: number): AttentionRow | null;
+    upsertDurableMemory(input: {
+        project_id: number;
+        type: string;
+        name: string;
+        description?: string | null;
+        body: string;
+    }): DurableMemoryRow;
+    getDurableMemoryByName(project_id: number, name: string): DurableMemoryRow | null;
+    /**
+     * webui v2 — remove a durable-memory chapter from the DB. Returns `true`
+     * when a row was deleted, `false` when the chapter did not exist.
+     * No-op + false is the contract; callers should map false to 404.
+     */
+    deleteDurableMemory(project_id: number, name: string): boolean;
+    listDurableMemory(project_id: number, type?: string): DurableMemoryRow[];
+    indexDurableMemory(project_id: number, types?: string[]): Array<Pick<DurableMemoryRow, 'name' | 'description' | 'type' | 'updated_at'>>;
+    recordSessionSize(input: {
+        team_name: string;
+        alias: string;
+        sessionid: string;
+        input_tokens?: number | null;
+        cache_tokens?: number | null;
+        output_tokens?: number | null;
+        total_tokens?: number | null;
+        observed_at?: string;
+    }): SessionSizeRow;
+    latestSessionSizes(): SessionSizeRow[];
+    sessionSizeHistory(team_name: string, alias: string, limit?: number): SessionSizeRow[];
+    insertSessionEvent(input: {
+        run_id: number;
+        step_id: number | null;
+        kind: string;
+        timestamp_ms: number;
+        payload: string;
+        payload_truncated?: number;
+        overflow_artifact_id?: number | null;
+    }): SessionEventRow;
+    listSessionEvents(run_id: number, sinceId?: number): SessionEventRow[];
+    listSessionEventsSince(sinceId: number, limit?: number): SessionEventRow[];
+    /**
+     * P3 (briefs/lmctl0-verbs-native-port-design.md §2.4 / §2.5) —
+     * read-only accessor for the most-recent `agent_call` session_event for
+     * a run. Returns `{alias,provider,model?}` parsed from the payload (the
+     * five-field shape the engine adapter wrote — the engine moved to lmbee
+     * with the daemon, 2026-09-27), or null when the run has no agent_call yet.
+     *
+     * Run-keyed ORDER BY id DESC — NOT a `payload.step_id == session_event
+     * .step_id` join (that join is INVALID for the workflow_escalation
+     * case: `escalate()` writes a NEW escalation-marker step row whose id
+     * goes into `attention.payload.step_id`, while the prior `agent_call`
+     * lives under a DIFFERENT step row, so step_id join would chase a row
+     * that has no `agent_call`). The design's §6.7 load-bearing test
+     * pins this distinction.
+     */
+    latestAgentCall(run_id: number): {
+        alias: string;
+        provider: string;
+        model?: string;
+    } | null;
+    /**
+     * P3 — read-only token rollup across ALL `agent_call` events for a run.
+     * Sums `payload.tokens_in` / `payload.tokens_out` (the fields the engine
+     * writes). Used by `info --run` for the per-run aggregate; never reads
+     * cost/price (R4 baked).
+     */
+    agentCallTokenTotals(run_id: number): {
+        totalInputTokens: number;
+        totalOutputTokens: number;
+        agentCallCount: number;
+    };
+    addRollupValue(input: {
+        run_id: number;
+        step_id: number | null;
+        metric_kind: string;
+        value: number;
+        bucket_start_ms: number;
+        bucket_end_ms: number;
+        updated_at: number;
+    }): void;
+    listRollupStats(run_id: number): RollupStatRow[];
+    getRollupCursor(): number;
+    setRollupCursor(eventId: number): void;
+    insertDriftSignal(input: {
+        team_member_id: number;
+        project_id?: number | null;
+        signal_kind: string;
+        severity: 'low' | 'medium' | 'high';
+        description: string;
+        detected_at: number;
+        expires_at?: number | null;
+        payload?: string | null;
+    }): DriftSignalRow;
+    listDriftSignals(opts?: {
+        team_member_id?: number;
+        project_id?: number;
+        unacked?: boolean;
+    }): DriftSignalRow[];
+    hasUnackedDriftSignal(team_member_id: number, project_id: number | null, signal_kind: string): boolean;
+    acknowledgeDriftSignal(id: number): DriftSignalRow | null;
+    insertInteractiveSession(input: {
+        run_id: number;
+        step_id: number;
+        state_name: string;
+        status: InteractiveSessionRow['status'];
+    }): InteractiveSessionRow;
+    getInteractiveSessionByStepId(step_id: number): InteractiveSessionRow | null;
+    getInteractiveSessionByRunAndState(run_id: number, state_name: string): InteractiveSessionRow | null;
+    setInteractiveAgentOutput(id: number, output: string, status: InteractiveSessionRow['status']): void;
+    resumeInteractive(step_id: number, input: string, done: boolean): InteractiveResumeResult;
+    /** DEF-1 §1.3 — operator answers a `workflow_escalation`. `decision` is one
+     *  of the escalated step's declared outcome tokens, or the reserved
+     *  `@abort`. Session-free; persists the decision and un-pauses the run. */
+    resumeEscalation(attention_id: number, decision: string): EscalationResumeResult;
+}