@askthew/mcp-plugin 0.4.0 → 0.4.2

package/dist/lib/free-install-registration.js

@@ -0,0 +1,52 @@
+import crypto from "node:crypto";
+import { markLocalIdentityRegistered, } from "./local-identity.js";
+function baseUrl(apiUrl) {
+    return (apiUrl?.trim() || process.env.ASKTHEW_API_URL?.trim() || "https://app.askthew.com").replace(/\/$/, "");
+}
+function hashClaimCode(code) {
+    return crypto.createHash("sha256").update(code.trim()).digest("hex");
+}
+function safeMessage(error) {
+    return error instanceof Error ? error.message : "Registration failed.";
+}
+export async function registerFreeInstall(input) {
+    const fetcher = input.options?.fetchImpl ?? fetch;
+    const response = await fetcher(`${baseUrl(input.options?.apiUrl ?? input.identity.apiUrl)}/api/cli/v1/free-installs/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            installId: input.identity.installId,
+            publicKey: input.identity.publicKey,
+            claimCodeHash: hashClaimCode(input.identity.claimCode),
+            emailClaim: input.identity.emailClaim,
+            deviceLabel: input.deviceLabel,
+            repo: input.repo ?? {},
+        }),
+    });
+    const payload = await response.json().catch(() => null);
+    if (!response.ok) {
+        throw new Error(payload?.error ? String(payload.error) : "Free install registration failed.");
+    }
+    const registeredAt = payload && typeof payload === "object" && typeof payload.registeredAt === "string"
+        ? payload.registeredAt
+        : new Date().toISOString();
+    markLocalIdentityRegistered({ registeredAt });
+    return { ok: true, registeredAt };
+}
+export async function tryRegisterFreeInstall(input) {
+    try {
+        return await registerFreeInstall(input);
+    }
+    catch (error) {
+        markLocalIdentityRegistered({ registrationError: safeMessage(error) });
+        return { ok: false, error: safeMessage(error) };
+    }
+}
+export function describeFreeIdentity(identity) {
+    return [
+        `Install ID: ${identity.installId}`,
+        identity.emailClaim ? `Email claim: ${identity.emailClaim} (unverified)` : "Email claim: none",
+        `Claim code: ${identity.claimCode}`,
+        identity.registeredAt ? `Registered: ${identity.registeredAt}` : "Registered: pending",
+    ].join("\n");
+}

package/dist/lib/free-tier-policy.d.ts

@@ -1,4 +1,5 @@
-export type McpMode = "paid" | "free" | "unauthenticated";
+import { type LocalInstallIdentity } from "./local-identity.js";
+export type McpMode = "paid" | "free" | "free_pending_auth" | "unauthenticated";
 export interface CliCredentials {
     email?: string;
     userId: string;
@@ -7,6 +8,9 @@ export interface CliCredentials {
     apiUrl?: string;
     telemetryOptOut?: boolean;
     accountStatus?: "new_dormant" | "existing_active";
+    identityKind?: "legacy_token" | "local_install";
+    installId?: string;
+    localIdentity?: LocalInstallIdentity;
 }
 export interface ModeResolution {
     mode: McpMode;

package/dist/lib/free-tier-policy.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import { credentialsPath, readJsonFile } from "./paths.js";
+import { loadLocalIdentity } from "./local-identity.js";
 function clean(value) {
     return String(value ?? "").trim().replace(/^['"]/, "").replace(/['"]$/, "");
 }
@@ -14,6 +15,20 @@ export function loadCliCredentials(env = process.env) {
             telemetryOptOut: env.ASKTHEW_TELEMETRY === "off",
         };
     }
+    const localIdentity = loadLocalIdentity(env);
+    if (localIdentity) {
+        return {
+            email: localIdentity.emailClaim,
+            userId: localIdentity.installId,
+            cliToken: localIdentity.installId,
+            cliTokenId: localIdentity.installId,
+            apiUrl: localIdentity.apiUrl,
+            telemetryOptOut: localIdentity.telemetryOptOut,
+            identityKind: "local_install",
+            installId: localIdentity.installId,
+            localIdentity,
+        };
+    }
     const creds = readJsonFile(credentialsPath(env));
     if (!creds?.cliToken || !creds.userId || !creds.cliTokenId) {
         return null;
@@ -39,7 +54,7 @@ export function resolveMcpMode(env = process.env) {
     }
     if (clean(env.ASKTHEW_FREE_MODE) === "1" || clean(env.ASKTHEW_FREE_MODE).toLowerCase() === "true") {
         return {
-            mode: "unauthenticated",
+            mode: "free_pending_auth",
             reason: fs.existsSync(credentialsPath(env)) ? "invalid_cli_credentials" : "free_mode_no_credentials",
         };
     }

package/dist/lib/local-identity.d.ts

@@ -0,0 +1,44 @@
+export interface LocalInstallIdentity {
+    installId: string;
+    privateKey: string;
+    publicKey: string;
+    claimCode: string;
+    emailClaim?: string;
+    createdAt: string;
+    registeredAt?: string;
+    registrationError?: string;
+    apiUrl?: string;
+    telemetryOptOut?: boolean;
+}
+export interface PublicInstallIdentity {
+    installId: string;
+    publicKey: string;
+    claimCode: string;
+    emailClaim?: string;
+    createdAt: string;
+    registeredAt?: string;
+    registrationError?: string;
+    apiUrl?: string;
+    telemetryOptOut?: boolean;
+}
+export declare function loadLocalIdentity(env?: NodeJS.ProcessEnv): LocalInstallIdentity | null;
+export declare function publicIdentity(identity: LocalInstallIdentity): PublicInstallIdentity;
+export declare function ensureLocalIdentity(input?: {
+    emailClaim?: string | null;
+    apiUrl?: string;
+    telemetryOptOut?: boolean;
+    env?: NodeJS.ProcessEnv;
+}): LocalInstallIdentity;
+export declare function markLocalIdentityRegistered(input: {
+    registeredAt?: string;
+    registrationError?: string;
+    env?: NodeJS.ProcessEnv;
+}): LocalInstallIdentity | null;
+export declare function signLocalIdentityPayload(input: {
+    identity: LocalInstallIdentity;
+    body: string;
+    timestamp?: string;
+}): {
+    timestamp: string;
+    signature: string;
+};

package/dist/lib/local-identity.js

@@ -0,0 +1,81 @@
+import crypto from "node:crypto";
+import { identityPath, readJsonFile, writePrivateJson } from "./paths.js";
+function normalizeEmail(email) {
+    const value = String(email ?? "").trim().toLowerCase();
+    return /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(value) ? value : undefined;
+}
+function generateClaimCode() {
+    return crypto.randomBytes(6).toString("base64url").toUpperCase();
+}
+export function loadLocalIdentity(env = process.env) {
+    const identity = readJsonFile(identityPath(env));
+    if (!identity?.installId || !identity.privateKey || !identity.publicKey || !identity.claimCode) {
+        return null;
+    }
+    return identity;
+}
+export function publicIdentity(identity) {
+    return {
+        installId: identity.installId,
+        publicKey: identity.publicKey,
+        claimCode: identity.claimCode,
+        emailClaim: identity.emailClaim,
+        createdAt: identity.createdAt,
+        registeredAt: identity.registeredAt,
+        registrationError: identity.registrationError,
+        apiUrl: identity.apiUrl,
+        telemetryOptOut: identity.telemetryOptOut,
+    };
+}
+export function ensureLocalIdentity(input = {}) {
+    const env = input.env ?? process.env;
+    const existing = loadLocalIdentity(env);
+    const emailClaim = normalizeEmail(input.emailClaim);
+    if (existing) {
+        const next = {
+            ...existing,
+            ...(emailClaim ? { emailClaim } : {}),
+            ...(input.apiUrl ? { apiUrl: input.apiUrl } : {}),
+            ...(typeof input.telemetryOptOut === "boolean" ? { telemetryOptOut: input.telemetryOptOut } : {}),
+        };
+        writePrivateJson(identityPath(env), next);
+        return next;
+    }
+    const keyPair = crypto.generateKeyPairSync("ed25519", {
+        privateKeyEncoding: { type: "pkcs8", format: "pem" },
+        publicKeyEncoding: { type: "spki", format: "pem" },
+    });
+    const identity = {
+        installId: crypto.randomUUID(),
+        privateKey: keyPair.privateKey,
+        publicKey: keyPair.publicKey,
+        claimCode: generateClaimCode(),
+        ...(emailClaim ? { emailClaim } : {}),
+        ...(input.apiUrl ? { apiUrl: input.apiUrl } : {}),
+        ...(typeof input.telemetryOptOut === "boolean" ? { telemetryOptOut: input.telemetryOptOut } : {}),
+        createdAt: new Date().toISOString(),
+    };
+    writePrivateJson(identityPath(env), identity);
+    return identity;
+}
+export function markLocalIdentityRegistered(input) {
+    const env = input.env ?? process.env;
+    const identity = loadLocalIdentity(env);
+    if (!identity)
+        return null;
+    const next = {
+        ...identity,
+        registeredAt: input.registrationError ? identity.registeredAt : (input.registeredAt ?? new Date().toISOString()),
+        registrationError: input.registrationError,
+    };
+    writePrivateJson(identityPath(env), next);
+    return next;
+}
+export function signLocalIdentityPayload(input) {
+    const timestamp = input.timestamp ?? new Date().toISOString();
+    const signature = crypto.sign(null, Buffer.from(`${timestamp}.${input.body}`), input.identity.privateKey).toString("base64url");
+    return {
+        timestamp,
+        signature,
+    };
+}

package/dist/lib/local-store.d.ts

@@ -9,10 +9,20 @@ export interface LocalSignalInput {
     filesTouched?: string[];
     commandsRun?: string[];
     metadata?: Record<string, unknown>;
+    scopeKey?: string | null;
 }
-export interface LocalSignal extends Required<LocalSignalInput> {
+export interface LocalSignal {
     id: number;
+    sessionId: string;
+    sequence: number;
+    kind: SignalKind;
+    summary: string;
+    evidence: unknown[];
+    filesTouched: string[];
+    commandsRun: string[];
+    metadata: Record<string, unknown>;
     capturedAt: string;
+    scopeKey?: string | null;
 }
 export interface LocalDecision {
     id: string;
@@ -27,6 +37,11 @@ export interface LocalDecision {
     createdAt: string;
     updatedAt: string;
     uploadedAt: string | null;
+    scopeKey?: string | null;
+    proposedAt?: string | null;
+    committedAt?: string | null;
+    shippedAt?: string | null;
+    abandonedAt?: string | null;
 }
 export interface LocalDecisionInput {
     id?: string;
@@ -38,6 +53,7 @@ export interface LocalDecisionInput {
     files?: string[];
     sourceSignalIds?: number[];
     rawContent: string;
+    scopeKey?: string | null;
 }
 export interface TelemetryOutboxRow {
     id: number;
@@ -65,11 +81,16 @@ export declare class LocalStore {
     insertSignal(input: LocalSignalInput): LocalSignal;
     listSignals(input?: {
         sessionId?: string;
+        scopeKey?: string | null;
+        since?: string;
         limit?: number;
+        cursor?: string;
         uploaded?: boolean;
     }): LocalSignal[];
     getSignal(id: number): LocalSignal | null;
-    mostRecentSessionId(): any;
+    mostRecentSessionId(input?: {
+        scopeKey?: string | null;
+    }): any;
     createDecision(input: LocalDecisionInput): LocalDecision;
     updateDecision(id: string, patch: Partial<Omit<LocalDecision, "id" | "createdAt">>): LocalDecision | null;
     deleteDecision(id: string): boolean;
@@ -78,8 +99,17 @@ export declare class LocalStore {
         status?: DecisionStatus;
         limit?: number;
         since?: string;
+        cursor?: string;
+        sessionId?: string;
+        scopeKey?: string | null;
         pendingUploadOnly?: boolean;
     }): LocalDecision[];
+    listSessionIds(input?: {
+        limit?: number;
+        scopeKey?: string | null;
+    }): string[];
+    listSignalsByIds(ids: number[]): LocalSignal[];
+    getDecisionForSignal(signalId: number): LocalDecision | null;
     enqueueTelemetry(payload: Record<string, unknown>): number;
     listTelemetryOutbox(input?: {
         undeliveredOnly?: boolean;
@@ -96,4 +126,5 @@ export declare class LocalStore {
     private openDatabase;
     private persistJson;
     private nextJsonId;
+    private addColumnIfMissing;
 }

package/dist/lib/local-store.js

@@ -55,6 +55,7 @@ export class LocalStore {
           files_json text not null default '[]',
           commands_json text not null default '[]',
           metadata_json text not null default '{}',
+          scope_key text,
           captured_at text not null,
           uploaded_at text,
           unique(session_id, sequence)
@@ -69,6 +70,11 @@ export class LocalStore {
           files_json text not null default '[]',
           source_signal_ids text not null default '[]',
           raw_content text not null,
+          scope_key text,
+          proposed_at text,
+          committed_at text,
+          shipped_at text,
+          abandoned_at text,
           created_at text not null,
           updated_at text not null,
           uploaded_at text
@@ -82,10 +88,16 @@ export class LocalStore {
           delivered_at text
         );
       `);
-            this.setMeta("schema_version", "1");
+            this.addColumnIfMissing("signals", "scope_key", "alter table signals add column scope_key text");
+            this.addColumnIfMissing("decisions", "scope_key", "alter table decisions add column scope_key text");
+            this.addColumnIfMissing("decisions", "proposed_at", "alter table decisions add column proposed_at text");
+            this.addColumnIfMissing("decisions", "committed_at", "alter table decisions add column committed_at text");
+            this.addColumnIfMissing("decisions", "shipped_at", "alter table decisions add column shipped_at text");
+            this.addColumnIfMissing("decisions", "abandoned_at", "alter table decisions add column abandoned_at text");
+            this.setMeta("schema_version", "2");
             return;
         }
-        this.data.meta.schema_version = "1";
+        this.data.meta.schema_version = "2";
         this.persistJson();
     }
     getMeta(key) {
@@ -115,9 +127,9 @@ export class LocalStore {
             }
             const result = this.db
                 .prepare(`insert into signals
-            (session_id, sequence, kind, summary, evidence_json, files_json, commands_json, metadata_json, captured_at)
-           values (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(input.sessionId, input.sequence, input.kind, input.summary, JSON.stringify(input.evidence ?? []), JSON.stringify(input.filesTouched ?? []), JSON.stringify(input.commandsRun ?? []), JSON.stringify(input.metadata ?? {}), now);
+            (session_id, sequence, kind, summary, evidence_json, files_json, commands_json, metadata_json, scope_key, captured_at)
+           values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.sessionId, input.sequence, input.kind, input.summary, JSON.stringify(input.evidence ?? []), JSON.stringify(input.filesTouched ?? []), JSON.stringify(input.commandsRun ?? []), JSON.stringify(input.metadata ?? {}), input.scopeKey ?? null, now);
             const id = Number(result.lastInsertRowid ?? 0);
             return this.getSignal(id);
         }
@@ -135,6 +147,7 @@ export class LocalStore {
             filesTouched: input.filesTouched ?? [],
             commandsRun: input.commandsRun ?? [],
             metadata: input.metadata ?? {},
+            scopeKey: input.scopeKey ?? null,
             capturedAt: now,
         };
         this.data.signals.push(signal);
@@ -144,14 +157,51 @@ export class LocalStore {
     listSignals(input = {}) {
         const limit = input.limit ?? 300;
         if (this.db) {
-            const where = input.sessionId ? "where session_id = ?" : "";
+            const clauses = [];
+            const params = [];
+            if (input.sessionId) {
+                clauses.push("session_id = ?");
+                params.push(input.sessionId);
+            }
+            if (input.scopeKey) {
+                clauses.push("scope_key = ?");
+                params.push(input.scopeKey);
+            }
+            if (input.since) {
+                clauses.push("captured_at >= ?");
+                params.push(input.since);
+            }
+            if (input.cursor) {
+                const cursorTime = new Date(input.cursor).getTime();
+                if (Number.isFinite(cursorTime)) {
+                    clauses.push("captured_at > ?");
+                    params.push(new Date(cursorTime).toISOString());
+                }
+                else if (/^\d+$/.test(input.cursor)) {
+                    clauses.push("id > ?");
+                    params.push(Number(input.cursor));
+                }
+            }
+            const where = clauses.length > 0 ? `where ${clauses.join(" and ")}` : "";
             const rows = this.db
                 .prepare(`select * from signals ${where} order by captured_at asc, id asc limit ?`)
-                .all(...(input.sessionId ? [input.sessionId, limit] : [limit]));
+                .all(...params, limit);
             return rows.map(rowToSignal);
         }
         return this.data.signals
             .filter((signal) => !input.sessionId || signal.sessionId === input.sessionId)
+            .filter((signal) => !input.scopeKey || signal.scopeKey === input.scopeKey)
+            .filter((signal) => !input.since || signal.capturedAt >= input.since)
+            .filter((signal) => {
+            if (!input.cursor)
+                return true;
+            const cursorTime = new Date(input.cursor).getTime();
+            if (Number.isFinite(cursorTime))
+                return signal.capturedAt > new Date(cursorTime).toISOString();
+            if (/^\d+$/.test(input.cursor))
+                return signal.id > Number(input.cursor);
+            return true;
+        })
             .sort((a, b) => a.capturedAt.localeCompare(b.capturedAt) || a.id - b.id)
             .slice(0, limit);
     }
@@ -162,16 +212,17 @@ export class LocalStore {
         }
         return this.data.signals.find((signal) => signal.id === id) ?? null;
     }
-    mostRecentSessionId() {
-        const signal = this.listSignals({ limit: 1 }).at(-1);
-        if (signal) {
-            return signal.sessionId;
-        }
+    mostRecentSessionId(input = {}) {
         if (this.db) {
-            const row = this.db.prepare("select session_id from signals order by captured_at desc, id desc limit 1").get();
+            const row = input.scopeKey
+                ? this.db.prepare("select session_id from signals where scope_key = ? order by captured_at desc, id desc limit 1").get(input.scopeKey)
+                : this.db.prepare("select session_id from signals order by captured_at desc, id desc limit 1").get();
             return typeof row?.session_id === "string" ? row.session_id : null;
         }
-        return this.data.signals.at(-1)?.sessionId ?? null;
+        return this.data.signals
+            .filter((signal) => !input.scopeKey || signal.scopeKey === input.scopeKey)
+            .sort((left, right) => left.capturedAt.localeCompare(right.capturedAt) || left.id - right.id)
+            .at(-1)?.sessionId ?? null;
     }
     createDecision(input) {
         const now = new Date().toISOString();
@@ -190,13 +241,18 @@ export class LocalStore {
             createdAt: now,
             updatedAt: now,
             uploadedAt: null,
+            scopeKey: input.scopeKey ?? null,
+            proposedAt: (input.status ?? "proposed") === "proposed" ? now : null,
+            committedAt: input.status === "committed" ? now : null,
+            shippedAt: input.status === "shipped" ? now : null,
+            abandonedAt: input.status === "abandoned" ? now : null,
         };
         if (this.db) {
             this.db
                 .prepare(`insert into decisions
-            (id, session_id, headline, why, status, alignment, files_json, source_signal_ids, raw_content, created_at, updated_at, uploaded_at)
-           values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(decision.id, decision.sessionId, decision.headline, decision.why, decision.status, decision.alignment, JSON.stringify(decision.files), JSON.stringify(decision.sourceSignalIds), decision.rawContent, decision.createdAt, decision.updatedAt, decision.uploadedAt);
+            (id, session_id, headline, why, status, alignment, files_json, source_signal_ids, raw_content, scope_key, proposed_at, committed_at, shipped_at, abandoned_at, created_at, updated_at, uploaded_at)
+           values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(decision.id, decision.sessionId, decision.headline, decision.why, decision.status, decision.alignment, JSON.stringify(decision.files), JSON.stringify(decision.sourceSignalIds), decision.rawContent, decision.scopeKey, decision.proposedAt, decision.committedAt, decision.shippedAt, decision.abandonedAt, decision.createdAt, decision.updatedAt, decision.uploadedAt);
             return decision;
         }
         this.data.decisions.push(decision);
@@ -213,11 +269,22 @@ export class LocalStore {
             ...patch,
             updatedAt: new Date().toISOString(),
         };
+        if (patch.status && patch.status !== existing.status) {
+            if (patch.status === "proposed" && !next.proposedAt)
+                next.proposedAt = next.updatedAt;
+            if (patch.status === "committed" && !next.committedAt)
+                next.committedAt = next.updatedAt;
+            if (patch.status === "shipped" && !next.shippedAt)
+                next.shippedAt = next.updatedAt;
+            if (patch.status === "abandoned" && !next.abandonedAt)
+                next.abandonedAt = next.updatedAt;
+        }
         if (this.db) {
             this.db
                 .prepare(`update decisions set headline = ?, why = ?, status = ?, alignment = ?, files_json = ?,
-           source_signal_ids = ?, raw_content = ?, updated_at = ?, uploaded_at = ? where id = ?`)
-                .run(next.headline, next.why, next.status, next.alignment, JSON.stringify(next.files), JSON.stringify(next.sourceSignalIds), next.rawContent, next.updatedAt, next.uploadedAt, id);
+           source_signal_ids = ?, raw_content = ?, scope_key = ?, proposed_at = ?, committed_at = ?,
+           shipped_at = ?, abandoned_at = ?, updated_at = ?, uploaded_at = ? where id = ?`)
+                .run(next.headline, next.why, next.status, next.alignment, JSON.stringify(next.files), JSON.stringify(next.sourceSignalIds), next.rawContent, next.scopeKey, next.proposedAt, next.committedAt, next.shippedAt, next.abandonedAt, next.updatedAt, next.uploadedAt, id);
             return next;
         }
         this.data.decisions = this.data.decisions.map((decision) => (decision.id === id ? next : decision));
@@ -245,6 +312,14 @@ export class LocalStore {
         if (this.db) {
             const clauses = [];
             const params = [];
+            if (input.sessionId) {
+                clauses.push("session_id = ?");
+                params.push(input.sessionId);
+            }
+            if (input.scopeKey) {
+                clauses.push("scope_key = ?");
+                params.push(input.scopeKey);
+            }
             if (input.status) {
                 clauses.push("status = ?");
                 params.push(input.status);
@@ -253,6 +328,17 @@ export class LocalStore {
                 clauses.push("created_at >= ?");
                 params.push(input.since);
             }
+            if (input.cursor) {
+                const cursorTime = new Date(input.cursor).getTime();
+                if (Number.isFinite(cursorTime)) {
+                    clauses.push("created_at < ?");
+                    params.push(new Date(cursorTime).toISOString());
+                }
+                else {
+                    clauses.push("id < ?");
+                    params.push(input.cursor);
+                }
+            }
             if (input.pendingUploadOnly) {
                 clauses.push("uploaded_at is null");
             }
@@ -263,12 +349,83 @@ export class LocalStore {
                 .map(rowToDecision);
         }
         return this.data.decisions
+            .filter((decision) => !input.sessionId || decision.sessionId === input.sessionId)
+            .filter((decision) => !input.scopeKey || decision.scopeKey === input.scopeKey)
             .filter((decision) => !input.status || decision.status === input.status)
             .filter((decision) => !input.since || decision.createdAt >= input.since)
+            .filter((decision) => {
+            if (!input.cursor)
+                return true;
+            const cursorTime = new Date(input.cursor).getTime();
+            if (Number.isFinite(cursorTime))
+                return decision.createdAt < new Date(cursorTime).toISOString();
+            return decision.id < input.cursor;
+        })
             .filter((decision) => !input.pendingUploadOnly || !decision.uploadedAt)
             .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
             .slice(0, limit);
     }
+    listSessionIds(input = {}) {
+        const limit = input.limit ?? 100000;
+        if (this.db) {
+            const rows = this.db
+                .prepare(`select session_id, max(captured_at) as last_seen_at
+           from signals
+           ${input.scopeKey ? "where scope_key = ?" : ""}
+           group by session_id
+           order by last_seen_at desc
+           limit ?`)
+                .all(...(input.scopeKey ? [input.scopeKey, limit] : [limit]));
+            return rows.map((row) => String(row.session_id));
+        }
+        const lastSeen = new Map();
+        for (const signal of this.data.signals) {
+            if (input.scopeKey && signal.scopeKey !== input.scopeKey) {
+                continue;
+            }
+            const current = lastSeen.get(signal.sessionId);
+            if (!current || signal.capturedAt > current) {
+                lastSeen.set(signal.sessionId, signal.capturedAt);
+            }
+        }
+        return Array.from(lastSeen.entries())
+            .sort((left, right) => right[1].localeCompare(left[1]))
+            .slice(0, limit)
+            .map(([sessionId]) => sessionId);
+    }
+    listSignalsByIds(ids) {
+        const uniqueIds = Array.from(new Set(ids.filter((id) => Number.isFinite(id))));
+        if (uniqueIds.length === 0) {
+            return [];
+        }
+        if (this.db) {
+            const placeholders = uniqueIds.map(() => "?").join(", ");
+            return this.db
+                .prepare(`select * from signals where id in (${placeholders}) order by captured_at asc, id asc`)
+                .all(...uniqueIds)
+                .map(rowToSignal);
+        }
+        const idSet = new Set(uniqueIds);
+        return this.data.signals
+            .filter((signal) => idSet.has(signal.id))
+            .sort((a, b) => a.capturedAt.localeCompare(b.capturedAt) || a.id - b.id);
+    }
+    getDecisionForSignal(signalId) {
+        if (this.db) {
+            const rows = this.db.prepare("select * from decisions order by created_at desc").all();
+            for (const row of rows) {
+                const decision = rowToDecision(row);
+                if (decision.sourceSignalIds.includes(signalId)) {
+                    return decision;
+                }
+            }
+            return null;
+        }
+        return (this.data.decisions
+            .slice()
+            .sort((left, right) => right.createdAt.localeCompare(left.createdAt))
+            .find((decision) => decision.sourceSignalIds.includes(signalId)) ?? null);
+    }
     enqueueTelemetry(payload) {
         const now = new Date().toISOString();
         if (this.db) {
@@ -356,6 +513,15 @@ export class LocalStore {
     nextJsonId(rows) {
         return rows.reduce((max, row) => Math.max(max, row.id), 0) + 1;
     }
+    addColumnIfMissing(table, column, statement) {
+        if (!this.db)
+            return;
+        const rows = this.db.prepare(`pragma table_info(${table})`).all();
+        if (rows.some((row) => row.name === column)) {
+            return;
+        }
+        this.db.exec(statement);
+    }
 }
 function tryRequireBetterSqlite3() {
     try {
@@ -389,6 +555,7 @@ function rowToSignal(row) {
         filesTouched: parseJson(row.files_json, []),
         commandsRun: parseJson(row.commands_json, []),
         metadata: parseJson(row.metadata_json, {}),
+        scopeKey: typeof row.scope_key === "string" ? row.scope_key : null,
         capturedAt: String(row.captured_at),
     };
 }
@@ -406,6 +573,11 @@ function rowToDecision(row) {
         createdAt: String(row.created_at),
         updatedAt: String(row.updated_at),
         uploadedAt: typeof row.uploaded_at === "string" ? row.uploaded_at : null,
+        scopeKey: typeof row.scope_key === "string" ? row.scope_key : null,
+        proposedAt: typeof row.proposed_at === "string" ? row.proposed_at : null,
+        committedAt: typeof row.committed_at === "string" ? row.committed_at : null,
+        shippedAt: typeof row.shipped_at === "string" ? row.shipped_at : null,
+        abandonedAt: typeof row.abandoned_at === "string" ? row.abandoned_at : null,
     };
 }
 function rowToTelemetry(row) {

package/dist/lib/paths.d.ts

@@ -2,6 +2,8 @@ export declare function askTheWDataDir(env?: NodeJS.ProcessEnv): string;
 export declare function ensureAskTheWDataDir(env?: NodeJS.ProcessEnv): string;
 export declare function localStorePath(env?: NodeJS.ProcessEnv): string;
 export declare function credentialsPath(env?: NodeJS.ProcessEnv): string;
+export declare function identityPath(env?: NodeJS.ProcessEnv): string;
+export declare function configPath(env?: NodeJS.ProcessEnv): string;
 export declare function jsonFallbackStorePath(env?: NodeJS.ProcessEnv): string;
 export declare function writePrivateJson(filePath: string, value: unknown): void;
 export declare function readJsonFile<T>(filePath: string): T | null;

package/dist/lib/paths.js

@@ -23,6 +23,12 @@ export function localStorePath(env = process.env) {
 export function credentialsPath(env = process.env) {
     return path.join(askTheWDataDir(env), "credentials.json");
 }
+export function identityPath(env = process.env) {
+    return path.join(askTheWDataDir(env), "identity.json");
+}
+export function configPath(env = process.env) {
+    return path.join(askTheWDataDir(env), "config.json");
+}
 export function jsonFallbackStorePath(env = process.env) {
     return path.join(askTheWDataDir(env), "store.json");
 }