toolroll 0.9.104 → 0.9.105

package/dist/memory-pass.d.ts

@@ -1,151 +0,0 @@
-import type { Store } from './store.js';
-import { performSubscriptionLeadRequest } from './subscription-chat.js';
-import { type TidyAnalyzer } from './memory-tidy.js';
-import { type MemoryProposal, type Verdict } from './contracts/memory-pass.js';
-export type { MemoryProposal, Verdict };
-/** One session's trace, in characters (TEXT_LIMITS.memoryTrace). */
-export declare const MEMORY_TRACE_BYTES: 40000;
-export declare const MEMORY_MIN_SESSIONS = 2;
-export declare const MEMORY_MAX_PROPOSALS = 6;
-/** The project instructions' budget: the same limit knowledge holds them to. */
-export declare const INSTRUCTION_BUDGET_BYTES: 4000;
-export declare const MEMORY_GAP_MAX_AGE_MS: number;
-export type MemorySource = {
-    id: string;
-    repo: string;
-    kind: 'claude' | 'codex' | 'lead' | 'crew';
-    source: string;
-    at: string;
-    trace: () => string;
-};
-/** The Claude Code project directory for a checkout: the path with every slash turned into a dash. */
-export declare const claudeProjectDir: (cwd: string, home?: string) => string;
-/** Claude Code: one JSONL per session; user/assistant text verbatim, tool calls one line, results clipped, thinking dropped. */
-export declare function distillClaude(path: string): string;
-/** Codex: rollout JSONL; messages and custom tool calls, outputs clipped. */
-export declare function distillCodex(path: string): string;
-export declare function collectSessions(store: Store, repo: string, options?: {
-    evidenceRoot?: string;
-    home?: string;
-    local?: boolean;
-}): MemorySource[];
-export type MemorySurface = {
-    version: string;
-    instructions: {
-        id: string;
-        text: string;
-    }[];
-    decisions: {
-        id: string;
-        claim: string;
-    }[];
-};
-/** The always-loaded surface: instruction lines with stable ids, active decisions with theirs. Its hash keys the analysis cache. */
-export declare function memorySurface(store: Store, repo: string, actor: string): MemorySurface;
-export type MemoryAnalyzer = (input: {
-    trace: string;
-    surface: MemorySurface;
-    openGaps: {
-        key: string;
-        mistake: string;
-    }[];
-    kind: MemorySource['kind'];
-}) => Promise<{
-    ok: true;
-    text: string;
-} | {
-    ok: false;
-    problem: string;
-}>;
-export declare function analysisPrompt(surface: MemorySurface, openGaps: {
-    key: string;
-    mistake: string;
-}[]): string;
-/** The production analyser: one call through the configured chat provider, no tools, no history. */
-export declare function defaultAnalyzer(store: Store, options: {
-    configDir?: string;
-    env?: NodeJS.ProcessEnv;
-    fetcher?: typeof fetch;
-    timeoutMs?: number;
-    runner?: Parameters<typeof performSubscriptionLeadRequest>[1];
-}): MemoryAnalyzer;
-/** The clean-up's question to the chat model, asked only on a person's request (memory-tidy.ts proposeTidy). */
-export declare function defaultTidyAnalyzer(store: Store, options?: {
-    env?: NodeJS.ProcessEnv;
-    configDir?: string;
-    fetcher?: typeof fetch;
-    runner?: Parameters<typeof performSubscriptionLeadRequest>[1];
-    timeoutMs?: number;
-}): TidyAnalyzer;
-/**
- * Read the analyser's answer with the tolerant parse-side schema, then keep only claims whose quote
- * is really in the trace and, for an instruction's effect, whose id is on the surface audited.
- */
-export declare function parseVerdict(text: string, trace: string, surface: MemorySurface): {
-    ok: true;
-    verdict: Verdict;
-} | {
-    ok: false;
-    problem: string;
-};
-export type PassReport = {
-    repo: string;
-    surface: string;
-    sessions: number;
-    analyzed: number;
-    cached: number;
-    failed: number;
-    problems: string[];
-    gaps: number;
-    proposals: number;
-};
-/**
- * Collect, distil, analyse and aggregate for one project. Never writes memory:
- * it fills the ledger and the proposal queue. Each session is analysed once
- * per surface version; a failed analysis is named and retried next run.
- */
-export declare function runMemoryPass(store: Store, args: {
-    repo: string;
-    actor: string;
-    analyzer: MemoryAnalyzer;
-    evidenceRoot?: string;
-    home?: string;
-    local?: boolean;
-    maxSessions?: number;
-}, now?: Date): Promise<PassReport>;
-/**
- * Turn corroborated gaps and harm into a few proposals: an addition needs
- * the gap seen in at least two distinct sessions; a removal needs harm from
- * following the instruction in two sessions. Under the instruction budget an
- * addition is proposed only when it fits; over it, the run says so instead
- * of growing the file. A rejected fingerprint is not proposed again until
- * more sessions corroborate it.
- */
-export declare function synthesizeProposals(store: Store, repo: string, actor: string, surface: MemorySurface, now?: Date): number;
-export declare function listProposals(store: Store, repo: string, status?: 'pending' | 'all'): MemoryProposal[];
-/** The one writer: accept applies the edit through the knowledge or decision store as the person; reject remembers the fingerprint and its corroboration. */
-export declare function decideProposal(store: Store, args: {
-    repo: string;
-    actor: string;
-    id: number;
-    decision: 'accept' | 'reject';
-    claim?: string;
-}, now?: Date): MemoryProposal;
-export declare function memoryStatus(store: Store, repo: string, actor: string): {
-    surface: string;
-    instructionBytes: number;
-    budgetBytes: number;
-    sessions: {
-        total: number;
-        analyzed: number;
-        failed: number;
-    };
-    openGaps: number;
-    pending: number;
-    included: {
-        kind: string;
-        item: string;
-        title: string;
-        words: string;
-    }[];
-};

package/dist/memory-tidy.d.ts

@@ -1,181 +0,0 @@
-import { type Decision } from "./project-memory.js";
-import type { Store } from "./store.js";
-export declare const UNUSED_DAYS = 60, UNUSED_RUNS = 20, FAILING_NOTE = 3, TIDY_MIN_ENTRIES = 10;
-export declare const TIDY_EVERY_MS: number, TIDY_QUIET_MS = 86400000;
-/** What a stale proposal says. */
-export declare const TIDY_STALE = "Changed since proposed. Run Clean up again.";
-export type TidyItem = {
-    kind: "decision";
-    id: number;
-    revision: number;
-    status: string;
-    sha: string;
-} | {
-    kind: "reference";
-    id: string;
-    revision: number;
-    sha: string;
-} | {
-    kind: "lesson";
-    id: number;
-    version: number;
-    sha: string;
-};
-export type TidyKind = "retire" | "merge" | "contradiction" | "note-failing" | "restore" | "unmerge";
-export type TidyProposal = {
-    id: number;
-    repo: string;
-    kind: TidyKind;
-    items: TidyItem[];
-    afterText: string | null;
-    rationale: string;
-    evidence: Record<string, unknown>;
-    source: string;
-    status: string;
-    createdAt: string;
-    decidedBy: string | null;
-    titles: Record<string, string>;
-};
-export declare function listTidy(store: Store, repo: string, status?: "pending" | "all"): TidyProposal[];
-/**
- * The scheduled pass: deterministic, no analyzer in reach. Runs when the project has been quiet for a day, at most
- * weekly, with at least 10 entries. Proposes only.
- */
-export declare function scheduledTidy(store: Store, repo: string, now: Date): number;
-export type TidyAnalyzer = (input: {
-    system: string;
-    data: string;
-}) => Promise<{
-    ok: true;
-    text: string;
-} | {
-    ok: false;
-    problem: string;
-}>;
-export declare const CONTRADICTION_SCHEMA: {
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly required: readonly ["contradictions"];
-    readonly properties: {
-        readonly contradictions: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "object";
-                readonly additionalProperties: false;
-                readonly required: readonly ["a", "b", "why"];
-                readonly properties: {
-                    readonly a: {
-                        readonly type: "integer";
-                    };
-                    readonly b: {
-                        readonly type: "integer";
-                    };
-                    readonly why: {
-                        readonly type: "string";
-                    };
-                };
-            };
-        };
-    };
-};
-/** Read a model's pairs: ids of active decisions only, a clean reason, each pair once. Everything else is dropped. */
-export declare function parseContradictions(text: string, active: readonly number[]): {
-    a: number;
-    b: number;
-    why: string;
-}[];
-/** Clean up, on a person's request: the deterministic pass with no quiet gate, and contradictions when an analyzer is given. */
-export declare function proposeTidy(store: Store, args: {
-    repo: string;
-    actor: string;
-    analyzer?: TidyAnalyzer;
-}, now: Date): Promise<{
-    made: number;
-    problem: string | null;
-}>;
-/** Every decision reachable from `id` through ordinary supersession and not-undone merges, transitively (never `id`). */
-export declare function successorChain(store: Store, repo: string, id: number): number[];
-/** The active decisions in `id`'s chain. */
-export declare function activeTail(store: Store, repo: string, id: number): number[];
-/** One new decision from several; each old one superseded with a "merged into" history row; every member listed. */
-export declare function mergeDecisions(store: Store, args: {
-    repo: string;
-    actor: string;
-    ids: readonly number[];
-    claim: string;
-    why: string;
-    proof: string;
-}, now: Date): Decision;
-export type ExpandedChange = {
-    restored: false;
-    proposal: number;
-    items: TidyItem[];
-};
-/**
- * Restore a retired or superseded decision. With no active tail it goes straight back to active. With one, nothing
- * changes: a proposal names every affected item, and a person chooses what happens to the tail.
- */
-export declare function restoreDecision(store: Store, args: {
-    repo: string;
-    actor: string;
-    id: number;
-    proof: string;
-}, now: Date): {
-    restored: true;
-    decision: Decision;
-} | ExpandedChange;
-/**
- * Undo a merge. Direct only while its successor is active, at the revision recorded at the merge, and not merged on.
- * Otherwise nothing changes: a proposal names every affected item, the later merge included. A merge already undone is
- * refused and changes nothing.
- */
-export declare function unmergeDecisions(store: Store, args: {
-    repo: string;
-    actor: string;
-    merge: number;
-    proof: string;
-}, now: Date): {
-    restored: true;
-    successor: number;
-} | ExpandedChange;
-/** A disabled lesson back in use (re-checks its support, bound to its version and sha). */
-export declare function restoreLesson(store: Store, root: string, args: {
-    repo: string;
-    actor: string;
-    id: number;
-    proof: string;
-}, now: Date): void;
-/** A reference back from history, as a new knowledge revision bound to the current one. */
-export declare function restoreReference(store: Store, args: {
-    repo: string;
-    actor: string;
-    id: string;
-    fromRevision: number;
-    proof: string;
-}, now: Date): void;
-export type TidyDecision = {
-    repo: string;
-    actor: string;
-    id: number;
-    decision: "accept" | "reject";
-    choice?: string;
-    claim?: string;
-    why?: string;
-    proof: string;
-};
-/**
- * Accept or reject one proposal: the one writer of a proposal's outcome. In one transaction, a person's standing, the
- * proposal's state and every bound item are re-read; any difference marks it stale and changes nothing.
- */
-export declare function decideTidy(store: Store, root: string, args: TidyDecision, now: Date): TidyProposal;
-/** Merges that can still be undone, for the page. */
-export declare function undoableMerges(store: Store, repo: string): {
-    merge: number;
-    successor: number;
-    predecessors: number[];
-}[];
-/** Lessons that were disabled and can be used again, for the page. */
-export declare function disabledLessons(store: Store, repo: string): {
-    id: number;
-    observation: string;
-}[];

package/dist/memory-use.d.ts

@@ -1,35 +0,0 @@
-import { type KnowledgeSelection } from "./contracts/project-knowledge.js";
-import type { Store } from "./store.js";
-export type MemoryKind = "lesson" | "reference" | "decision";
-export type MemoryUse = {
-    lastRun: number;
-    lastAt: string | null;
-    runs: number;
-};
-/** A run's role as a phase of the work. */
-export declare const phaseOfRole: (role: string) => "plan" | "review" | "build";
-/** Every reference and decision in a run's frozen knowledge. Called in the transaction that freezes it; advisory, so a
- * failure leaves the run's context exactly as it was. */
-export declare function recordKnowledgeUse(store: Store, input: {
-    run: number;
-    repo: string;
-    role: string;
-    selection: KnowledgeSelection;
-}): void;
-/** Every lesson in a run's frozen learning context. As recordKnowledgeUse. */
-export declare function recordLessonUse(store: Store, input: {
-    run: number;
-    repo: string;
-    payload: string;
-    at: string;
-}): void;
-/**
- * Backfill from snapshots older than this feature, a bounded batch at a time (the watch loop's learning pass): each
- * snapshot's sha is verified first. Lesson rows take the snapshot's own time and version; knowledge rows from a snapshot
- * with no `capturedAt` have no version and no time. Returns how many snapshots were read.
- */
-export declare function backfillMemoryUse(store: Store, now: Date, limit?: number): number;
-/** A project's usage, by `<kind>:<item>`: its newest run, that run's time and how many runs had it. */
-export declare function memoryUseOf(store: Store, repo: string): Map<string, MemoryUse>;
-/** "Last included in a run: #4410, Nov 3 · 41 runs"; "#2210 (time not recorded)" for a backfilled row; "Not included yet". */
-export declare function lastIncludedWords(use: MemoryUse | undefined): string;

package/dist/merge-checklist.d.ts

@@ -1,55 +0,0 @@
-/** "Can I merge?" (docs/plans/plain-toolroll.md P1.6): one checklist per task, read from the records the task page,
- * the result page and the pull request row already read, with nothing recomputed and nothing checked live. Each row
- * says one fact about the task's current result; a blocker carries one existing act the person can take: Run checks,
- * Retry, or Ask the agent to fix (Send back with a note naming the blocker). Nothing here acts: it is a read, and every
- * act it names is the person's own post through its usual door.
- *
- * Rows Toolroll keeps no record of (up to date with main; conflicts outside a batch check) say so, rather than guess:
- * GitHub shows them on the pull request. */
-import { type AssignmentAccess, type AssignmentSnapshot } from "./assignment.js";
-import { type Store } from "./store.js";
-export declare const CHECKLIST_KEYS: readonly ["plan", "build", "checks", "requirements", "pull-request", "pr-ci", "up-to-date", "conflicts", "comments", "release"];
-export type ChecklistKey = (typeof CHECKLIST_KEYS)[number];
-/** yes: done; no: in the way (with its act when one exists); waiting: under way, nothing to do yet; unknown: Toolroll
- * keeps no record of it; skip: doesn't apply to this task. */
-export type ChecklistMark = "yes" | "no" | "waiting" | "unknown" | "skip";
-/** The existing act a blocker carries. `fix`: Send back, with `note` as its feedback (empty: send the saved notes). */
-export type ChecklistAct = {
-    kind: "run-checks";
-    run: number;
-} | {
-    kind: "retry";
-    taskId: string;
-} | {
-    kind: "fix";
-    run: number;
-    note: string;
-};
-export type ChecklistRow = {
-    key: ChecklistKey;
-    label: string;
-    mark: ChecklistMark;
-    say: string;
-    act: ChecklistAct | null;
-};
-export type MergeChecklist = {
-    taskId: string;
-    activeTaskId: string;
-    run: number | null;
-    head: string | null;
-    /** yes: nothing Toolroll records is in the way; no: something is (the first `no` row); not-yet: only waiting rows. */
-    answer: "yes" | "no" | "not-yet" | "merged";
-    sentence: string;
-    rows: ChecklistRow[];
-};
-export declare const CHECKLIST_LABELS: Readonly<Record<ChecklistKey, string>>;
-/** The one sentence for a row Toolroll keeps no record of. */
-export declare const NOT_RECORDED = "Toolroll doesn't record this. The pull request on GitHub shows it.";
-/** The act labels, the same words the result page uses. */
-export declare const CHECKLIST_ACT_LABELS: Readonly<Record<ChecklistAct["kind"], string>>;
-/** The checklist for a task's current result, as `access` may see it; null when the task isn't visible there. */
-export declare function mergeChecklistOf(store: Store, taskId: string, now: Date, access: AssignmentAccess, root?: string): MergeChecklist | null;
-/** The checklist from an assignment snapshot already read (the task page reads one). */
-export declare function checklistFromAssignment(store: Store, taskId: string, assignment: AssignmentSnapshot): MergeChecklist;
-/** The checklist as plain lines (the CLI, the lead, the TUI): the answer, then one line per row that applies. */
-export declare function checklistLines(list: MergeChecklist): string[];

package/dist/metrics.d.ts

@@ -1,6 +0,0 @@
-import type { Store } from "./store.js";
-import { type ServerTelemetry } from "./server-telemetry.js";
-/** `repos`: the projects this console serves (null: all); task, run and worker figures count only theirs. */
-export declare function prometheusMetrics(store: Store, now: Date, repos?: readonly string[] | null, destinations?: ReadonlyMap<string, string>): string;
-/** Performance labels are fixed vocabularies only, independent of the store's project labels. */
-export declare function performanceMetrics(telemetry: ServerTelemetry): string;

package/dist/mobile-viewport.d.ts

@@ -1,7 +0,0 @@
-/** Presentation only: no fields are read, no requests are sent, and no
- * keyboard events are captured. A focused input alone is NOT a keyboard.
- *
- * It publishes the visible area (--viewport-height, --viewport-top): a phone's
- * keyboard shrinks only the visual viewport on iOS (100dvh never moves), so a
- * full-height app shell sized to it is what keeps the composer above the keys. */
-export declare const MOBILE_VIEWPORT_SCRIPT: string;

package/dist/model-catalog.d.ts

@@ -1,123 +0,0 @@
-import type { Store } from "./store.js";
-import { type OpenRouterModel } from "./openrouter-models.js";
-import { type ProviderId } from "./provider.js";
-export declare const MODELS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS model_seen (\n  source        TEXT NOT NULL CHECK (source IN ('claude','codex','gemini','openrouter')),\n  id            TEXT NOT NULL,\n  name          TEXT NOT NULL,\n  input_usd     REAL,\n  output_usd    REAL,\n  context       INTEGER,\n  tools         INTEGER NOT NULL DEFAULT 0,\n  released_at   TEXT,\n  first_seen_at TEXT NOT NULL,\n  last_seen_at  TEXT NOT NULL,\n  PRIMARY KEY (source, id)\n);\nCREATE TABLE IF NOT EXISTS runtime_check (\n  tool           TEXT PRIMARY KEY CHECK (tool IN ('claude','codex','gemini')),\n  installed      TEXT,\n  latest         TEXT,\n  update_command TEXT,\n  problem        TEXT,\n  checked_at     TEXT NOT NULL,\n  updated_at     TEXT,\n  updated_by     TEXT\n);\nCREATE TABLE IF NOT EXISTS model_watch (\n  id         INTEGER PRIMARY KEY CHECK (id = 1),\n  enabled    INTEGER NOT NULL DEFAULT 0,\n  checked_at TEXT,\n  problem    TEXT,\n  changed_by TEXT,\n  changed_at TEXT\n);";
-export type ModelSource = "claude" | "codex" | "gemini" | "openrouter";
-export type SeenModel = {
-    source: ModelSource;
-    id: string;
-    name: string;
-    inputUsd: number | null;
-    outputUsd: number | null;
-    context: number | null;
-    tools: boolean;
-    releasedAt: string | null;
-    firstSeenAt: string;
-};
-export type RuntimeTool = "claude" | "codex" | "gemini";
-export type RuntimeState = {
-    tool: RuntimeTool;
-    name: string;
-    installed: string | null;
-    latest: string | null;
-    updateCommand: string[] | null;
-    problem: string | null;
-    checkedAt: string;
-    updatedAt: string | null;
-    updatedBy: string | null;
-    behind: boolean;
-};
-export type VersionRunner = (command: string, args: string[], options: {
-    timeoutMs: number;
-    env?: NodeJS.ProcessEnv;
-}) => Promise<{
-    code: number;
-    stdout: string;
-    stderr: string;
-}>;
-export type CatalogSeams = {
-    fetcher?: typeof fetch;
-    runner?: VersionRunner;
-    home?: string;
-    path?: string;
-};
-export declare const RUNTIME_TOOLS: Record<RuntimeTool, {
-    name: string;
-    command: string;
-    pkg: string;
-}>;
-export declare const WATCH_EVERY_MS: number;
-/** The current Claude models by exact id, offered even before the first catalog check has run. */
-export declare const CLAUDE_EXACT: readonly {
-    value: string;
-    label: string;
-}[];
-/** `anthropic/claude-opus-5.5` → `claude-opus-5-5`, the name the Claude CLI and API use. */
-export declare function claudeIdOf(openrouterId: string): string | null;
-/** The Codex CLI's own list — account-specific, maintained by the CLI. */
-export declare function codexCatalog(home?: string): {
-    id: string;
-    name: string;
-}[];
-type Row = Omit<SeenModel, "firstSeenAt">;
-/** Pure: the catalog rows each source should hold after a fetch. */
-export declare function catalogRows(openrouter: OpenRouterModel[], codex: {
-    id: string;
-    name: string;
-}[]): Row[];
-/** Upsert a fetch. Returns models first seen now, except on a source's first
- * fetch (the baseline would otherwise announce every model at once). */
-export declare function recordCatalog(store: Store, rows: Row[], now: Date): SeenModel[];
-export declare function seenModels(store: Store, source: ModelSource, options?: {
-    current?: boolean;
-}): SeenModel[];
-export declare function seenModel(store: Store, source: ModelSource, id: string): SeenModel | null;
-export declare function isNewModel(model: SeenModel, now: Date): boolean;
-/** What the Claude CLI's short name currently runs: the newest of its family. */
-export declare function aliasTarget(store: Store, alias: string): SeenModel | null;
-export declare function dollars(amount: number | null): string;
-export declare function priceWords(model: SeenModel): string;
-/** The friendly name for a saved provider + model, e.g. "opus" → "Claude Opus 5.5". */
-export declare function modelWords(store: Store, provider: string, model: string | null): string;
-export type ModelOption = {
-    value: string;
-    label: string;
-    isNew: boolean;
-};
-/** Every model a provider can run, newest first, with prices. */
-export declare function modelOptions(store: Store, provider: ProviderId, now: Date, home?: string): ModelOption[];
-/** Chat reserves worst-case spend: price per token in whole micro-dollars,
- * rounded UP from the live list price. null = no live price. */
-export declare function livePin(store: Store, chatProvider: string, model: string): {
-    inMicrousd: number;
-    outMicrousd: number;
-} | null;
-export declare function compareVersions(a: string, b: string): number;
-/** How this copy was installed decides the one safe update command. */
-export declare function updateCommandFor(tool: RuntimeTool, resolved: string): string[] | null;
-export declare function runtimeStates(store: Store): RuntimeState[];
-export declare function checkRuntimes(store: Store, now: Date, seams?: CatalogSeams): Promise<RuntimeState[]>;
-/** Update one CLI, only while nothing is running, then read its version again. */
-export declare function updateRuntime(store: Store, tool: RuntimeTool, by: string, now: Date, seams?: CatalogSeams): Promise<{
-    ok: boolean;
-    message: string;
-}>;
-export type WatchState = {
-    enabled: boolean;
-    checkedAt: string | null;
-    problem: string | null;
-    changedBy: string | null;
-};
-export declare function watchState(store: Store): WatchState;
-export declare function setWatch(store: Store, enabled: boolean, by: string, now: Date): void;
-/** One full check: the catalog, the CLIs, and a notice for each new model or
- * newly available update. Idempotent per model and per released version. */
-export declare function checkModels(store: Store, now: Date, seams?: CatalogSeams): Promise<{
-    ok: boolean;
-    added: SeenModel[];
-    runtimes: RuntimeState[];
-    problem: string | null;
-}>;
-/** The background pass: runs only when the person turned checks on. */
-export declare function modelWatchPass(store: Store, now: Date, seams?: CatalogSeams): Promise<boolean>;
-export {};