@rryando/arcs 3.10.0 → 4.0.0

package/dist/utils/session-store.d.ts

@@ -0,0 +1,339 @@
+/**
+ * Session CRUD storage for ARCS projects.
+ *
+ * Tracks agent runtime sessions (opencode, claude-code) that are attached to a
+ * project. Unlike tasks/plans/knowledge these records are volatile runtime
+ * state: they carry no markdown mirror and never invalidate the graph cache.
+ */
+export type { SessionLinkedNodeType, SessionRuntimeType, SessionStatus, } from "./storage-utils.js";
+export { SESSION_LINKED_NODE_TYPES, SESSION_RUNTIME_TYPES, SESSION_STATUSES, } from "./storage-utils.js";
+/**
+ * Where a session record came from — its provenance, not its state.
+ *
+ * - `observed` — a runtime session ARCS merely watches: a terminal `claude`
+ *   session announcing itself through the hook bridge, or an opencode session
+ *   discovered (or created) on a live opencode server. ARCS can nudge it, but
+ *   something outside ARCS drives it.
+ * - `arcs` — a record ARCS minted for itself (the headless oneshot/stable
+ *   threads). No terminal is attached, so nothing ever drains its message
+ *   queue; it is driven by headless runs only.
+ *
+ * Declared here rather than in storage-utils alongside the other session enums
+ * because origin is derived by this module (legacy promotion below) and every
+ * consumer already imports the session enums through this file.
+ */
+export declare const SESSION_ORIGINS: readonly ["observed", "arcs"];
+export type SessionOrigin = (typeof SESSION_ORIGINS)[number];
+export interface SessionMeta {
+    id: string;
+    normalizedId: string;
+    runtimeType: import("./storage-utils.js").SessionRuntimeType;
+    /** Runtime-native session id, verbatim (e.g. opencode "ses_04f…"). */
+    runtimeSessionId: string;
+    /**
+     * Provenance of the record. Persisted, never client-settable, and never
+     * rewritten by an upsert — whoever created the record fixed it. Always
+     * present on a value read through this module even when the stored record
+     * predates the field (see `withDerivedOrigin`).
+     */
+    origin: SessionOrigin;
+    status: import("./storage-utils.js").SessionStatus;
+    startedAt: string;
+    lastMessageAt?: string;
+    updatedAt: string;
+    userEmail?: string;
+    /**
+     * DAG node this session is working on. Always set together with
+     * `linkedNodeId` — a half-set link is never persisted.
+     */
+    linkedNodeType?: import("./storage-utils.js").SessionLinkedNodeType;
+    /** Normalized task/plan id — never a diagram node id (T001…). */
+    linkedNodeId?: string;
+    /**
+     * Messages accepted from the web UI but not yet delivered. Only runtimes
+     * without a live channel (claude-code) ever populate this: the runtime drains
+     * the queue itself at its next checkpoint. Absent means "nothing pending".
+     */
+    messageQueue?: string[];
+    /**
+     * Id of the headless run currently claimed on this record — written when the
+     * run is spawned and cleared when it settles (`beginSessionRun` /
+     * `settleSessionRun`). Its presence IS the claim: a record carrying one is
+     * believed to have a live `claude` child behind it.
+     *
+     * Written for the runs ARCS drives itself, so in practice every `arcs`-origin
+     * thread; an `observed` record only carries one while a headless run targets
+     * it. Deliberately absent from `UpdateSessionInput`: a claim is a fact about
+     * a process, never something a caller hands in.
+     */
+    currentRunId?: string;
+    /**
+     * OS pid of the claimed run's child. Persisted because in-memory liveness
+     * dies with the server and the restart case is exactly the one that has to be
+     * recoverable — the startup sweep probes this pid to tell a live run from an
+     * orphaned claim.
+     */
+    currentRunPid?: number;
+    /**
+     * ISO-8601 proof of life for the claimed run. Same unit as every other
+     * top-level timestamp on this record; `metadata.run.*` keeps epoch ms and the
+     * two never mix.
+     *
+     * SHORTCUT: nothing refreshes this mid-run yet, so it equals the run's spawn
+     * time and RUN_HEARTBEAT_TTL_MS has to cover a whole run; upgrade to a
+     * periodic touch (and a far shorter TTL) when the runner grows a heartbeat.
+     */
+    heartbeatAt?: string;
+    /**
+     * ISO-8601 time of the last runtime checkpoint ARCS observed — Claude Code's
+     * `UserPromptSubmit` and `Stop` hooks. The only liveness evidence an
+     * `observed` session ever produces: nothing else reports that a terminal
+     * session is still working.
+     */
+    lastCheckpointAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface SessionIndex {
+    sessions: SessionMeta[];
+}
+export interface CreateSessionInput {
+    runtimeType: import("./storage-utils.js").SessionRuntimeType;
+    runtimeSessionId: string;
+    /**
+     * Provenance, set once at creation and defaulting to `observed`. Only the
+     * ARCS-minted headless threads pass `arcs`. Deliberately absent from every
+     * request schema: origin is what capability is derived from, so a client that
+     * could set it could talk itself out of the queue refusal below.
+     */
+    origin?: SessionOrigin;
+    status?: import("./storage-utils.js").SessionStatus;
+    startedAt?: string;
+    lastMessageAt?: string;
+    userEmail?: string;
+    metadata?: Record<string, unknown>;
+    now?: string;
+}
+export interface UpdateSessionInput {
+    id: string;
+    status?: import("./storage-utils.js").SessionStatus;
+    /** Pass `null` to clear; pass an ISO timestamp to set. */
+    lastMessageAt?: string | null;
+    /**
+     * ISO timestamp of a runtime checkpoint just observed (`null` clears it).
+     * Settable here — unlike the run claim — because a checkpoint is a report the
+     * hook bridge relays, not a process ARCS owns.
+     */
+    lastCheckpointAt?: string | null;
+    /** Pass `null` to clear; pass a string to set. */
+    userEmail?: string | null;
+    /** Pass `null` to clear; merged shallowly into the existing metadata. */
+    metadata?: Record<string, unknown> | null;
+    /**
+     * Link target kind. `null` (on either linkage field) clears the whole link.
+     * Setting a link requires both fields to resolve to a value.
+     */
+    linkedNodeType?: import("./storage-utils.js").SessionLinkedNodeType | null;
+    /** Normalized task/plan id — validated against the task/plan store. */
+    linkedNodeId?: string | null;
+    /**
+     * Whole-queue replacement (`null` clears it). Appending/draining goes through
+     * `enqueueSessionMessage`/`drainSessionMessageQueue` instead — a shallow merge
+     * cannot express those safely under concurrent access.
+     */
+    messageQueue?: string[] | null;
+    now?: string;
+}
+export interface SessionFilters {
+    status?: import("./storage-utils.js").SessionStatus;
+    runtimeType?: import("./storage-utils.js").SessionRuntimeType;
+}
+export declare function readSessionIndex(projectDir: string): Promise<SessionIndex>;
+/**
+ * Capability: may a message be handed to this session through `messageQueue`?
+ *
+ * Queued delivery only works when something drains the queue, and the only
+ * drainer is the Claude Code hook script running inside a real terminal
+ * session — an `observed` claude-code record. An `arcs`-origin thread has no
+ * terminal attached, so a message queued for it would sit there forever
+ * (that black hole is what the queue refusal on POST /message closes), and
+ * opencode records take live injection instead of ever queueing.
+ *
+ * Derived from `origin`, never from a metadata string.
+ */
+export declare function canQueue(session: SessionMeta): boolean;
+/**
+ * What a session is doing right now, as a reader of the UI would say it.
+ *
+ * DERIVED, never stored: there is no `phase` field on `SessionMeta` and no way
+ * to write one through this module. A stored phase is a second source of truth
+ * that goes stale the instant a process dies without telling anyone — which is
+ * precisely the "stuck on running forever" failure this replaces.
+ */
+export declare const SESSION_PHASES: readonly ["running", "idle", "failed", "ended"];
+export type SessionPhase = (typeof SESSION_PHASES)[number];
+/**
+ * Outcome vocabulary persisted on `metadata.run.outcome`. A superset of the
+ * runner's own `RunOutcome` ("success" | "error" | "timeout"): `interrupted` is
+ * never produced BY a run, it is written FOR a run whose process disappeared
+ * without ever settling — a restart's orphan. Declared here rather than
+ * imported from the web server because `utils/` must not depend on
+ * `web-server/`; claude-runner's union stays exactly what a child can return.
+ */
+export declare const SESSION_RUN_OUTCOMES: readonly ["success", "error", "timeout", "interrupted"];
+export type SessionRunOutcome = (typeof SESSION_RUN_OUTCOMES)[number];
+/**
+ * How long a run claim's heartbeat counts as proof of life. Sized to the
+ * runner's default 10-minute run ceiling because nothing refreshes the
+ * heartbeat mid-run yet (see `SessionMeta.heartbeatAt`) — a shorter window
+ * would demote a perfectly healthy long run to `idle`.
+ */
+export declare const RUN_HEARTBEAT_TTL_MS: number;
+/**
+ * How long a runtime checkpoint counts as proof of life for an observed
+ * session. Deliberately shorter than the run TTL: checkpoints arrive at every
+ * prompt and every turn end, so a terminal that has produced neither in five
+ * minutes is waiting on a human, not working.
+ */
+export declare const CHECKPOINT_TTL_MS: number;
+export interface SessionPhaseOptions {
+    /** Clock in epoch ms; defaults to `Date.now()`. */
+    now?: number;
+    heartbeatTtlMs?: number;
+    checkpointTtlMs?: number;
+}
+/**
+ * The record's run claim, or `undefined` when it holds none. Validated rather
+ * than trusted: a hand-edited index can carry anything under this key.
+ */
+export declare function sessionRunClaim(session: SessionMeta): string | undefined;
+/**
+ * Derives a session's phase from its own persisted evidence, in one place.
+ *
+ * Precedence, strongest first:
+ *  1. a terminal `status` — `failed` is `failed`, `completed`/`disconnected`
+ *     are `ended`. Nothing observed later reopens a session that is over.
+ *  2. a run claim (`currentRunId`) — ARCS spawned a child for this record, so
+ *     its `heartbeatAt` is the freshest evidence there is. Stale means the
+ *     claim outlived its proof of life, which reads `idle`, not `failed`: the
+ *     run is settled by the reconciler, not guessed at here.
+ *  3. `lastCheckpointAt` — the only signal an observed terminal session emits.
+ *
+ * `metadata.run.outcome` is deliberately NOT an input. That field is run-level
+ * history (rendered next to the run), while phase answers "is this session live
+ * right now" — a run that failed an hour ago leaves the session idle and ready
+ * for the next one, not permanently `failed`.
+ *
+ * Pure: a record plus a clock, no I/O, no process probing. Liveness that needs
+ * the world (a pid, `claude agents`) belongs to the reconciler, which starts
+ * from this value and can only ever demote it.
+ *
+ * SHORTCUT: checkpoint freshness cannot tell `UserPromptSubmit` (turn started)
+ * from `Stop` (turn ended), so a session reads `running` for the TTL after its
+ * last turn; upgrade to a persisted checkpoint kind when the panel needs
+ * turn-level precision.
+ */
+export declare function deriveSessionPhase(session: SessionMeta, options?: SessionPhaseOptions): SessionPhase;
+export declare function createSession(projectDir: string, input: CreateSessionInput): Promise<SessionMeta>;
+/**
+ * Create-or-update by runtime session id. Used by runtime discovery bridges,
+ * which see the same session many times and must stay idempotent.
+ *
+ * Deliberately never touches `linkedNodeType`/`linkedNodeId`: discovery
+ * refreshes carry status/metadata only and must not silently unlink a session
+ * a human just linked. Linkage is `updateSession`-only.
+ */
+export declare function upsertSession(projectDir: string, input: CreateSessionInput): Promise<SessionMeta>;
+export declare function listSessions(projectDir: string, filters?: SessionFilters): Promise<SessionMeta[]>;
+export declare function getSession(projectDir: string, sessionId: string): Promise<SessionMeta>;
+export declare function updateSession(projectDir: string, input: UpdateSessionInput): Promise<SessionMeta>;
+/**
+ * Appends a message to a session's pending queue.
+ *
+ * Deliberately not part of `updateSession`: the generic path shallow-merges
+ * whatever the caller passes, which would let two concurrent senders read the
+ * same array and write back a queue missing one message. Append happens inside
+ * the store lock, so the read-modify-write is atomic.
+ *
+ * The message is stored verbatim — callers validate content (the route rejects
+ * empty strings before it gets here).
+ */
+export declare function enqueueSessionMessage(projectDir: string, sessionId: string, message: string): Promise<SessionMeta>;
+/**
+ * Reads and clears a session's pending queue in one lock acquisition.
+ *
+ * Read-then-clear must be atomic: a checkpoint that read the queue and cleared
+ * it in two calls would drop any message enqueued in between. Delivery is
+ * at-most-once — a consumer that crashes after draining loses the batch, which
+ * is the accepted trade for never replaying a message twice into a session.
+ */
+export declare function drainSessionMessageQueue(projectDir: string, sessionId: string): Promise<string[]>;
+export interface BeginSessionRunInput {
+    /** Caller-minted id for this run — the claim's identity. */
+    runId: string;
+    /** OS pid of the spawned child; absent/`null` when the spawn produced none. */
+    pid?: number | null;
+    /** ISO override for the heartbeat and `updatedAt` stamps (tests). */
+    now?: string;
+}
+export interface SettleSessionRunInput {
+    /**
+     * Settles only when it matches the persisted claim. Omit to settle whatever
+     * claim is there (the startup sweep passes the id it read, so a run that
+     * started in between is never settled out from under itself).
+     */
+    runId?: string;
+    outcome: SessionRunOutcome;
+    error?: string;
+    /** Epoch ms for `metadata.run.endedAt` — defaults to now. */
+    endedAt?: number;
+    /**
+     * Extra `metadata.run` fields stamped in the SAME write as the outcome: what
+     * the RUNNER measured and no claim could have known at spawn (the pid and
+     * startedAt the child actually reported, the run's mode, the stream
+     * observations). Merged UNDER the settle's own fields, so `outcome`/`endedAt`/
+     * `error` can never be smuggled past the settle that owns them.
+     */
+    run?: Record<string, unknown>;
+    /**
+     * Sibling `metadata` keys written in the same read-modify-write, shallow
+     * merged as `updateSession` merges. The seed-decision repair rides here: a
+     * settle that released the claim in one write and repaired the record in a
+     * second is readable in between as "this run failed" while still carrying the
+     * seed state that failed it — and the second write can land AFTER a newer run
+     * has already claimed the record, clobbering its live `metadata.run`. Merged
+     * UNDER `run`, so `run` can never be rewritten through this door.
+     */
+    metadata?: Record<string, unknown>;
+    /** ISO override for `updatedAt` (tests). */
+    now?: string;
+}
+/**
+ * Claims a session for a headless run: persists the run id, the child's pid and
+ * the first heartbeat, all of which survive the server process that made them.
+ *
+ * The claim is what makes a run recoverable. In-memory liveness (the runner's
+ * `liveRuns` map) dies with the server, so without a persisted claim a run
+ * interrupted by a restart would leave the session reading `running` forever
+ * with nothing left that could ever settle it.
+ */
+export declare function beginSessionRun(projectDir: string, sessionId: string, input: BeginSessionRunInput): Promise<SessionMeta>;
+/**
+ * Releases a session's run claim, records how the run ended on `metadata.run`,
+ * and applies whatever the settle repaired — in ONE lock acquisition.
+ *
+ * Read-modify-write has to be atomic: `metadata.run` is replaced wholesale by
+ * every writer, so settling through the generic `updateSession` would race the
+ * route's own write-back and could drop the run's pid/startedAt.
+ *
+ * Everything a settle concludes therefore goes in HERE rather than in a
+ * follow-up `updateSession`. The claim is the only thing serializing a run
+ * against the next one, and releasing it is the LAST thing this write does — so
+ * a conclusion left to a second write is both observable in the gap (the record
+ * reads settled while still carrying the state the run just disproved) and
+ * unguarded outside it: the `input.runId` check above holds only for the
+ * duration of this lock, and a newer run can claim the record the moment it is
+ * released.
+ */
+export declare function settleSessionRun(projectDir: string, sessionId: string, input: SettleSessionRunInput): Promise<SessionMeta>;
+export declare function deleteSession(projectDir: string, sessionId: string): Promise<void>;
+//# sourceMappingURL=session-store.d.ts.map

package/dist/utils/session-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../src/utils/session-store.ts"],"names":[],"mappings":"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"}