@lmctl-ai/lmctl 0.1.342 → 0.2.3

package/dist/db/backfill-event-log.d.ts

@@ -0,0 +1,26 @@
+import type Database from './sqlite.js';
+export interface BackfillResult {
+    /** Events newly appended this run (0 on a clean re-run). */
+    appended: number;
+    /** Events skipped because their deterministic event_id already existed. */
+    skipped: number;
+    /** Per-source-table appended+skipped totals, for parity assertions. */
+    bySource: Record<'team_chat_log' | 'agent_mailbox' | 'tracked_invocation' | 'agent_inflight', number>;
+    /** Projection row counts after rebuild. */
+    projections: {
+        agent_state: number;
+        message_pending: number;
+        invocation_state: number;
+    };
+}
+export declare function backfillEventLog(db: Database): BackfillResult;
+/**
+ * Rebuild `agent_state` (lease slice) / `message_pending` / `invocation_state`
+ * from `message_event`, in `seq` order. Truncates the three projections first,
+ * so the result is a pure function of the log — this is the reusable
+ * "rebuild a projection by replaying the log" capability. Idempotent.
+ *
+ * Not wrapped in its own transaction: `backfillEventLog` already calls it
+ * inside the outer transaction. A standalone caller should wrap it.
+ */
+export declare function rebuildProjections(db: Database): void;

package/dist/db/delegation.d.ts

@@ -0,0 +1,37 @@
+import type Database from './sqlite.js';
+/** v32 - per-receiver in-flight marker for single-sender serialization. */
+export interface AgentInflightRow {
+    receiver_teamfile: string;
+    receiver_alias: string;
+    sender_teamfile: string;
+    sender_alias: string;
+    started_at: string;
+    active_count: number;
+    holder_pid: number | null;
+}
+export type AgentInflightInput = Omit<AgentInflightRow, 'active_count' | 'holder_pid'>;
+export type AgentInflightObservedHolder = Pick<AgentInflightRow, 'sender_teamfile' | 'sender_alias' | 'started_at' | 'holder_pid'>;
+export interface AgentInflightAcquireOptions {
+    stale_before?: string | null;
+    force?: boolean;
+    reclaim_reason?: 'force' | 'stale' | 'dead-pid' | 'session-idle';
+    reclaim_observed?: AgentInflightObservedHolder;
+}
+export type AgentInflightAcquireResult = {
+    acquired: true;
+    current: AgentInflightRow;
+    lease_id: string;
+} | {
+    acquired: false;
+    current: AgentInflightRow;
+};
+export declare function prepareDelegationStatements(db: Database): {
+    getAgentInflight: import("./sqlite.js").Statement;
+    listAgentInflight: import("./sqlite.js").Statement;
+    acquireAgentInflight: import("./sqlite.js").Statement;
+    clearAgentInflight: import("./sqlite.js").Statement;
+    clearAgentInflightIfSender: import("./sqlite.js").Statement;
+    clearObservedTerminalAgentInflight: import("./sqlite.js").Statement;
+    decrementAgentInflight: import("./sqlite.js").Statement;
+    clearAgentInflightOlderThan: import("./sqlite.js").Statement;
+};

package/dist/db/escalation_vocab.d.ts

@@ -0,0 +1,45 @@
+/**
+ * DEF-1 (escalation-engine, briefs/def1-escalation-engine-design.md §3/§4;
+ * canonical model durable-memory/escalation-and-progressive-automation.md).
+ *
+ * The SINGLE engine-owned generic-escalation vocabulary + the
+ * prompt-convention snippet. Specialized-first / minimal: `other`
+ * (umbrella + free-text reason) + 3 named kinds. The author NEVER
+ * declares these — the *prompt* makes the agent produce them, and the
+ * engine RESERVES them (matched before declared semantic edges; a
+ * declared edge using a reserved name is ignored — §2 reserved-word
+ * guarantee). One-line extendable; grow empirically via the authoring
+ * loop, do NOT pre-specify a large taxonomy.
+ */
+/** Umbrella escalation token; carries a short free-text reason after a
+ *  colon: `STANCE: other: <why no declared outcome fits>`. */
+export declare const ESCALATION_OTHER = "other";
+/** First-class named escalation reason kinds. */
+export declare const ESCALATION_KINDS: readonly ["not_enough_information", "dont_know", "other_work"];
+/** The full reserved generic-escalation vocabulary. */
+export declare const ESCALATION_VOCAB: ReadonlySet<string>;
+/** Engine-reserved operator decision: end the run as a human-decided
+ *  abort (NOT a synthesized generic failure terminal). */
+export declare const ESCALATION_ABORT_DECISION = "@abort";
+/** Fail-closed result reason when an operator escalation-resume decision is
+ *  neither the reserved `@abort` nor one of the escalated step's declared
+ *  outcomes (DEF-1 §"bounded"). Enforced in `resumeEscalationTxn` BEFORE any
+ *  state mutation; surfaced uniformly via the `{resumed:false}` channel. */
+export declare const ESCALATION_INVALID_DECISION: "invalid_decision";
+/** The terminal_state a `@abort` escalation decision finishes the run
+ *  with — a real, human-decided terminal. */
+export declare const ESCALATION_ABORTED_TERMINAL = "escalation_aborted";
+/** Attention `kind` for an engine-raised workflow escalation (sibling of
+ *  `interactive_waiting_operator`). */
+export declare const WORKFLOW_ESCALATION_KIND = "workflow_escalation";
+/** True iff `t` is a reserved generic-escalation token. `other` may be
+ *  carried as a bare `other` or `other: <reason>` (the parser yields the
+ *  bare token; the free text rides the stance evidence channel). */
+export declare function isEscalationToken(t: unknown): t is string;
+/**
+ * The engine-owned prompt-convention snippet. Injected into every
+ * review/consolidate/interactive agent turn (NOT authored). Interpolates
+ * the step's declared semantic outcomes so the agent is told the exact
+ * choices it may pick, plus the escalation contract for "none fit".
+ */
+export declare function renderEscalationPromptSnippet(declaredOutcomes: readonly string[]): string;

package/dist/db/event-log.d.ts

@@ -0,0 +1,40 @@
+import type Database from './sqlite.js';
+export interface EventAppendInput {
+    stream_id: string;
+    event_type: string;
+    /** JSON-serializable event payload. Stored via JSON.stringify; the schema
+     * enforces json_valid(). */
+    payload: unknown;
+    /** The projection's last_seq observed by the caller immediately before this
+     * attempt (e.g. agent_state.last_seq for an INFLIGHT_TAKE). Use 0 when the
+     * projection row does not exist yet (first event of a stream). */
+    observedLastSeq: number;
+    /** ISO-8601 UTC timestamp; display/audit only (seq is the ordering
+     * authority). Defaults to now. */
+    ts?: string;
+    /** Overrides the event_type component of the deterministic event_id intent
+     * tuple. Standing rule: an event type that is (a) NOT backed by a CAS
+     * projection and (b) appendable by multiple distinct actors on one stream
+     * MUST fold actor identity into its intent (e.g.
+     * 'MESSAGE_ACKNOWLEDGED:<actor>') or concurrent distinct-actor appends
+     * collide and silently dedupe. The stored event_type stays clean. */
+    intentKey?: string;
+}
+export interface EventAppendResult {
+    /** False when the deterministic event_id already existed (retried attempt);
+     * the projection update was skipped because the original commit applied it. */
+    appended: boolean;
+    /** The event's seq — freshly assigned, or the existing row's on a dedupe. */
+    seq: number;
+    event_id: string;
+}
+export declare function deterministicEventId(streamId: string, eventType: string, observedLastSeq: number): string;
+/**
+ * Append an event and apply its projection update atomically.
+ *
+ * `updateProjection` runs INSIDE the same transaction, after the event row is
+ * inserted, and receives the new event's seq (projections store it as
+ * `last_seq`). If it throws, the event row is rolled back with it — neither
+ * half ever lands alone.
+ */
+export declare function appendEventWithProjection(db: Database, input: EventAppendInput, updateProjection: (eventSeq: number) => void): EventAppendResult;