@primusclaw/personal-agent-runtime 0.0.0-stage → 0.1.0

package/dist/types/sqlite/approval-repository.d.ts

@@ -0,0 +1,19 @@
+/** ApprovalRepository on SQLite (table `approvals`). Which cards are being sent right now is kept in this process only;
+ * what outlives a crash is the `card_sent` column: a card recorded and not marked sent is sent by the next process. */
+import { type Approval, type ApprovalRepository, type ApprovalState, type NewApproval, type UnsentCard } from "@primusclaw/personal-agent";
+import type { StoreContext } from "./context.js";
+export declare class SqliteApprovalRepository implements ApprovalRepository {
+    #private;
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    saveApproval(approval: NewApproval): boolean;
+    approvalSent(sessionId: string, toolUseId: string): void;
+    approvalInFlight(sessionId: string, toolUseId: string): boolean;
+    forgetApproval(sessionId: string, toolUseId: string): void;
+    claimUnsentApprovals(): UnsentCard[];
+    approvalSendFailed(sessionId: string, toolUseId: string): void;
+    getApproval(sessionId: string, toolUseId: string): Approval | null;
+    closeApproval(sessionId: string, toolUseId: string, state: ApprovalState, options?: {
+        readonly onlyIfPending?: boolean;
+    }): boolean;
+}

package/dist/types/sqlite/assistant-repository.d.ts

@@ -0,0 +1,42 @@
+/** The assistant's cards and messages on SQLite (tables `assistant_cards`, `auto_replies`, `assistant_action_cards`,
+ * `assistant_confirm_cards`, `assistant_messages`). */
+import { type ActionCard, type AssistantButtonRepository, type AssistantCard, type AssistantCardRepository, type AssistantMessage, type AssistantMessageRepository, type CardState, type ConfirmCard, type JsonObject, type MoveOptions, type PlacedCard } from "@primusclaw/personal-agent";
+import { type StoreContext } from "./context.js";
+export declare class SqliteAssistantCardRepository implements AssistantCardRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    addAssistantCard(userId: string, itemId: string, version: number, canAccept: boolean): string;
+    getAssistantCard(cardId: string): AssistantCard | null;
+    endAssistantCard(cardId: string, ended: string): boolean;
+    placeAssistantCard(cardId: string, placement: {
+        readonly activityId: string;
+        readonly reference: JsonObject;
+        readonly render: JsonObject;
+    }): void;
+    placedAssistantCards(filter: {
+        readonly itemId: string;
+    } | {
+        readonly since?: number;
+    }): PlacedCard[];
+    moveAssistantCard(cardId: string, state: CardState, options?: MoveOptions): boolean;
+    setAutoReply(userId: string, itemId: string, pull: string): void;
+    autoReply(userId: string, itemId: string): string | null;
+    clearAutoReply(userId: string, itemId: string): void;
+}
+export declare class SqliteAssistantButtonRepository implements AssistantButtonRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    addActionCard(userId: string, channelMessageId: string, name: string, args: string): string;
+    getActionCard(cardId: string): ActionCard | null;
+    moveActionCard(cardId: string, state: CardState, options?: MoveOptions): boolean;
+    addConfirmCard(userId: string, confirmationId: string, kind: string, label?: string): string;
+    getConfirmCard(cardId: string): ConfirmCard | null;
+    moveConfirmCard(cardId: string, state: CardState, options?: MoveOptions): boolean;
+}
+export declare class SqliteAssistantMessageRepository implements AssistantMessageRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    noteAssistantMessage(channelMessageId: string, userId: string, actions: readonly string[], people?: readonly string[]): void;
+    assistantMessagePeople(channelMessageId: string): ReadonlySet<string>;
+    assistantMessage(channelMessageId: string): AssistantMessage | null;
+}

package/dist/types/sqlite/context.d.ts

@@ -0,0 +1,38 @@
+/** What every repository of the SQLite store shares: the connection, the clock, randomness and the stored-secret keys. */
+import type { Random } from "@primusclaw/personal-agent";
+import { Fernet, MultiFernet } from "../crypto/fernet.js";
+import type { Database } from "./database.js";
+/** The fields a security event of the store carries (`link_attempt`, `link_lockout`); the sink filters and logs them. */
+export type SecurityEventFields = Readonly<Record<string, string | number | undefined>>;
+export type SecurityEventSink = (event: "link_attempt" | "link_lockout", fields: SecurityEventFields) => void;
+/**
+ * The keys of TEAMS_ENCRYPTION_KEYS: the first encrypts and hashes new link codes, every one decrypts and finds a code
+ * (adding a key at the head does not void the codes of the last 10 minutes).
+ */
+export declare class StoreSecrets {
+    #private;
+    readonly primary: Fernet;
+    readonly all: MultiFernet;
+    constructor(keys: readonly string[], nowSeconds?: () => number);
+    /** A Fernet token as the store keeps it (a BLOB of the token's ASCII). */
+    encrypt(text: string): Uint8Array;
+    /** The text, or null when no configured key reads it. */
+    decrypt(token: Uint8Array): string | null;
+    /** The code's stored hash under the first key. */
+    primaryHash(code: string): string;
+    /** The code's hash under every key. */
+    hashes(code: string): string[];
+}
+export interface StoreContext {
+    readonly db: Database;
+    /** Epoch seconds. */
+    readonly now: () => number;
+    readonly random: Random;
+    readonly secrets: StoreSecrets;
+}
+/** Python's `secrets.token_urlsafe(n)`: n random bytes, base64url without padding. */
+export declare function tokenUrlsafe(random: Random, n: number): string;
+/** Python's `secrets.token_hex(n)`. */
+export declare function tokenHex(random: Random, n: number): string;
+/** `n` characters drawn uniformly from `alphabet` (Python's `secrets.choice` per character). */
+export declare function drawCode(random: Random, alphabet: string, n: number): string;

package/dist/types/sqlite/database.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The one SQLite connection a store works on, with typed statement helpers. Opened as the Python worker opens it:
+ * autocommit (`isolation_level=None`), WAL, and a 5 s busy timeout (`sqlite3.connect`'s default).
+ */
+import { type SQLInputValue } from "node:sqlite";
+export type SqlValue = SQLInputValue;
+export type Row = Readonly<Record<string, SqlValue>>;
+/** Prepared statements are cached per SQL text; the store's statements are a closed set. */
+export declare class Database {
+    #private;
+    constructor(path: string);
+    /** Several statements, no parameters (DDL). */
+    exec(sql: string): void;
+    /** Rows changed. */
+    run(sql: string, ...params: readonly SqlValue[]): number;
+    /** The rowid of the row an INSERT made. */
+    insert(sql: string, ...params: readonly SqlValue[]): number;
+    get(sql: string, ...params: readonly SqlValue[]): Row | undefined;
+    all(sql: string, ...params: readonly SqlValue[]): Row[];
+    /** The column names of `table` (`PRAGMA table_info`). */
+    columns(table: string): Set<string>;
+    /** Idempotent. */
+    close(): void;
+    private statement;
+}
+/** Typed reads of a column; a value of another type is a corrupt row, not a case to handle. */
+export declare const col: {
+    str: (row: Row, name: string) => string;
+    strOrNull: (row: Row, name: string) => string | null;
+    num: (row: Row, name: string) => number;
+    numOrNull: (row: Row, name: string) => number | null;
+    /** Python's truthiness of the value. */
+    bool(row: Row, name: string): boolean;
+    bytes(row: Row, name: string): Uint8Array;
+};
+/** SQLite's integer for a flag. */
+export declare const flag: (value: boolean) => number;

package/dist/types/sqlite/feedback-repository.d.ts

@@ -0,0 +1,27 @@
+/** FeedbackRepository on SQLite (tables `feedback_reports`, `feedback_asks`, `feedback_offers`, `feedback_prompts`). */
+import { type FeedbackOffer, type FeedbackOfferState, type FeedbackPrompt, type FeedbackReport, type FeedbackRepository, type IssueRef, type NewFeedbackReport } from "@primusclaw/personal-agent";
+import { type StoreContext } from "./context.js";
+import { type Database } from "./database.js";
+/** Delivered reports past FEEDBACK_KEEP_SECONDS go (undelivered ones are never dropped). */
+export declare function pruneFiledReports(db: Database, now: number): void;
+export declare class SqliteFeedbackRepository implements FeedbackRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    addFeedbackReport(r: NewFeedbackReport): number;
+    getFeedbackReport(reportId: number): FeedbackReport | null;
+    feedbackTarget(r: FeedbackReport): IssueRef | null;
+    markFeedbackFiled(reportId: number, issue: IssueRef, asComment: boolean): void;
+    markFeedbackFailed(reportId: number, error: string, retryAt: number): void;
+    dueFeedback(limit: number): FeedbackReport[];
+    pendingFeedbackCount(): number;
+    openFeedbackAsk(userId: string, scope: string): void;
+    takeFeedbackAsk(userId: string, scope: string): boolean;
+    hasFeedbackAsk(userId: string, scope: string): boolean;
+    addFeedbackOffer(userId: string, issueNumber: number, sessionId: string, turnId: string): string;
+    getFeedbackOffer(offerId: string): FeedbackOffer | null;
+    moveFeedbackOffer(offerId: string, state: FeedbackOfferState, options?: {
+        readonly onlyFrom?: FeedbackOfferState | null;
+    }): boolean;
+    addFeedbackPrompt(userId: string, scope: string): string;
+    getFeedbackPrompt(promptId: string): FeedbackPrompt | null;
+}

package/dist/types/sqlite/forget.d.ts

@@ -0,0 +1,6 @@
+/** Deletions that more than one repository performs (a re-link, an unlink): one definition each. */
+import type { Database } from "./database.js";
+/** The person's notification subscription and its attempt record. */
+export declare function forgetNotifySub(db: Database, userId: string): void;
+/** Everything /repo and /sessions remember about the person. */
+export declare function forgetRepos(db: Database, userId: string): void;

package/dist/types/sqlite/github-repository.d.ts

@@ -0,0 +1,36 @@
+/** GitHub review delegation on SQLite (tables `github_confirmations`, `acting_sessions`, `review_notices`,
+ * `asker_follows`, `github_notices`). */
+import { type AskerFollow, type ConfirmationState, type GithubConfirmation, type GithubConfirmationRepository, type JsonObject, type NewGithubConfirmation, type ReviewDelegationRepository, type ReviewNotice } from "@primusclaw/personal-agent";
+import type { StoreContext } from "./context.js";
+export declare class SqliteGithubConfirmationRepository implements GithubConfirmationRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    addGithubConfirmation(c: NewGithubConfirmation): boolean;
+    getGithubConfirmation(confirmationId: string): GithubConfirmation | null;
+    pendingGithubConfirmations(actorId: string): GithubConfirmation[];
+    moveGithubConfirmation(confirmationId: string, state: ConfirmationState, options?: {
+        readonly onlyFrom?: ConfirmationState;
+    }): boolean;
+    forgetGithubConfirmation(confirmationId: string): void;
+}
+export declare class SqliteReviewDelegationRepository implements ReviewDelegationRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    noteActingSession(sessionId: string, requesterId: string, actorId: string): void;
+    isActingSession(sessionId: string): boolean;
+    noteReviewNotice(n: ReviewNotice): void;
+    reviewNotices(): ReviewNotice[];
+    addAskerFollow(f: {
+        readonly itemId: string;
+        readonly batchId: string;
+        readonly review: JsonObject;
+        readonly reference: JsonObject;
+        readonly deadline: number;
+    }): void;
+    askerFollows(): AskerFollow[];
+    askerFollowSaid(itemId: string, said: string): void;
+    askerFollowReviewerTold(itemId: string): void;
+    dropAskerFollow(itemId: string): void;
+    claimGithubNotice(userId: string, kind: string, interval: number): boolean;
+    releaseGithubNotice(userId: string, kind: string): void;
+}

package/dist/types/sqlite/idempotency-repository.d.ts

@@ -0,0 +1,14 @@
+/** IdempotencyRepository on SQLite (tables `processed`, `event_claims`). A claim is one statement on the store, so of
+ * any number of copies, in this process or another on the same file, one is sent. */
+import { type EventClaim, type IdempotencyRepository } from "@primusclaw/personal-agent";
+import { type StoreContext } from "./context.js";
+export declare class SqliteIdempotencyRepository implements IdempotencyRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    claimProcessed(activityId: string): boolean;
+    claimEvent(key: string): EventClaim;
+    finishEvent(key: string): void;
+    releaseEvent(key: string, holder: string): void;
+    seen(activityId: string): boolean;
+    markProcessed(activityId: string): void;
+}

package/dist/types/sqlite/link-repository.d.ts

@@ -0,0 +1,27 @@
+/** LinkRepository on SQLite (tables `links`, `pending_keys`, `link_attempts`). */
+import { type LinkLimits, type LinkRepository, type RedeemOutcome } from "@primusclaw/personal-agent";
+import { type StoreContext, type SecurityEventSink } from "./context.js";
+export declare class SqliteLinkRepository implements LinkRepository {
+    private readonly ctx;
+    private readonly limits;
+    private readonly securityEvent;
+    constructor(ctx: StoreContext, limits: LinkLimits, securityEvent: SecurityEventSink);
+    get linkWindowSeconds(): number;
+    stashPending(key: string): string;
+    redeemPending(userId: string, name: string, code: string, activityId?: string): RedeemOutcome;
+    /** The check, the spend and the count, as one step: two requests racing for one code bind it once. */
+    private judge;
+    private spend;
+    /** A re-link may be another Claw account: its subscription, sessions and repositories must be its own. The wrong
+     * codes stay counted until the window ends, or minting a code after every few guesses would make the limit none. */
+    private bind;
+    takeExpiredPending(): string[];
+    getKey(userId: string): string | null;
+    unlink(userId: string): void;
+    setClawUserId(userId: string, clawUserId: string): void;
+    needsClawUserId(userId: string): boolean;
+    clawUserIdOf(userId: string): string | null;
+    linkedUsers(): string[];
+    userForClawUser(clawUserId: string): string | null;
+    usersForClawUser(clawUserId: string): string[];
+}

package/dist/types/sqlite/member-repository.d.ts

@@ -0,0 +1,15 @@
+/** MemberDirectoryRepository on SQLite (tables `teams_users`, `personal_clicks`). */
+import type { KnownMember, MemberDirectoryRepository, MemberListEntry } from "@primusclaw/personal-agent";
+import type { StoreContext } from "./context.js";
+export declare class SqliteMemberDirectoryRepository implements MemberDirectoryRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    rememberMember(channelUserId: string, userId: string, name: string, email?: string): void;
+    rememberMemberEmails(members: readonly MemberListEntry[]): void;
+    knownMembers(limit?: number): KnownMember[];
+    userForChannelId(channelUserId: string): string | null;
+    channelIdOf(userId: string): string | null;
+    memberName(userId: string): string | null;
+    notePersonalClick(userId: string): void;
+    clickedPersonally(userId: string): boolean;
+}

package/dist/types/sqlite/migrations.d.ts

@@ -0,0 +1,12 @@
+import type { Database } from "./database.js";
+/** The DDL, as Python's `_SCHEMA`. */
+export declare const SCHEMA_SQL: string;
+/** table -> [column, declaration], in the order the Python worker adds them. */
+export declare const ADDED_COLUMNS: readonly (readonly [string, readonly (readonly [string, string])[]])[];
+/**
+ * The sessions table used to be keyed by the person alone. It is now keyed by (person, scope): scope '' is the 1:1
+ * chat. Existing rows become the 1:1 session; plugin_id '' means created without one.
+ */
+export declare function migrateSessions(db: Database): void;
+/** The whole start-up migration; idempotent. */
+export declare function migrate(db: Database): void;

package/dist/types/sqlite/notify-repository.d.ts

@@ -0,0 +1,17 @@
+/** NotifySubscriptionRepository on SQLite (tables `notify_subs`, `notify_sub_attempts`). */
+import type { NotifyRoute, NotifySubscription, NotifySubscriptionRepository } from "@primusclaw/personal-agent";
+import type { StoreContext } from "./context.js";
+export declare class SqliteNotifySubscriptionRepository implements NotifySubscriptionRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    saveNotifySub(userId: string, sub: NotifySubscription & {
+        readonly secret: string;
+        readonly typesVersion?: number;
+    }): void;
+    notifyTypesVersion(userId: string): number | null;
+    setNotifyTypesVersion(userId: string, typesVersion: number): void;
+    getNotifySub(userId: string): NotifySubscription | null;
+    notifySubByRoute(route: string): NotifyRoute | null;
+    forgetNotifySub(userId: string): void;
+    claimNotifyAttempt(userId: string, minInterval: number): boolean;
+}

package/dist/types/sqlite/observe-repository.d.ts

@@ -0,0 +1,19 @@
+/** ObserveRepository on SQLite (tables `observed_groups`, `observe_cards`). */
+import { type GroupObserver, type JsonObject, type NewObserveCard, type ObserveCard, type ObserveCardState, type ObserveRepository, type ObservedGroup } from "@primusclaw/personal-agent";
+import { type StoreContext } from "./context.js";
+export declare class SqliteObserveRepository implements ObserveRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    observeGroup(conversationId: string, observer: GroupObserver & {
+        readonly reference: JsonObject;
+        readonly name?: string;
+    }): void;
+    unobserveGroup(conversationId: string): string | null;
+    groupObserver(conversationId: string): GroupObserver | null;
+    observedBy(userId: string): ObservedGroup[];
+    observedReference(conversationId: string): JsonObject | null;
+    addObserveCard(card: NewObserveCard): string;
+    getObserveCard(cardId: string): ObserveCard | null;
+    observeSuggestionSettled(userId: string, runId: string, seq: number): boolean;
+    moveObserveCard(cardId: string, state: ObserveCardState, onlyFrom?: ObserveCardState): boolean;
+}

package/dist/types/sqlite/onboarding-repository.d.ts

@@ -0,0 +1,20 @@
+/** OnboardingRepository on SQLite (tables `onboarding_cards`, `onboarding_dms`, `pending_requests`). */
+import { type NewPendingRequest, type OnboardingCard, type OnboardingRepository, type PendingRequest } from "@primusclaw/personal-agent";
+import { type StoreContext } from "./context.js";
+import { type Database } from "./database.js";
+/** Requests of people who did not link in time go. */
+export declare function pruneExpiredRequests(db: Database, now: number): void;
+export declare class SqliteOnboardingRepository implements OnboardingRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    claimOnboardingCard(userId: string, scope: string, member: {
+        readonly channelUserId: string;
+        readonly name: string;
+    }): string | null;
+    releaseOnboardingCard(promptId: string): void;
+    getOnboardingCard(promptId: string): OnboardingCard | null;
+    claimOnboardingDm(userId: string): boolean;
+    releaseOnboardingDm(userId: string): void;
+    savePendingRequest(r: NewPendingRequest): void;
+    takePendingRequest(userId: string): PendingRequest | null;
+}

package/dist/types/sqlite/open.d.ts

@@ -0,0 +1,25 @@
+/**
+ * How the worker opens its store at start: the SQLite store on the configured file, with the security-event log wired
+ * in, and every stored secret moved to the first encryption key before anything is served (README, key rotation).
+ */
+import type { Clock, LinkLimits, Logger, Random } from "@primusclaw/personal-agent";
+import type { SecurityEventSink } from "./context.js";
+import { SqliteStore } from "./store.js";
+/** The settings the store is opened with; the configuration's own fields (TEAMS_DB_PATH, TEAMS_ENCRYPTION_KEYS, the
+ * TEAMS_LINK_* limits), so a worker's settings object is passed as it is. */
+export interface WorkerStoreSettings {
+    readonly dbPath: string;
+    readonly encryptionKeys: readonly string[];
+    readonly linkLimits: LinkLimits;
+}
+export interface WorkerStoreDeps {
+    /** The security-event log (`link_attempt`, `link_lockout`). */
+    readonly securityEvent: SecurityEventSink;
+    /** Where the re-encryption counts are logged. */
+    readonly logger: Logger;
+    /** Default: the system clock. */
+    readonly clock?: Clock;
+    /** Default: `node:crypto`. */
+    readonly random?: Random;
+}
+export declare function openWorkerStore(settings: WorkerStoreSettings, deps: WorkerStoreDeps): SqliteStore;

package/dist/types/sqlite/people-repository.d.ts

@@ -0,0 +1,33 @@
+/** Conversation references, preferences and held notices on SQLite (tables `conversation_refs`, `user_prefs`,
+ * `held_events`). */
+import { type ConversationRefRepository, type HeldEventRepository, type JsonObject, type Prefs, type PrefsRepository } from "@primusclaw/personal-agent";
+import type { StoreContext } from "./context.js";
+export declare class SqliteConversationRefRepository implements ConversationRefRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    saveReference(userId: string, reference: JsonObject): void;
+    getReference(userId: string): JsonObject | null;
+    lastInboundAt(userId: string): number | null;
+}
+export declare class SqlitePrefsRepository implements PrefsRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    getPrefs(userId: string): Prefs;
+    getTimezone(userId: string): string;
+    setTimezone(userId: string, timezone: string): void;
+    setQuiet(userId: string, window: readonly [string, string] | null): void;
+    setPausedUntil(userId: string, until: number | null): void;
+    setRemoteWindowPref(userId: string, window: string): void;
+    setBriefTrigger(userId: string, triggerId: string | null): void;
+    setLang(userId: string, lang: string, said?: boolean): void;
+    learnLang(userId: string, lang: string): void;
+    /** Upsert one preference; the others keep their value (or their default for a new row). */
+    private setPref;
+}
+export declare class SqliteHeldEventRepository implements HeldEventRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    holdEvent(userId: string, event: JsonObject): void;
+    usersWithHeld(): string[];
+    takeHeld(userId: string): JsonObject[];
+}

package/dist/types/sqlite/py-json.d.ts

@@ -0,0 +1,16 @@
+/**
+ * JSON text as Python's `json.dumps` writes it by default (`", "` and `": "` separators, non-ASCII as `\uXXXX`), so a
+ * `*_json` column holds the same text whichever worker wrote it. Reading back is plain `JSON.parse`.
+ */
+import { type JsonObject } from "@primusclaw/personal-agent";
+export declare function pyJsonDumps(value: unknown): string;
+/** The parsed value, or `undefined` when the text is not JSON (Python's `ValueError`). */
+export declare function parseJson(text: string | null): unknown;
+/** A stored list; anything else reads as an empty one (Python's `_json_list`). */
+export declare function jsonList(text: string | null): unknown[];
+/** A stored list of strings, other entries dropped. */
+export declare function jsonStrings(text: string | null): string[];
+/** The stored mode id -> flag map; anything that is not one reads as nothing said (Python's `_json_flags`). */
+export declare function jsonFlags(text: string | null): Record<string, boolean>;
+/** A stored object, or null when the text is not one. */
+export declare function storedObject(text: string | null): JsonObject | null;

package/dist/types/sqlite/reencrypt.d.ts

@@ -0,0 +1,13 @@
+import type { StoreContext } from "./context.js";
+/** Every column that holds a Fernet token, as (table, key column, encrypted column). A new one must be listed here, or
+ * it is never moved to a new key and is lost when the old key goes. */
+export declare const ENCRYPTED_COLUMNS: readonly (readonly [string, string, string])[];
+export interface ReencryptCounts {
+    /** Re-encrypted now. */
+    rotated: number;
+    /** Already under the first key. */
+    current: number;
+    /** Under none of the configured keys; left as they are. */
+    undecryptable: number;
+}
+export declare function reencrypt(ctx: StoreContext): ReencryptCounts;

package/dist/types/sqlite/remote-repository.d.ts

@@ -0,0 +1,24 @@
+/** Remote session names and permission cards on SQLite (tables `remote_session_names`, `remote_permissions`). */
+import { type NewRemotePermission, type RemotePermission, type RemotePermissionRepository, type RemotePermissionState, type RemoteSessionName, type RemoteSessionNameRepository } from "@primusclaw/personal-agent";
+import type { StoreContext } from "./context.js";
+export declare class SqliteRemoteSessionNameRepository implements RemoteSessionNameRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    nameRemoteSession(userId: string, sessionId: string, name?: Partial<RemoteSessionName>): void;
+    titleRemoteSession(sessionId: string, title: string): void;
+    setRemoteSessionAcp(sessionId: string, acpSessionId: string): void;
+    remoteSessionAcps(userId: string): Map<string, string>;
+    remoteSessionNames(userId: string): Map<string, RemoteSessionName>;
+}
+export declare class SqliteRemotePermissionRepository implements RemotePermissionRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    saveRemotePermission(p: NewRemotePermission): boolean;
+    getRemotePermission(sessionId: string, actionId: string): RemotePermission | null;
+    pendingRemotePermissions(userId: string, sessionId: string): RemotePermission[];
+    waitingRemoteSessions(userId: string): Set<string>;
+    forgetRemotePermission(sessionId: string, actionId: string): void;
+    closeRemotePermission(sessionId: string, actionId: string, state: RemotePermissionState, options?: {
+        readonly onlyIfPending?: boolean;
+    }): boolean;
+}

package/dist/types/sqlite/remote-state-repository.d.ts

@@ -0,0 +1,20 @@
+/** Where a chat is attached on a remote agent, on SQLite (table `remote_state`). The key is the person's id for a 1:1
+ * chat, or `<userId>#<conversation>` for a group chat bound to a session. */
+import { type RemoteAttachment, type RemoteModes, type RemoteState, type RemoteStateRepository } from "@primusclaw/personal-agent";
+import type { StoreContext } from "./context.js";
+export declare class SqliteRemoteStateRepository implements RemoteStateRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    getRemote(chatKey: string): RemoteState | null;
+    remoteAttachedUsers(): string[];
+    attachedRemote(chatKey: string): RemoteState | null;
+    attachRemote(chatKey: string, a: RemoteAttachment): void;
+    setRemoteWindow(chatKey: string, window: string): void;
+    noteWindowCard(chatKey: string, cardId: string, kept?: number): void;
+    detachRemote(chatKey: string): void;
+    setRemoteCursor(chatKey: string, sessionId: string, cursor: string): void;
+    setRemoteTurn(chatKey: string, sessionId: string, isOpen: boolean): void;
+    setRemoteModes(chatKey: string, sessionId: string, modes: RemoteModes): void;
+    setRemoteStatusCard(chatKey: string, cardId: string): void;
+    setRemoteListing(chatKey: string, sessionIds: readonly string[]): void;
+}

package/dist/types/sqlite/session-repository.d.ts

@@ -0,0 +1,31 @@
+/** Which session a chat uses, and what /repo and /sessions remember, on SQLite (tables `sessions`, `recent_repos`,
+ * `pending_repo`, `session_history`). Order is by a per-person counter, not the clock, so two picks in one second keep
+ * their order. */
+import { type ChatSession, type HistorySession, type NotedSession, type RepoChoice, type RepoHistoryRepository, type SessionRepository } from "@primusclaw/personal-agent";
+import type { StoreContext } from "./context.js";
+export declare class SqliteSessionRepository implements SessionRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    getSession(userId: string, scope?: string): string | null;
+    getSessionPlugin(userId: string, scope?: string): string;
+    getSessionModel(userId: string, scope?: string): string;
+    getSessionShared(userId: string, scope?: string): boolean;
+    setSession(userId: string, session: Partial<ChatSession> & {
+        readonly sessionId: string;
+    }, scope?: string): void;
+    clearSession(userId: string, scope?: string): void;
+}
+export declare class SqliteRepoHistoryRepository implements RepoHistoryRepository {
+    private readonly ctx;
+    constructor(ctx: StoreContext);
+    touchRecentRepo(userId: string, choice: RepoChoice): void;
+    recentRepos(userId: string): RepoChoice[];
+    setPendingRepo(userId: string, choice: RepoChoice): void;
+    getPendingRepo(userId: string): RepoChoice | null;
+    clearPendingRepo(userId: string): void;
+    noteSession(userId: string, sessionId: string, seen?: NotedSession): void;
+    sessionHistory(userId: string, limit?: number): HistorySession[];
+    forgetSession(userId: string, sessionId: string): void;
+    forgetRepos(userId: string): void;
+    private nextSeq;
+}

package/dist/types/sqlite/store.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The StorePort on one SQLite file (`/data/state.db`), table for table and column for column the Python worker's, so
+ * either worker opens what the other wrote. Single process by design: the deployment runs one replica (Recreate).
+ */
+import { type Clock, type LinkLimits, type Random, type StorePort } from "@primusclaw/personal-agent";
+import { SqliteApprovalRepository } from "./approval-repository.js";
+import { SqliteAssistantButtonRepository, SqliteAssistantCardRepository, SqliteAssistantMessageRepository } from "./assistant-repository.js";
+import { type SecurityEventSink } from "./context.js";
+import { SqliteFeedbackRepository } from "./feedback-repository.js";
+import { SqliteGithubConfirmationRepository, SqliteReviewDelegationRepository } from "./github-repository.js";
+import { SqliteIdempotencyRepository } from "./idempotency-repository.js";
+import { SqliteLinkRepository } from "./link-repository.js";
+import { SqliteMemberDirectoryRepository } from "./member-repository.js";
+import { SqliteNotifySubscriptionRepository } from "./notify-repository.js";
+import { SqliteObserveRepository } from "./observe-repository.js";
+import { SqliteOnboardingRepository } from "./onboarding-repository.js";
+import { SqliteConversationRefRepository, SqliteHeldEventRepository, SqlitePrefsRepository } from "./people-repository.js";
+import { type ReencryptCounts } from "./reencrypt.js";
+import { SqliteRemotePermissionRepository, SqliteRemoteSessionNameRepository } from "./remote-repository.js";
+import { SqliteRemoteStateRepository } from "./remote-state-repository.js";
+import { SqliteRepoHistoryRepository, SqliteSessionRepository } from "./session-repository.js";
+import { SqliteTurnAnswerRepository } from "./turn-repository.js";
+export declare const DEFAULT_LINK_LIMITS: LinkLimits;
+export interface SqliteStoreOptions {
+    /** The database file (`TEAMS_DB_PATH`), or ":memory:". */
+    readonly path: string;
+    /** TEAMS_ENCRYPTION_KEYS: the first encrypts, all decrypt. At least one. */
+    readonly encryptionKeys: readonly string[];
+    readonly clock?: Clock;
+    readonly random?: Random;
+    readonly linkLimits?: LinkLimits;
+    /**
+     * Where `link_attempt` / `link_lockout` go: the security-event log, which filters the fields it logs. Required, so a
+     * worker cannot be assembled that links people without an audit trail (the Python store always logs them).
+     */
+    readonly securityEvent: SecurityEventSink;
+}
+export declare class SqliteStore implements StorePort {
+    #private;
+    readonly links: SqliteLinkRepository;
+    readonly references: SqliteConversationRefRepository;
+    readonly prefs: SqlitePrefsRepository;
+    readonly held: SqliteHeldEventRepository;
+    readonly members: SqliteMemberDirectoryRepository;
+    readonly notifySubs: SqliteNotifySubscriptionRepository;
+    readonly approvals: SqliteApprovalRepository;
+    readonly observe: SqliteObserveRepository;
+    readonly assistantCards: SqliteAssistantCardRepository;
+    readonly assistantButtons: SqliteAssistantButtonRepository;
+    readonly assistantMessages: SqliteAssistantMessageRepository;
+    readonly remoteState: SqliteRemoteStateRepository;
+    readonly remoteSessionNames: SqliteRemoteSessionNameRepository;
+    readonly remotePermissions: SqliteRemotePermissionRepository;
+    readonly sessions: SqliteSessionRepository;
+    readonly repoHistory: SqliteRepoHistoryRepository;
+    readonly turns: SqliteTurnAnswerRepository;
+    readonly feedback: SqliteFeedbackRepository;
+    readonly onboarding: SqliteOnboardingRepository;
+    readonly githubConfirmations: SqliteGithubConfirmationRepository;
+    readonly reviewDelegation: SqliteReviewDelegationRepository;
+    readonly idempotency: SqliteIdempotencyRepository;
+    constructor(options: SqliteStoreOptions);
+    now(): number;
+    /** Move every stored secret to the first key (run at start, before serving). */
+    reencrypt(): ReencryptCounts;
+    close(): void;
+}

package/dist/types/sqlite/turn-repository.d.ts

@@ -0,0 +1,24 @@
+/** Chat turns that answered in the chat, on SQLite (tables `turn_answers`, `answered_messages`). A turn row carries the
+ * id of the process that started it: a turn of another process died with it. */
+import { type AnsweredInChat, type TurnAnswerRepository, type FinishedRun } from "@primusclaw/personal-agent";
+import type { StoreContext } from "./context.js";
+export declare class SqliteTurnAnswerRepository implements TurnAnswerRepository {
+    private readonly ctx;
+    private readonly bootId;
+    /** @param bootId this process's id (Python's `secrets.token_hex(8)` at start). */
+    constructor(ctx: StoreContext, bootId: string);
+    turnStarted(sessionId: string, turn?: {
+        readonly prompt?: string;
+        readonly messageId?: string;
+        readonly turnId?: string;
+    }): void;
+    turnDelivered(sessionId: string, turn?: {
+        readonly messageId?: string;
+        readonly turnId?: string;
+    }): void;
+    turnNotDelivered(sessionId: string, turnId?: string): void;
+    answeredInChat(sessionId: string, run: FinishedRun): AnsweredInChat | null;
+    /** The two message ids decide when both are known; else the clock does (see the port's description). */
+    private judge;
+    turnPrompt(sessionId: string, finishedAt: number): string;
+}

package/dist/types/system-clock.d.ts

@@ -0,0 +1,3 @@
+import type { Clock } from "@primusclaw/personal-agent";
+/** The process's clocks: `Date.now()` for the wall clock, `performance.now()` for durations. */
+export declare const systemClock: Clock;