@wenathlan/devthink 2.0.15 → 2.0.20

package/dist/serve.d.ts

@@ -1,136 +0,0 @@
-/**
- * The serve module of the 1.1.90 consolidation: every correlated variation of the mcp server surface interned in this one file, so the module family carries one surface without duplicate variations.
- * The correlation is the serve mode of the agent protocol: jsonrpc holds the wire framing layer (the message codec that encodes and decodes one frame or one ordered batch, the notification frames a server never answers, and the structured errors with their retry hints that ride the rpc error data so a client reads whether a failure retries, waits its retry after window or never retries); resourceexpose holds the served resource surface (the pagestate, plan, audit, session and health catalog with its read rendering, the resource subscriptions with their change notifications that reuse the watcher baselines of the agent stream family and the notification frames the changes ride); and promptexpose holds the served prompt surface (the walkthrough prompts of the common tasks, the user authored template library published as mcp prompts and the prompts/call rendering that substitutes the declared arguments through the template library).
- * No endpoint, transport, provider or built-in template body is ever hardcoded anywhere in the family: every route and prompt stays the user's choice, the audit resource carries summaries with no payload, and no served surface ever bypasses the consent gates.
- */
-import type { jsonrpcframe, rpcerror, rpcerrorcode, retryhint, structurederror, toolresult } from "./types.js";
-/**
- * Json rpc framing layer of the 1.1.84 mcp server mode.
- * Every wire message concern of the serve mode lives in this file: the message codec that encodes and decodes every message a transport carries — one frame or one batch array of frames — on top of the frame grammar the agent protocol family owns, the notification frames that omit the id so a server never answers them, the batch assembly and flattening that keeps the member order, the structured errors with their retry hints that ride the rpc error data so a client reads exactly whether a failure retries, waits its retry after window or never retries, and the error mapping that turns a structured error into the rpc error frame and back.
- * The layer stays pure: the transports feed it raw wire text and write the encoded answers back through their own seams, the retry hints derive from the structured error surface of the call runtime, and no transport, endpoint or provider is ever hardcoded.
- */
-/** One wire message of the serve mode: a single frame or an ordered batch of frames. */
-export type jsonrpcmessage = jsonrpcframe | jsonrpcframe[];
-/** Encodes one wire message — a frame or a batch — into its compact json rpc wire form. */
-export declare function encodemessage(message: jsonrpcmessage): string;
-/** Decodes one raw wire message: a bare frame parses as itself while an array parses as a batch whose members must all be frames; anything else refuses. */
-export declare function decodemessage(raw: string): {
-    message?: jsonrpcmessage;
-    error?: rpcerror;
-};
-/** Flattens one wire message into its ordered frames: a bare frame yields itself while a batch yields its members in order. */
-export declare function framesof(message: jsonrpcmessage): jsonrpcframe[];
-/** Assembles one batch message from its ordered frames; an empty list refuses because a batch carries at least one frame. */
-export declare function batchof(frames: jsonrpcframe[]): {
-    message?: jsonrpcmessage;
-    error?: rpcerror;
-};
-/** True when one frame is a notification: notifications omit the id and a server never answers them. */
-export declare function isnotification(frame: jsonrpcframe): boolean;
-/** Builds one notification frame: the method with its params and no id, so the transport writes it without waiting for an answer. */
-export declare function notificationframe(method: string, params?: Record<string, unknown>): jsonrpcframe;
-/** Wraps one structured error with its retry hint into the rpc error frame a transport answers with: the structured surface rides the error data so the client reads the code name, the message, the retry hint and the retry after window from one frame. A code outside the json rpc code names answers as internal while the structured data keeps the original code. */
-export declare function errorwithretry(input: {
-    code: rpcerrorcode | string;
-    message: string;
-    retryhint: retryhint;
-    retryafter?: number;
-}): rpcerror;
-/** Reads the structured error surface with its retry hint back out of one rpc error; an error without the structured data keeps its code name and never retries. */
-export declare function structuredof(error: rpcerror): structurederror;
-/** Builds the error response frame of one request id around the structured error with its retry hint. */
-export declare function errorresponse(input: {
-    id?: number | string | null;
-    code: rpcerrorcode | string;
-    message: string;
-    retryhint: retryhint;
-    retryafter?: number;
-}): jsonrpcframe;
-/** Builds the result response frame of one request id; a tool result keeps its structured payload intact so the client reads the same details the sidepanel steps read. */
-export declare function resultresponse(id: number | string | null | undefined, result: unknown): jsonrpcframe;
-/** Builds the tool result payload of one frame result: the content, the structured payload and the error flag ride the wire exactly as the sidepanel steps read them. */
-export declare function toolresultof(result: unknown): toolresult | undefined;
-import type { agentplan, agentsession, auditevent, resourcewatch, servedresource, servehealth } from "./types.js";
-/**
- * Resource exposure of the 1.1.84 mcp server mode.
- * Every served resource concern lives in this file: the resource catalog the serve mode publishes — the page state of the session tab, the approved plan, the audit trail, the session record and the health line with its version and uptime — the resources/read rendering of every resource into its wire text, the resource subscriptions a paired client opens with their change notifications that reuse the watcher baselines of the agent stream family so a subscriber reads exactly the keys that changed, and the notification frames the changes ride.
- * The exposure stays pure and consent-first: the page state resource carries no page content the user granted none of, the audit trail resource carries the summaries with no payload, and a subscription never widens what the session grants because the watcher stays a read only observation.
- */
-/** The resource uris the serve mode publishes, in the documented order of the resources/list report. */
-export declare const resourceuris: readonly ["devthink://pagestate", "devthink://plan", "devthink://audit", "devthink://session", "devthink://health"];
-/** The resource catalog the serve mode publishes: the page state of the session tab, the approved plan, the audit trail, the session record and the health line. */
-export declare function servedresources(): servedresource[];
-/** Resolves one served resource by its uri; an unknown uri returns undefined so the read reports it. */
-export declare function resourceof(uri: string): servedresource | undefined;
-/** Reads one served resource into its wire form: the page state carries the observed signals only, the plan its reviewed steps, the audit its summaries with no payload, the session its record and the health its line; an unknown uri refuses with its reason. */
-export declare function readresource(input: {
-    uri: string;
-    pagestate?: Record<string, unknown>;
-    plan?: agentplan;
-    audit?: auditevent[];
-    session?: agentsession;
-    health?: servehealth;
-}): {
-    resource?: servedresource;
-    text?: string;
-    reason?: string;
-};
-/** Opens one resource subscription for a paired client: the uri must name a served resource and the baseline freezes the resource state at subscription time so later change notifications deliver exactly the keys that changed. */
-export declare function subscriberesource(input: {
-    clientid: string;
-    uri: string;
-    state?: Record<string, unknown>;
-    now: number;
-    id?: string;
-}): {
-    watch?: resourcewatch;
-    reason?: string;
-};
-/** Publishes one resource change to its active subscribers: every watcher of the resource receives the delta of the changed keys against its baseline while the baseline absorbs the new state; the delivery stamps the last delivery time. */
-export declare function publishchange(input: {
-    watches: resourcewatch[];
-    uri: string;
-    state: Record<string, unknown>;
-    now: number;
-}): {
-    deliveries: Array<{
-        watchid: string;
-        clientid: string;
-        delta: Record<string, unknown>;
-        frame: jsonrpcframe;
-    }>;
-    watches: resourcewatch[];
-};
-/** Builds the resources/updated notification frame of one delivered change: the watcher id, the resource uri, the changed keys and the time. */
-export declare function resourcechangeframe(watchid: string, uri: string, delta: Record<string, unknown>, now: number): jsonrpcframe;
-/** Builds the resources/list result of the serve mode: every served resource with its uri, description and mimetype. */
-export declare function resourceslist(): {
-    resources: servedresource[];
-};
-import type { promptdef, prompttemplate } from "./types.js";
-/**
- * Prompt exposure of the 1.1.84 mcp server mode.
- * Every served prompt concern lives in this file: the prompt template library published as mcp prompts — every user saved template of the llm integration family becomes one prompt with its variables as declared arguments — the walkthrough prompts for the common tasks a client walks through (the first snapshot, the reviewed fill and the table extraction) with their ordered steps rendered in plain language, the combined prompts/list report of the library and the walkthroughs beside the protocol prompt tools, and the prompts/call rendering that substitutes the declared arguments through the template library so a client reads exactly the prompt the user authored.
- * The exposure stays pure: no built-in template body ever ships beyond the reviewed walkthrough steps, a sensitive library template keeps its consent notice requirement, and no prompt execution bypasses the consent gates.
- */
-/** The walkthrough prompts of the common tasks: the ordered steps a client walks through, rendered from the declared arguments. */
-export declare function walkthroughprompts(): promptdef[];
-/** Publishes one prompt template of the library as one mcp prompt: the template name becomes the prompt name, the description states the user authored body and the declared arguments carry the template variables with their required markers. */
-export declare function templateprompt(template: prompttemplate): promptdef;
-/** Lists every served prompt of the serve mode: the walkthrough prompts for the common tasks first, then the prompt template library the user authored, then the protocol prompt tools of the agent stream family. */
-export declare function listmcpprompts(templates: prompttemplate[]): promptdef[];
-/** Renders one served prompt with its arguments: a walkthrough or protocol prompt renders through its own template while a library template renders through the template library so its sensitive consent notice requirement stays intact; a required argument left empty keeps its placeholder so the review sees the gap. */
-export declare function rendermcpprompt(input: {
-    name: string;
-    args?: Record<string, unknown>;
-    templates: prompttemplate[];
-}): {
-    prompt?: promptdef;
-    rendered?: string;
-    reason?: string;
-};
-/** Builds the prompts/list result of the serve mode: every walkthrough prompt, every library template prompt and every protocol prompt with its declared arguments. */
-export declare function promptsof(templates: prompttemplate[]): {
-    prompts: promptdef[];
-};
-//# sourceMappingURL=serve.d.ts.map

package/dist/session.d.ts

@@ -1,296 +0,0 @@
-/**
- * The session module of the 1.1.90 consolidation: every correlated variation of the session logic interned in this one file, so the module family carries one surface without duplicate variations.
- * The correlation is the session as the persistent interface: sessions holds the stored state of the 1.1.49 memory family (task state checkpoints with their checksums, session capture with restore plans, naming, diffing, search, versioned export and import, retention expiry and the crash interrupted mark); sessioninterface turns the same session into the primary interface of the 1.1.63 family (sitenotes sealed at rest when sensitive, the append only scratchpad, runsummary distillation, semanticrecall with its fingerprint index, correction and consent memory as advisory history, the sessiongrid derived from the existing stores with no new state, historysearch over one corpus, error surfaces with retry hints and cancelrun with its queued only rollback).
- * No window, retention, limit or rollback scope is ever hardcoded: every length and expiry stays the user's choice with no engine cap, and no interface surface ever bypasses the human review.
- */
-import type { autointerval, restoreplan, searchfield, searchquery, sessionchange, sessiondiff, sessionfile, sessionfolder, sessionmatch, sessionrecord, sessiontab, snapshotscope, snapshotplan, stepoutcome, taskstate } from "./types.js";
-/** The session kinds of the 1.1.49 memory family: task state persistence, session capture, restore, naming, diffing, search, export and import. */
-export declare const sessionkinds: string[];
-/** The format version of exported session files; imports of unknown versions are refused. */
-export declare const sessionfileversion = 1;
-/** The reviewed snapshot section toggles: tabs, scroll positions, form state, local storage and cookies. */
-export declare const snapshotsections: snapshotscope[];
-/** The searchable fields of a session search: urls, titles, record names and captured text. */
-export declare const searchfields: searchfield[];
-/** Checksums the run id, step cursor and recorded outputs of a task state so corruption is detected before a resume. */
-export declare function taskstatechecksum(runid: string, stepcursor: number, outputs: stepoutcome[]): string;
-/** Builds one persisted task state checkpoint of a run with its checksum. */
-export declare function taskstateof(input: {
-    runid: string;
-    stepcursor: number;
-    outputs: stepoutcome[];
-    checkpointat: number;
-}): taskstate;
-/** True when a persisted task state carries the intact checksum of its own payload; a corrupted checkpoint never resumes. */
-export declare function taskstatevalid(state: taskstate | undefined): boolean;
-/** Normalizes one captured tab of a saved session: url, title, index, scroll position and form state. */
-export declare function sessiontabof(value: unknown): sessiontab | undefined;
-/** Normalizes one reviewed auto snapshot interval: a positive period, a positive maximum snapshot count and a zero or positive expiry window; every value stays a user choice with no code ceiling. */
-export declare function autointervalof(value: unknown): autointerval | undefined;
-/** Normalizes one reviewed snapshot plan: the scope, the section toggles of the reviewed grammar, the capture link flag and the optional auto interval. */
-export declare function snapshotplanof(value: unknown): snapshotplan | undefined;
-/** Normalizes one reviewed restore plan: the tab, form and capture policies of the reviewed grammar. */
-export declare function restoreplanof(value: unknown): restoreplan | undefined;
-/** Normalizes one reviewed session search query: the non-empty term list, the searched fields of the reviewed grammar and the optional time window. */
-export declare function searchqueryof(value: unknown): searchquery | undefined;
-/** Normalizes one session folder: the name, the optional parent folder and the tag list. */
-export declare function sessionfolderof(value: unknown): sessionfolder | undefined;
-/** Builds one saved session record with its default tag list and capture linkage. */
-export declare function newsessionrecord(input: {
-    id: string;
-    name: string;
-    createdat: number;
-    tabs: sessiontab[];
-    captures: string[];
-    storage: Array<{
-        origin: string;
-        keys: string[];
-        values: string[];
-    }>;
-    cookies: Array<{
-        origin: string;
-        names: string[];
-    }>;
-    auto?: boolean;
-    folder?: string;
-    tags?: string[];
-}): sessionrecord;
-/** Classifies the tab, url, form and storage changes between two saved sessions by matching tabs on their recorded index. */
-export declare function diffsessionrecords(left: sessionrecord, right: sessionrecord): sessionchange[];
-/** Builds one stored session diff result of two compared records. */
-export declare function newsessiondiff(input: {
-    id: string;
-    left: sessionrecord;
-    right: sessionrecord;
-    at: number;
-}): sessiondiff;
-/** Searches across saved sessions: matches urls, titles, record names and captured form text inside the reviewed time window and returns every match with its session id. */
-export declare function searchsessionrecords(query: searchquery, records: sessionrecord[]): sessionmatch[];
-/** Packs saved session records into one versioned session file with its record ids, byte size and checksum. */
-export declare function exportsessionfile(records: sessionrecord[], now: number): sessionfile;
-/** Validates one imported session file: the format version must match, every record must carry intact sections and the checksum must verify before any record review begins. */
-export declare function importsessionfile(value: unknown): sessionfile | undefined;
-/** Expires the heavy sections of saved sessions after the reviewed retention window while the record metadata survives; an absent window keeps every section and no code ceiling applies. */
-export declare function expiresessions(records: sessionrecord[], retention: number | undefined, now: number): sessionrecord[];
-/** Lists saved sessions filtered by name substring, folder and time window; the filter stays a user choice with no result cap. */
-export declare function filteredsessions(records: sessionrecord[], filter: {
-    name?: string;
-    folder?: string;
-    from?: number;
-    to?: number;
-}): sessionrecord[];
-/** Marks one persisted task state interrupted by a browser restart when the cursor never reached the end of the plan. */
-export declare function crashinterrupted(state: taskstate | undefined, plansteps: number, now: number): taskstate | undefined;
-import type { agentplan, cancelrunaction, consentmemoryentry, correctionentry, emptystatesurface, errorsurface, errorcause, historyindexentry, historysearchhit, historysearchquery, planprogress, recallindexentry, recallmatch, recallquery, rollbackdescriptor, runsummary, scratchpadentry, sessiongridrow, sitenote, storedrunlog, tabsessionref } from "./types.js";
-/** Seals one sensitive note body at rest with a local keystream; the sealed text persists while the plain body never does. */
-export declare function sealnotebody(id: string, body: string): string;
-/** Opens one sealed note body for the reading surface; the plain body leaves storage only through this reader. */
-export declare function opennotebody(id: string, sealedbody: string): string;
-/** Builds one site note record per origin: the title, the body, the author provenance and the timestamps; a sensitive note seals its body at rest while a plain note keeps its body readable. */
-export declare function sitenoteof(input: {
-    origin: string;
-    title: string;
-    body: string;
-    author: string;
-    sensitive?: boolean;
-    now: number;
-    id?: string;
-}): sitenote;
-/** Reads the display body of one site note: a sensitive note opens its sealed body for the reader while a plain note returns its body. */
-export declare function notebodyof(note: sitenote): string;
-/** Applies one edit to a site note: the edit keeps the author provenance of the writer and the updated timestamp while the created timestamp stays. */
-export declare function editnote(note: sitenote, input: {
-    title: string;
-    body: string;
-    author: string;
-    now: number;
-}): sitenote;
-/** Expires the site notes past the user configured window: an absent window keeps every note while the expired notes leave the store at the user boundary only. */
-export declare function expirnotes(notes: sitenote[], retention: number | undefined, now: number): sitenote[];
-/** Builds one append only scratchpad entry of one task with its step provenance; the scratchpad never rewrites a written entry. */
-export declare function scratchentryof(input: {
-    taskid: string;
-    sessionid: string;
-    text: string;
-    stepid?: string;
-    author: string;
-    now: number;
-    id?: string;
-}): scratchpadentry;
-/** Reads the scratchpad of one task only: entries of another task never cross the owning task session boundary. */
-export declare function scratchpadof(entries: scratchpadentry[], taskid: string, sessionid: string): scratchpadentry[];
-/** Prunes the scratchpad entries past the user configured window: an absent window keeps every entry while the pruned entries leave the pad only at the user boundary. */
-export declare function prunescratchpad(entries: scratchpadentry[], window: number | undefined, now: number): scratchpadentry[];
-/** Distills one run summary from the completed run: the origins visited, the kinds executed and the per step outcomes inside the user configured window with no fixed cap; the distillation names its provenance. */
-export declare function distillrunsummary(input: {
-    plan: agentplan;
-    outcomes: stepoutcome[];
-    origins: string[];
-    sessionid: string;
-    window?: number;
-    provenance: "offscreenworker" | "inline";
-    now: number;
-}): runsummary;
-/** Builds the runsummary search corpus entry of one distilled summary so historysearch indexes every summary beside the notes and the session metadata. */
-export declare function summaryhistoryentry(summary: runsummary): historyindexentry;
-/** Builds the sitenote search corpus entry of one note; a sensitive note indexes its title and origin only so the sealed body never enters the corpus. */
-export declare function notehistoryentry(note: sitenote): historyindexentry;
-/** Builds one recall index entry from a past extraction record: the fingerprint deduplicates repeated extractions while the run and step provenance stays readable. */
-export declare function recallentryof(input: {
-    origin: string;
-    runid: string;
-    stepid: string;
-    text: string;
-    at: number;
-}): recallindexentry;
-/** Adds one recall index entry with fingerprint deduplication: a repeated extraction keeps its first index entry while later duplicates never double rank. */
-export declare function addrecallentry(index: recallindexentry[], entry: recallindexentry): recallindexentry[];
-/** Ranks the indexed extractions by local text similarity inside the worker: the jaccard overlap of the query terms and the entry terms, scoped to the origins of the run scope, with the provenance of every match. */
-export declare function rankrecall(index: recallindexentry[], query: recallquery, scope: {
-    origins: string[];
-}): recallmatch[];
-/** Expires the recall index entries past the user configured window: the live index keeps the window while the extraction records themselves stay for the audit trail. */
-export declare function expirerecallindex(index: recallindexentry[], window: number | undefined, now: number): recallindexentry[];
-/** Builds one correction memory entry from a plan review edit: the step shape before and after the edit with the reason in plain language. */
-export declare function editedcorrectionof(input: {
-    origin: string;
-    kind: string;
-    stepid: string;
-    original: string;
-    corrected: string;
-    reason: string;
-    now: number;
-    id?: string;
-}): correctionentry;
-/** Builds one correction memory entry from a rejected step: the step shape it refused with the rejection reason. */
-export declare function rejectedcorrectionof(input: {
-    origin: string;
-    kind: string;
-    stepid: string;
-    original: string;
-    reason: string;
-    now: number;
-    id?: string;
-}): correctionentry;
-/** Reads the past corrections that match a proposed step by origin and kind so proposal requests feed the matching history in. */
-export declare function matchingcorrections(corrections: correctionentry[], proposal: {
-    origin: string;
-    kind: string;
-}): correctionentry[];
-/** Expires the correction memory entries past the user configured window: an absent window keeps every correction. */
-export declare function expirecorrections(corrections: correctionentry[], window: number | undefined, now: number): correctionentry[];
-/** Builds one consent memory entry per origin: every grant, denial, expiry and revocation lands with its boundary and kinds while the record stays advisory. */
-export declare function consentmemoryof(input: {
-    origin: string;
-    decision: "grant" | "deny" | "expire" | "revoke";
-    boundary: string;
-    kinds: string[];
-    expiresat?: number;
-    now: number;
-    id?: string;
-}): consentmemoryentry;
-/** Reads the prior consent decisions of one origin for the prompt surface: the history stays advisory, the denial records carry the same weight as the grants and no entry ever auto grants. */
-export declare function consentadvisory(entries: consentmemoryentry[], origin: string, now: number): consentmemoryentry[];
-/** Reads the advisory verdict of the consent memory for a new prompt: the latest decision names itself, a refusal keeps its refusal and no history widens a boundary. */
-export declare function consentadvisoryverdict(entries: consentmemoryentry[], origin: string, kind: string): {
-    advisory: boolean;
-    reason: string;
-};
-/** Computes the queued and the executed steps of one run from the plan and its progress: the queued steps never executed while the executed steps stay in the sealed log. */
-export declare function rollbacksplit(plan: agentplan | undefined, progress: planprogress | undefined): {
-    executedstepids: string[];
-    queuedstepids: string[];
-};
-/** Builds the rollback option descriptor of one cancelrun: the queued scope rolls the queued steps back only while the executed steps stay untouched in the immutable log. */
-export declare function rollbackof(plan: agentplan | undefined, progress: planprogress | undefined, preference: "queued" | "none" | undefined): rollbackdescriptor;
-/** Builds one cancelrun action with its rollback option descriptor; the action never touches the sealed log of the executed steps. */
-export declare function cancelrunactionof(input: {
-    runid: string;
-    sessionid: string;
-    plan: agentplan | undefined;
-    progress: planprogress | undefined;
-    preference: "queued" | "none" | undefined;
-}): cancelrunaction;
-/** Builds one error surface payload of a failed step: the cause class, the message, the retry hint with the policy verdict and the context facts. */
-export declare function errorsurfaceof(input: {
-    stepid: string;
-    runid: string;
-    message: string;
-    cause: errorcause;
-    retryallowed: boolean;
-    retryreason: string;
-    context: Record<string, string>;
-    now: number;
-}): errorsurface;
-/** Classifies the cause of one failed step: a policy refusal and a gate wait carry their own classes, a network shaped message names the network and every other failure stays with the page. */
-export declare function classifyfailure(input: {
-    message: string;
-    policyrefused: boolean;
-    gatewait: boolean;
-}): errorcause;
-/** Reads the retry hint of one error surface: a retry passes only through a new reviewed dispatch, so the verdict names the reviewed path instead of an automatic one. */
-export declare function retryhintof(surface: errorsurface): {
-    allowed: boolean;
-    reason: string;
-};
-/** Derives the session grid rows from the existing session stores with no new state: the live run derives from the session, the plan and its progress, the saved runs derive from the sealed logs and their summaries, and the per tab lock state names the concurrent holder. */
-export declare function sessiongridrows(input: {
-    session?: {
-        id: string;
-        tabid: number;
-        origin: string;
-        stoppedat?: number;
-        pausedat?: number;
-        grants?: string[];
-    };
-    plan?: agentplan;
-    progress?: planprogress;
-    logs: storedrunlog[];
-    summaries: runsummary[];
-    locks: Array<{
-        runid: string;
-    }>;
-    tabsessions: tabsessionref[];
-}): sessiongridrow[];
-/** Normalizes one history search query: the non empty text with the optional origin, time range and outcome filters. */
-export declare function historyqueryof(value: unknown): historysearchquery | undefined;
-/** Adds one corpus entry to the incremental history index: each store write lands in the index at once so the search reads a growing corpus with no rebuild. */
-export declare function addhistoryentry(corpus: historyindexentry[], entry: historyindexentry): historyindexentry[];
-/** Extracts the matched terms of one query inside one text, case insensitive, for the result highlighting. */
-export declare function highlightterms(text: string, query: string): string[];
-/** Searches the one corpus of session metadata, notes and run summaries: the text matches with the matched terms highlighted, filtered by origin, time range and outcome. */
-export declare function historysearch(corpus: historyindexentry[], query: historysearchquery): historysearchhit[];
-/** Serves the empty state guidance of one session interface surface in plain language: the grid explains the first run, the search box suggests a first query, the notes explain the note flow and the scratchpad explains how the agent writes. */
-export declare function emptystatemessage(surface: emptystatesurface, origin?: string): string;
-/** Builds the per tab isolation key of one tab so parallel tabs never collide inside the session stores. */
-export declare function tabsessionkey(tabid: number): string;
-/** Builds one per tab session reference that isolates the session state per tab: parallel tabs keep their own session, run and origin references. */
-export declare function tabsessionrefof(input: {
-    tabid: number;
-    sessionid: string;
-    runid?: string;
-    origin: string;
-    now: number;
-}): tabsessionref;
-/** Exports the site notes, the run summaries and the correction memory as one audit bundle: every record carries its provenance while sensitive note bodies stay sealed. */
-export declare function sessionbundleof(input: {
-    notes: sitenote[];
-    summaries: runsummary[];
-    corrections: correctionentry[];
-    exportedat: number;
-}): {
-    kind: "sessionbundle";
-    notes: sitenote[];
-    summaries: runsummary[];
-    corrections: correctionentry[];
-    exportedat: number;
-};
-/**
- * The recall seam the memory adapter documents for the future remote recall backend: today the local fingerprint index answers every semanticrecall query inside the extension, and the seam keeps the query and answer shapes stable so a reviewed remote backend can take the calls later without touching the callers.
- */
-export interface recallseam {
-    recall(query: recallquery, scope: {
-        origins: string[];
-    }): Promise<recallmatch[]>;
-}
-//# sourceMappingURL=session.d.ts.map

package/dist/storage.d.ts

@@ -1,53 +0,0 @@
-/** DevThink local store: mirrors credential-free workbench records into a physical SQLite database. */
-import type { DevThinkPaths } from "./config.ts";
-export type StoredWorkspace = {
-    id: string;
-    title: string;
-    createdAt: string;
-    updatedAt: string;
-};
-export type StoredTab = {
-    id: string;
-    sessionId: string;
-    workspaceId: string;
-    label: string;
-    provider?: string;
-    sectionId: string;
-    createdAt: string;
-    updatedAt: string;
-};
-export type StoredMessage = {
-    id: string;
-    sessionId: string;
-    workspaceId: string;
-    tabId: string;
-    sectionId: string;
-    role: string;
-    content: string;
-    createdAt: string;
-};
-export type StoredSession = {
-    id: string;
-    workspaceId: string;
-    title: string;
-    mode: string;
-    model?: string;
-    provider?: string;
-    activeTabId: string;
-    createdAt: string;
-    updatedAt: string;
-    tabs: StoredTab[];
-    messages: StoredMessage[];
-};
-export type StoredPreference = {
-    key: string;
-    value: string;
-    updatedAt: string;
-};
-/** Executes a local SQLite transaction without allowing database failures to erase JSON-compatible records. */
-export declare function mirrorSession(paths: DevThinkPaths, workspace: StoredWorkspace, session: StoredSession): void;
-/** Reads non-sensitive workbench preferences from the CLI-owned local database. */
-export declare function readPreferences(paths: DevThinkPaths): Record<string, StoredPreference>;
-/** Persists an allowlisted interface preference without mixing it with provider credentials. */
-export declare function savePreference(paths: DevThinkPaths, key: string, value: string): StoredPreference;
-//# sourceMappingURL=storage.d.ts.map