sensorium-mcp 3.1.2 → 3.1.3-board.10

package/dist/data/memory/thread-registry.d.ts

@@ -6,12 +6,14 @@
  */
 import type { Database } from "./schema.js";
 import type { IThreadRepository } from "../interfaces.js";
+import { Optional } from "../optional.js";
 export interface ThreadRegistryEntry {
     id: number;
     threadId: number;
     name: string;
     type: "root" | "daily" | "branch" | "worker";
     rootThreadId: number | null;
+    notifyThreadId: number | null;
     badge: string;
     client: string;
     maxRetries: number;
@@ -26,7 +28,9 @@ export interface ThreadRegistryEntry {
     lastActiveAt: string | null;
     sessionResetAt: string | null;
     cleanShutdown: boolean;
-    status: "active" | "archived" | "expired" | "exited";
+    /** Mirrors the persisted thread_registry status CHECK (schema-ddl.ts / migration 23).
+     *  Narrower than the CHECK would make reads an unchecked cast. */
+    status: "created" | "spawning" | "active" | "stuck" | "exiting" | "exited" | "archived" | "expired";
     archivedAt: string | null;
     summary: string | null;
 }
@@ -35,6 +39,7 @@ type RegisterThreadEntry = {
     name: string;
     type: ThreadRegistryEntry["type"];
     rootThreadId?: number;
+    notifyThreadId?: number;
     badge?: string;
     client?: string;
     maxRetries?: number;
@@ -53,37 +58,238 @@ export declare class ThreadRepository implements IThreadRepository {
     getRootThreads(db: Database): ThreadRegistryEntry[];
 }
 export declare const threadRepository: ThreadRepository;
+/**
+ * The row seam, and the one place the minted-id rule is stated for `thread_registry`.
+ *
+ * A worker's identity is MINTED ({@link mintThreadId}, called from `birthWorker`), so a
+ * `type = 'worker'` row below {@link MINTED_THREAD_ID_FLOOR} is not a worker anything
+ * mints — it is a Telegram topic number wearing a worker's type, and every id-reuse
+ * failure this line has chased (a worker inheriting an earlier occupant's lifecycle, a
+ * sweep deleting a live thread's forum topic because the id IS the topic) starts there.
+ *
+ * It is refused HERE because this statement is where `type` enters the table: the INSERT
+ * writes `entry.type`, and the ON CONFLICT arm below either PRESERVES the stored type
+ * (while `keep_alive = 1`) or writes `excluded.type`, which is this same `entry.type`.
+ * No other writer introduces one — `UpdateThreadPatch` has no `type` field, and
+ * `handleConvertToRoot`'s direct UPDATE writes the literal 'root'. A preserved type was
+ * therefore introduced by an earlier call through this guard, or predates migration 39,
+ * which purged what did.
+ *
+ * It THROWS where the entrances above it answer in prose. `handleCreateThread` and
+ * `handleStartThread` refuse their own callers with a sentence naming the one way to get
+ * a worker, because those callers are an agent or an HTTP client that can act on it;
+ * an entry arriving here already carries the contradiction, and there is no row this
+ * function could write instead that the caller asked for.
+ */
 export declare function registerThread(db: Database, entry: RegisterThreadEntry): ThreadRegistryEntry;
+/**
+ * Allocate a thread id that no thread has ever held and none ever will again —
+ * GIVEN the allocating INSERT autocommits, which is what the first guard enforces.
+ * Inside an enclosing `db.transaction`, SQLite's AUTOINCREMENT mark rolls back with
+ * everything else and the next mint is handed the same number (measured), so the
+ * promise is not available mid-transaction and is refused rather than weakened.
+ *
+ * That refusal breaks no correct caller, because the sound order is mint, commit,
+ * then register: the id has to be durable before any row, file, process or wire
+ * message names it. A caller wanting mint-and-register atomically still mints first
+ * and tolerates the gap on a crash — a minted-never-used id is this design's native
+ * waste product, and never reusing one is exactly what makes those gaps free.
+ *
+ * Why the sequence is shaped the way it is — and why the mark survives a hard
+ * `deleteThread` and the 180-day purge — is argued on THREAD_ID_SEQUENCE_DDL. The
+ * trim that keeps the table at one row carries a WHERE and so cannot lower it.
+ *
+ * The floor is asserted rather than assumed. An id below it is a Telegram topic
+ * number as far as every reader of `thread_registry.thread_id` is concerned, and the
+ * two states that produce one — an unseeded sequence, or a lowered floor — are
+ * both silent. Refusing to mint is the only answer a caller cannot paper over.
+ */
+export declare function mintThreadId(db: Database): number;
 export declare function getThread(db: Database, threadId: number): ThreadRegistryEntry | null;
+/** Registry badge marking an ephemeral task-board card worker. */
+export declare const BOARD_WORKER_BADGE = "board-worker";
+/**
+ * Whether a thread's own episodic memory writes are suppressed. Currently true
+ * for ephemeral board-card workers, whose state lives in card comments rather
+ * than Sensorium episodes. Named for the memory concern so the episode layer
+ * asks a memory-domain question and never learns the board badge value.
+ */
+export declare function suppressesEpisodicMemory(db: Database, threadId: number): boolean;
 export declare function getThreadByName(db: Database, name: string): ThreadRegistryEntry | null;
 export declare function getThreadsByRoot(db: Database, rootThreadId: number): ThreadRegistryEntry[];
 export declare function getRootThreads(db: Database): ThreadRegistryEntry[];
-export declare function getDailyRotationThreads(db: Database): ThreadRegistryEntry[];
+/**
+ * All non-worker, non-archived threads. The nightly memory pass (consolidation,
+ * reflection, narrative) runs for every one of these — memory integrity is
+ * required by all threads, not just those opted into session rotation. Workers
+ * are excluded because their memory is no-persist (discarded on decommission).
+ */
+export declare function getConsolidationThreads(db: Database): ThreadRegistryEntry[];
 export declare function getKeepAliveThreads(db: Database): ThreadRegistryEntry[];
 export declare function getAllThreads(db: Database): ThreadRegistryEntry[];
 export declare function getActiveThreads(db: Database): ThreadRegistryEntry[];
 /** All non-archived threads — for dashboard display. */
 export declare function getDashboardThreads(db: Database): ThreadRegistryEntry[];
 export declare function updateThread(db: Database, threadId: number, updates: UpdateThreadPatch): boolean;
+/** Archive a row. False when there is no row, a start holds it ('spawning'), or a
+ *  purge has marked it — re-stamping archived_at under a purge would be a false 200. */
 export declare function archiveThread(db: Database, threadId: number): boolean;
 export declare function unarchiveThread(db: Database, threadId: number): boolean;
-export declare function getArchivedThreads(db: Database): ThreadRegistryEntry[];
+/**
+ * Archived threads, workers EXCLUDED by default.
+ *
+ * The exclusion is right for the overview this feed was written for — a swarm
+ * run leaves dozens of decommissioned workers that would bury the handful of
+ * roots and branches an operator actually recognises. It was wrong as the ONLY
+ * answer: this is the single feed behind the archived-threads tab, which is the
+ * single place the permanent delete can be invoked from, and 220 of the 225
+ * per-thread config dirs on the live host (230 of its 320 MB) belong to exactly
+ * the archived workers it hid. The delete API itself never had a type filter —
+ * only the list did — so the bytes were unreachable rather than protected.
+ *
+ * `includeWorkers` is opt-in so every existing caller keeps the behaviour it
+ * was written against.
+ */
+export declare function getArchivedThreads(db: Database, opts?: {
+    includeWorkers?: boolean;
+}): ThreadRegistryEntry[];
+/**
+ * Drop ONLY the registry row. Not a purge, and not reachable from the operator's
+ * delete any more — that goes through `purgeThread`, which takes every dependent
+ * table with it.
+ *
+ * It stays because worker-birth's PRE-SPAWN teardown wants exactly this: a row it
+ * registered moments ago, for a worker no process has run as, so nothing has been
+ * written against the id yet and there is nothing for a purge to find.
+ * `purgeThread` would refuse that row (no purge marked it: it is active, not
+ * archived). Do not reach for this to retire a thread that has ever run.
+ */
 export declare function deleteThread(db: Database, threadId: number): boolean;
 /**
- * Purge archived threads older than `maxAgeMs` (default 180 days).
- * Deletes the thread's associated data and registry entry.
- * Returns the number of threads purged.
+ * How long an archived thread survives before the daily sweep purges it.
+ *
+ * Was 180 days. The sweep is a floor, not the only way out — an archived thread
+ * now also has an explicit, operator-driven permanent delete (purgeThread +
+ * purgeThreadFiles, surfaced as `DELETE /api/threads/:id?hard=true`). With a
+ * deliberate path available, the automatic one no longer has to be the thing
+ * that reclaims disk, so the window is long enough that nothing is ever lost to
+ * a timer the operator forgot about. Exported so operator-facing text states
+ * the real number instead of a stale literal.
+ */
+export declare const ARCHIVED_THREAD_PURGE_DAYS = 730;
+/**
+ * Mark an archived row as being purged, answering the stamp written: the fence
+ * a finisher must still see to act. Empty means the purge lost: the row is not
+ * archived any more (a start claimed it), already marked, gone, or — when
+ * `archivedAt` is given — re-archived with a newer stamp than the one judged.
  */
-export declare function purgeOldArchivedThreads(db: Database, maxAgeMs?: number): number;
+export declare function markThreadPurging(db: Database, threadId: number, archivedAt?: string): Optional<string>;
+/** True while a purge owns the row (markThreadPurging): every door refuses it. */
+export declare function isThreadMarkedForPurge(db: Database, threadId: number): boolean;
+/** The mark a purge holds on the row now, or empty when none does. */
+export declare function threadPurgeMark(db: Database, threadId: number): Optional<string>;
+/**
+ * What a start's claim on a thread row found:
+ *   - "claimed": the row was resting (`previous`) and is now `claimedAs`, so the
+ *     start owns it and must hand it back (releaseThreadStart) if it does not go
+ *     ahead;
+ *   - "free": nothing to take — no row yet, or a row a process is already on;
+ *   - "starting": the row is 'spawning' — another start holds it between its
+ *     claim and its spawn's answer. A spawning start (start_thread, dashboard
+ *     /start) must refuse ("already starting") rather than write the same id's
+ *     files beside it (inc66 M3); start_session attaches instead, taking nothing;
+ *   - "purging": a purge owns the row, and the start must refuse.
+ */
+export type ThreadStartClaim = {
+    kind: "claimed";
+    previous: string;
+    claimedAs: "spawning" | "active";
+} | {
+    kind: "free";
+} | {
+    kind: "starting";
+} | {
+    kind: "purging";
+};
+/**
+ * Every start of an existing id calls this BEFORE its first file write. It flips
+ * a resting row to `status` ('spawning' for a spawn, 'active' for a session that
+ * revives its thread), which is a state a purge refuses to mark. Synchronous and
+ * in one transaction, so the read, the flip and the note restore see the same row.
+ * A revived ARCHIVED row gets its archived notes back, exactly as unarchiveThread.
+ */
+export declare function claimThreadStart(db: Database, threadId: number, status: "spawning" | "active"): ThreadStartClaim;
+/** Hand a claimed row back to the status it was taken from when its start failed. */
+export declare function releaseThreadStart(db: Database, threadId: number, claim: ThreadStartClaim): void;
+/**
+ * Delete ONE thread's entire DB footprint — the registry row, then every table in
+ * THREAD_DEPENDENT_DELETES — in a single transaction. This is the LAST step of a
+ * purge: only a row still carrying the exact mark `purgingAt` this purge holds is
+ * deleted, so a row nobody marked, one a start took first, or a successor's row
+ * marked again matches nothing and the purge touches no dependent row. A row
+ * already gone means another purge finished it, and anything still keyed to the
+ * id is an orphan, which this cleans up. Returns true when this call deleted the
+ * registry row.
+ *
+ * DB only. On-disk per-thread artifacts are purgeThreadFiles' job
+ * (src/services/thread-purge.service.ts), and they are removed BEFORE this runs.
+ */
+export declare function purgeThread(db: Database, threadId: number, purgingAt: string): boolean;
+/** Rows a purge marked and has not finished, with each mark: a crash between
+ *  mark and row delete, a leftover that kept the rows, or a purge still awaiting
+ *  its file work. */
+export declare function selectThreadsMidPurge(db: Database): {
+    threadId: number;
+    purgingAt: string;
+}[];
+/**
+ * One archived row carrying an archive anchor, STRAIGHT FROM THE DB AND
+ * UNVALIDATED. The column types are what the schema declares, not what SQLite
+ * enforces: `thread_id` becomes a filesystem path segment and `archived_at`
+ * decides whether a thread is old enough to destroy, so the purge service
+ * validates both before either is used (isPurgeableThreadId and archiveAnchorMs
+ * in sweepOldArchivedThreads).
+ */
+export interface AnchoredArchivedRow {
+    threadId: number;
+    archivedAt: string;
+}
+/**
+ * Every archived thread that has an archive anchor — NOT a cutoff query, and
+ * nothing is deleted here. The age test lives in the sweep, in JavaScript, on
+ * parsed instants: `archived_at < cutoff` in SQL is a TEXT comparison, so a
+ * stamp that is not a canonical UTC ISO instant (`...-02:00`, a different
+ * precision) compares by characters rather than by time, and this is the
+ * predicate of an unattended delete.
+ *
+ * The sweep also has to gate each candidate on liveness — an async question no
+ * SQLite transaction can hold open — which is why selection and deletion are
+ * separate calls at all: `sweepOldArchivedThreads` in
+ * services/thread-purge.service.ts selects, validates, gates, marks, then purges.
+ *
+ * ANCHORED ON `archived_at`, NOT `last_active_at`. "730 days of grace after
+ * archiving" is what the window means, and last activity does not express it: a
+ * thread archived today whose last message was three years ago was eligible on
+ * the very next sweep. Every archived row has an anchor: updateThread derives it
+ * from the status, and migration 40 stamped the rows archived before it did.
+ */
+export declare function selectAnchoredArchivedThreads(db: Database): AnchoredArchivedRow[];
 /**
  * Reset the daily session timestamp for a thread.
  * Sets session_reset_at = now, used by bootstrap to filter the message buffer.
  */
 export declare function resetDailySession(db: Database, threadId: number): boolean;
 /**
- * Mark a thread's session as running (clean_shutdown = 0). Called at session
- * start; if the process dies before a graceful exit flips it back to 1, the
- * next resume sees 0 and knows the previous session was interrupted.
+ * Mark a thread's session as running (clean_shutdown = 0). Called from
+ * start_session, and the only write that clears the flag.
+ *
+ * The column now carries ONE meaning that code acts on: 0 = "the process
+ * currently attached to this thread reached start_session". spawn-common's
+ * registerSpawnedProcess sets it back to 1 for every new process, and the
+ * birth-death respawn net reads it to tell a thread that died before it ever
+ * registered from one that ran and then exited. (Its original job — letting the
+ * next resume notice an interrupted session — is handled by the memory
+ * briefing's self-judge prompt instead.)
  */
 export declare function markSessionRunning(db: Database, threadId: number): boolean;
 /**
@@ -91,8 +297,13 @@ export declare function markSessionRunning(db: Database, threadId: number): bool
  * alive at graceful exit (SIGTERM/SIGINT, maintenance restart), so a planned
  * server stop is not mistaken for a crash by the threads it takes down.
  * A thread that had already crashed lingers as status='active' but is absent
- * from aliveThreadIds, so its clean_shutdown stays 0 and the next resume
- * correctly detects the interruption. An empty list marks nothing.
+ * from aliveThreadIds, so its flag stays 0. An empty list marks nothing.
+ *
+ * In the {@link markSessionRunning} reading this says "no live process of ours
+ * is registered on that thread any more", which is true — the server is exiting.
+ * Agent children are detached and outlive it, so nothing re-reads the flag until
+ * they are re-adopted or respawned, and the respawn net's uptime window keeps a
+ * long-lived survivor out of scope.
  */
 export declare function markAliveThreadsCleanShutdown(db: Database, aliveThreadIds: number[]): number;
 /**
@@ -108,9 +319,113 @@ export declare function resolveTelegramTopicId(db: Database, threadId: number):
  */
 export declare function getExplicitTelegramTopicId(db: Database, threadId: number): number | null;
 /**
- * Backfill thread names from topic_registry for threads with empty/missing names.
- * Returns the number of threads updated.
+ * Record that `topicId` is gone by clearing the thread's stored pointer — only while
+ * the pointer still names `topicId`. A compare-and-clear, because every caller clears
+ * after an AWAITED delete: a pointer written in the meantime (the dashboard PATCH)
+ * names a topic that caller never deleted, and blanking it would hide that topic from
+ * the orphan sweep, which selects only stored pointers. Returns whether it cleared.
+ */
+export declare function clearTelegramTopicIdIfStill(db: Database, threadId: number, topicId: number): boolean;
+/**
+ * The topic number a DESTRUCTIVE teardown may aim at, stated once so no call site
+ * has to guess. Three arms, and the third is the point:
+ *
+ * 1. the explicit pointer when the row carries one — the only positive evidence of
+ *    which topic this thread owns;
+ * 2. else the thread id itself, but ONLY below {@link MINTED_THREAD_ID_FLOOR}: a
+ *    NULL column on a topic-numbered thread means the id IS the topic, which is
+ *    still true of every thread not born on the board's minting path;
+ * 3. else NOTHING. A minted id is not a topic number — the floor sits above int32
+ *    and Telegram topic ids are int32 — so falling back to it aims the delete at a
+ *    number no topic can have. Telegram answers TOPIC_ID_INVALID, which teardown
+ *    reads as "already gone", and the real topic is archived out of reach of every
+ *    sweep that looks for a stored pointer. Returning nothing is safe precisely
+ *    because no topic is recorded: there is no delete to retry later, so a caller
+ *    may treat the empty answer as a reached end state rather than a failure.
+ *
+ * Arm 2 becomes dead code once no below-floor worker remains.
+ */
+export declare function resolveDeletableTelegramTopicId(db: Database, threadId: number): Optional<number>;
+/**
+ * The liveness predicate for a Telegram topic: which OTHER live thread, if any,
+ * still claims `topicId`.
+ *
+ * A Telegram topic is a shared, externally owned, DESTRUCTIVE resource, and this
+ * is the one question every delete site must ask first. Three separate paths
+ * (a stale `decommissionWorker` that continued past a failed transition, the
+ * periodic archived-worker orphan sweep, and the dashboard archive/hard-delete
+ * route) each resolved a topic and deleted it while a live thread still owned it,
+ * because each checked only its OWN row.
+ *
+ * Two arms, both load-bearing:
+ *  - `telegram_topic_id = ?` — the explicit claim.
+ *  - `telegram_topic_id IS NULL AND thread_id = ?` — the IMPLICIT claim.
+ *    `resolveTelegramTopicId` reads a NULL column as "my topic is my thread_id",
+ *    so a live row with a NULL column genuinely owns that topic number. Without
+ *    this arm the orphan sweep can delete a live thread's topic.
+ *
+ * `excludingThreadId` is the thread doing the deleting: it must never count
+ * itself as a claimant, or the ordinary case (a row tearing down the topic it
+ * alone holds) would stop deleting anything at all.
+ *
+ * Synchronous, like every other read here — which is what lets the dashboard's
+ * sync `handleDeleteThread` gate its fire-and-forget delete without becoming
+ * async and without moving its response.
+ */
+export declare function liveThreadClaimingTopic(db: Database, topicId: number, excludingThreadId: number): Optional<number>;
+/**
+ * The routing half of the ownership question: which thread, if any, should
+ * receive a message that arrived in `topicId`.
+ *
+ * TWO STAGES, and the priority between them is the point:
+ *   1. the LIVE owner — `TERMINAL_TOPIC_STATUSES` excluded, as the delete gate
+ *      does;
+ *   2. only when stage 1 is empty, the `exited` row that explicitly claims it.
+ *
+ * The stages are two SEQUENTIAL QUERIES with an early return, NOT an ordering
+ * inside one SELECT, and the distinction is worth stating because the paragraph
+ * below argues against an `ORDER BY`. The thing rejected there is an ARBITRARY
+ * tiebreak between rows no requirement ranks; this is a named priority between
+ * two different QUESTIONS, asked in order. A reader must not take one for the
+ * other.
+ *
+ * LIVE ALWAYS BEATS EXITED. That ordering is what stops a dead predecessor
+ * stealing a live successor's messages when both claim one topic — a state the
+ * dashboard PATCH route makes reachable today, and one that mint-once thread ids
+ * will GUARANTEE, since every respawn then has an exited row and a live row on
+ * the same topic by design.
+ *
+ * Stage 2 admits `exited` and only `exited`. `exited` → Active is a legal
+ * transition (`VALID_TRANSITIONS`), the dashboard permits starting an exited
+ * thread, and the wait poll loop evicts a parked agent only on `archived` /
+ * `expired` — so an exited row is one that may still be listening at its logical
+ * id, or be resumed to consume its backlog, while a message left at
+ * `<topicId>.jsonl` is read by nothing. `expired` stays OUT because `expired` →
+ * Active is structurally forbidden (Expired goes only to Archived) and the
+ * dashboard refuses to start it; `archived` stays OUT because an archived thread
+ * resumes by being REMAPPED onto a new topic while its old one is torn down by
+ * design.
+ *
+ * Only the EXPLICIT claim, in both stages. `liveThreadClaimingTopic`'s second arm
+ * (`telegram_topic_id IS NULL AND thread_id = ?`) is dead for routing: it can
+ * only ever answer `thread_id`, which equals `topicId`, which is already what the
+ * caller falls back to when this returns empty.
+ *
+ * No ORDER BY, matching the sibling. No LIFECYCLE writer can give two rows the
+ * same explicit `telegram_topic_id`: the column's one write seam is
+ * `updateThread`, every lifecycle caller writes either the row's own `thread_id`
+ * or an id Telegram just minted for that write, and the orphan sweep and
+ * `decommissionWorker` only clear.
+ * Minted ids are assumed unique within the configured chat — Telegram's
+ * numbering, not ours; unenforced here, and void if this registry is ever pointed
+ * at a different chat. The dashboard PATCH route (`buildThreadUpdates`) is the
+ * known exception: it writes any number the operator sends, so a two-claimant
+ * pair is operator-reachable, and WITHIN one stage this query then returns
+ * whichever row SQLite scans first — exactly the base behaviour. An ORDER BY
+ * would encode a winner no requirement names. The typed-open
+ * `ActivateThreadInput` / `TouchThreadInput` seam accepts a `telegramTopicId`
+ * too, with no production caller passing one today.
  */
-export declare function backfillMissingNames(db: Database): number;
+export declare function threadOwningTopic(db: Database, topicId: number): Optional<number>;
 export {};
 //# sourceMappingURL=thread-registry.d.ts.map

package/dist/data/memory/thread-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thread-registry.d.ts","sourceRoot":"","sources":["../../../src/data/memory/thread-registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"thread-registry.d.ts","sourceRoot":"","sources":["../../../src/data/memory/thread-registry.ts"],"names":[],"mappings":"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"}