toolroll 0.9.96 → 0.9.98

package/dist/live-reply.js

@@ -0,0 +1,302 @@
+/**
+ * The shared live-reply core (docs/plans/responsive-chat.md §2): one lead turn's `LeadProgress` turned into text-only
+ * views that every surface renders. Surfaces never read `LeadProgress` themselves.
+ *
+ *   queued → working (one status line) → writing (status + display-safe partial text) → closed (answered | failed | blocked)
+ *
+ * Nothing here is durable or authoritative: the saved thread message and its cards remain the record, and no view ever
+ * carries a card, a button, an ask or an approval. A partial is the reply as written so far, cut back to what is
+ * settled (never an unfinished word, code span, link or bold run), withheld while its tail could be the start of a
+ * password or key, and shaped with the final reply's own presentation policy (presentation, not redaction).
+ *
+ * `createLiveSender` is the one sender per live surface message (§2.4): at most one request in flight, one pending
+ * slot holding only the newest view, a generation that only grows, and `close()` — after which nothing more is sent,
+ * and which resolves only once the request in flight has settled, so durable delivery can start strictly after it.
+ */
+import { scanForSecrets } from "./evidence.js";
+import { shapeReply, shapeReplyPrefix } from "./reply-shape.js";
+/** The status line's fixed words (§2.3). A running tool reads as its own label plus "…". */
+export const LIVE_STATUS = {
+    queued: "Waiting for your earlier messages…",
+    thinking: "Thinking…",
+    writing: "Writing…",
+    repair: "Fixing the reply…",
+    shorten: "Shortening the reply…",
+    /** A preview closed because text looked like a password or key; the turn itself may still answer. */
+    held: "Working on it…",
+};
+/** One token that could still grow into a match of a secret family: a non-empty prefix of one of its openings, or the
+ * whole opening followed by its body characters. Preceded by a non-word character or the start, as the detectors'
+ * own word boundaries are. */
+function opening(leads, body) {
+    const escape = (text) => text.replace(/[.*+?^${}()|[\]\\/-]/g, "\\$&");
+    const alternatives = new Set();
+    for (const lead of leads) {
+        for (let length = 1; length < lead.length; length += 1)
+            alternatives.add(escape(lead.slice(0, length)));
+        alternatives.add(`${escape(lead)}${body}*`);
+    }
+    return `(?:${[...alternatives].join("|")})`;
+}
+/**
+ * The start of every `SECRET_PATTERNS` family (evidence.ts), checked against the end of the text written so far:
+ * while any matches, the partial is withheld. Single-token families look at the unfinished last token; the families
+ * whose match spans spaces (a private-key header, an npm `_authToken = value`) look at the whole last line.
+ */
+const SECRET_STARTS = [
+    // private-key: "-----BEGIN RSA PRIVATE KEY-----", partway. No start boundary: the complete detector has none either.
+    /-{1,5}(?:B(?:E(?:G(?:I(?:N(?:[ \t][A-Z \t]*-{0,5})?)?)?)?)?)?$/,
+    // npm-auth-token: "_authToken = value", partway.
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9])${opening(["_authToken"], String.raw `[\s=]`)}\S*$`),
+    // aws-access-key, github-token, slack-token, openai-key, stripe-key, google-api-key, gitlab-token.
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["AKIA", "ASIA"], "[0-9A-Z]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["ghp_", "gho_", "ghu_", "ghs_", "ghr_", "github_pat_"], "[A-Za-z0-9_]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["xoxb-", "xoxa-", "xoxp-", "xoxr-", "xoxs-"], "[A-Za-z0-9-]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["sk-"], "[A-Za-z0-9_-]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["sk_live_", "sk_test_", "rk_live_", "rk_test_", "whsec_"], "[A-Za-z0-9]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["AIza"], "[0-9A-Za-z_-]")}$`),
+    new RegExp(String.raw `(?:^|[^A-Za-z0-9_])${opening(["glpat-"], "[A-Za-z0-9_-]")}$`),
+    // telegram-bot-token: "123456789:AA…".
+    /(?:^|[^A-Za-z0-9_])\d+(?::(?:A(?:A[A-Za-z0-9_-]*)?)?)?$/,
+    // discord-bot-token: "M…24.…6.…27".
+    /(?:^|[^A-Za-z0-9_])[MN][A-Za-z\d]*(?:\.[\w-]*(?:\.[\w-]*)?)?$/,
+    // password-in-url: "scheme://user:password@host", partway (a scheme and its colon are enough to wait).
+    /(?:^|[^A-Za-z0-9+.-])[a-z][a-z0-9+.-]*:\S*$/i,
+];
+/** Could the end of this text be the start of a password or key? Then nothing of it shows yet. */
+export function secretMayStart(text) {
+    const lastLine = text.replace(/\r\n?/g, "\n").split("\n").at(-1) ?? "";
+    return SECRET_STARTS.some(pattern => pattern.test(lastLine));
+}
+/**
+ * What of a reply still being written is settled: everything before its last whitespace (the unfinished last word
+ * stays out), then cut back before any code fence, code span, bold run or link that hasn't closed yet. Trailing
+ * whitespace is trimmed.
+ */
+export function settledText(raw) {
+    const text = raw.replace(/\r\n?/g, "\n");
+    let end = text.length;
+    while (end > 0 && !/\s/.test(text[end - 1]))
+        end -= 1;
+    const shown = text.slice(0, end);
+    let fence = -1, code = -1, bold = -1, link = -1;
+    let linkState = null;
+    for (let index = 0; index < shown.length; index += 1) {
+        if (shown.startsWith("```", index)) {
+            fence = fence === -1 ? index : -1;
+            index += 2;
+            continue;
+        }
+        if (fence !== -1)
+            continue;
+        const char = shown[index];
+        if (char === "\n") {
+            code = -1;
+            bold = -1;
+            link = -1;
+            linkState = null;
+            continue;
+        }
+        if (char === "`") {
+            code = code === -1 ? index : -1;
+            continue;
+        }
+        if (code !== -1)
+            continue;
+        if (shown.startsWith("**", index)) {
+            bold = bold === -1 ? index : -1;
+            index += 1;
+            continue;
+        }
+        if (char === "[" && linkState === null) {
+            link = index;
+            linkState = "label";
+            continue;
+        }
+        if (linkState === "label" && char === "]") {
+            if (shown[index + 1] === "(") {
+                linkState = "url";
+                index += 1;
+            }
+            else {
+                link = -1;
+                linkState = null;
+            }
+            continue;
+        }
+        if (linkState === "url" && (char === ")" || /\s/.test(char))) {
+            link = -1;
+            linkState = null;
+        }
+    }
+    const cut = Math.min(...[fence, code, bold, link].filter(at => at !== -1), shown.length);
+    return shown.slice(0, cut).trimEnd();
+}
+/**
+ * A partial as it may be shown: `blocked` when it holds a password or key (the preview closes), `withheld` while its
+ * tail could still become one (show nothing new), else the settled text shaped for display. A step's finished text
+ * (`final`, secret-checked whole by the engine) shows whole.
+ */
+export function partialDisplay(raw, final, shape = {}) {
+    if (scanForSecrets(raw).length > 0)
+        return { kind: "blocked" };
+    if (!final && secretMayStart(raw))
+        return { kind: "withheld" };
+    const text = final ? shapeReply(raw, shape) : shapeReplyPrefix(settledText(raw), shape);
+    // Shaping only relabels and removes; a secret in what it returns would mean it came from somewhere else. Never shown.
+    if (scanForSecrets(text).length > 0)
+        return { kind: "blocked" };
+    return { kind: "shown", text };
+}
+/** One turn's live reply. `shape`: the owner's message (`asked`) and this app's origins, as the final reply is shaped. */
+export function createLiveReply(shape = {}, options = {}) {
+    const steps = [];
+    let queued = options.queued === true;
+    let closed = null;
+    let turn = null;
+    let last = "";
+    const current = () => steps.at(-1) ?? (steps.push({ calls: [], raw: "", shown: "" }), steps.at(-1));
+    const status = () => {
+        const step = steps.at(-1);
+        const running = step?.calls.filter(call => call.state === "running").at(-1);
+        if (running !== undefined)
+            return `${running.label}…`;
+        if (step?.reason !== undefined)
+            return LIVE_STATUS[step.reason];
+        if (closed === "blocked")
+            return LIVE_STATUS.held;
+        if (step !== undefined && step.raw.trim() !== "")
+            return LIVE_STATUS.writing;
+        return LIVE_STATUS.thinking;
+    };
+    const view = () => {
+        if (closed !== null)
+            return { phase: "closed", why: closed };
+        if (queued && steps.length === 0)
+            return { phase: "queued" };
+        const text = [...steps].reverse().find(step => step.shown !== "")?.shown ?? "";
+        return text === "" ? { phase: "working", status: status() } : { phase: "writing", status: status(), text };
+    };
+    const changed = () => {
+        const now = JSON.stringify(view());
+        if (now === last)
+            return false;
+        last = now;
+        return true;
+    };
+    last = JSON.stringify(view());
+    return {
+        get turn() { return turn; },
+        push(event) {
+            if (closed !== null)
+                return false;
+            turn ??= event.turn;
+            queued = false;
+            switch (event.kind) {
+                case "started": break;
+                case "step":
+                    steps.push({ calls: [], raw: "", shown: "", ...(event.reason === undefined ? {} : { reason: event.reason }) });
+                    break;
+                case "tool":
+                    current().calls.push({ id: event.id, label: event.label, state: "running" });
+                    break;
+                case "tool-result":
+                    for (const step of steps) {
+                        const index = step.calls.findIndex(call => call.id === event.id);
+                        if (index !== -1) {
+                            step.calls[index] = { id: event.id, label: step.calls[index].label, ...event.outcome };
+                            break;
+                        }
+                    }
+                    break;
+                case "text": {
+                    const step = current();
+                    step.raw = event.text;
+                    const shown = partialDisplay(event.text, event.final === true, shape);
+                    if (shown.kind === "blocked") {
+                        closed = "blocked";
+                        for (const one of steps)
+                            one.shown = "";
+                    }
+                    else if (shown.kind === "shown")
+                        step.shown = shown.text;
+                    break;
+                }
+                case "blocked":
+                    closed = "blocked";
+                    for (const one of steps)
+                        one.shown = "";
+                    break;
+            }
+            return changed();
+        },
+        close(why) {
+            if (closed === null)
+                closed = why;
+            for (const one of steps)
+                one.shown = "";
+            changed();
+        },
+        view,
+        status,
+        tools: () => steps.map(step => step.calls.map(call => ({ ...call }))),
+    };
+}
+/**
+ * The serialized sender for one live surface message (§2.4). `standing` re-proves the viewer's right to see this turn
+ * before every send (it may await; the close is re-checked after it). `spacingMs` is the least time between two sends,
+ * read before each one (a surface widens it after the platform asks for a pause). A failed send drops that view:
+ * previews are best effort.
+ */
+export function createLiveSender(options) {
+    const spacing = () => typeof options.spacingMs === "function" ? options.spacingMs() : options.spacingMs ?? 0;
+    const now = options.now ?? Date.now;
+    let generation = 0;
+    let closed = false;
+    let pending = null;
+    let inflight = null;
+    let timer = null;
+    let lastSent = Number.NEGATIVE_INFINITY;
+    const pump = () => {
+        if (closed || inflight !== null || timer !== null || pending === null)
+            return;
+        const wait = lastSent + spacing() - now();
+        if (wait > 0) {
+            timer = setTimeout(() => { timer = null; pump(); }, wait);
+            timer.unref?.();
+            return;
+        }
+        const next = pending;
+        pending = null;
+        inflight = (async () => {
+            try {
+                if (options.standing !== undefined && !(await options.standing()))
+                    return;
+                if (closed)
+                    return;
+                lastSent = now();
+                await options.send(next.view, next.generation);
+            }
+            catch { /* best effort: this view is dropped */ }
+        })().finally(() => { inflight = null; pump(); });
+    };
+    return {
+        get generation() { return generation; },
+        get closed() { return closed; },
+        offer(view) {
+            if (closed)
+                return;
+            generation += 1;
+            pending = { view, generation };
+            pump();
+        },
+        async close() {
+            closed = true;
+            pending = null;
+            if (timer !== null)
+                clearTimeout(timer);
+            timer = null;
+            await inflight;
+        },
+    };
+}

package/dist/local-owner.js

@@ -181,6 +181,8 @@ export const CHAT_ACTION_LOCAL_ACTS = Object.freeze({
     result_accept: "complete-task",
     task_cancel: "stop-run",
     task_resume: "resume-run",
+    // A Start card: the fast start's own act (approve() allows it only with a fast marker).
+    task_start: "build-now",
 });
 /** Every task card operation (chat-task-actions.ts), decided for the local owner. */
 export const CHAT_TASK_ACTION_LOCAL_ACTS = Object.freeze({

package/dist/one-step-chat-schema.d.ts

@@ -0,0 +1,22 @@
+/**
+ * v159: one-step start from chat (docs/plans/one-step-chat.md). Adds only: a saved row reads as it did. Kept beside
+ * nothing else so the update road can read the lists without the store, and so the version is easy to renumber.
+ *
+ * - `fast_preview.turn`: the lead turn a chat start's preview was prepared in (fast-start.ts prepareChatStart). Saved
+ *   rows read NULL; a chat preview without a turn is unusable, and the form's previews never have one.
+ * - `chat_typed_start` (C5): a typed yes to a Start card, recorded with the inbound message in the transaction that saves
+ *   it (typed-start.ts): which card it answered (the proposal and the chat message that carried it), the card's action
+ *   stamp then, how it was tied to the card (`reply` to it, or the `next` message after it), and once settled, the
+ *   outcome and the task it started. A new table: nothing saved changes. `proposal` is a plain number, not a reference:
+ *   the record has to outlive its card. Ending the chat deletes the card's proposal, and a yes already recorded for it
+ *   must still be answered by Toolroll ("didn't start anything") and never handed to the lead as a new message. Proposal
+ *   ids are never reused (AUTOINCREMENT), so a kept number can't come to name another card.
+ */
+export declare const V159_SCHEMA = "\nCREATE TABLE IF NOT EXISTS chat_typed_start (\n  provider     TEXT NOT NULL CHECK (provider IN ('telegram')),\n  event        TEXT NOT NULL,\n  proposal     INTEGER NOT NULL,\n  card_message TEXT NOT NULL,\n  stamp        TEXT NOT NULL,\n  how          TEXT NOT NULL CHECK (how IN ('reply', 'next')),\n  created      TEXT NOT NULL,\n  outcome      TEXT CHECK (outcome IS NULL OR outcome IN ('started', 'refused', 'not-counted')),\n  task_id      TEXT,\n  finished     TEXT,\n  PRIMARY KEY (provider, event),\n  FOREIGN KEY (provider, event) REFERENCES chat_event(provider, id)\n);\nCREATE INDEX IF NOT EXISTS chat_typed_start_proposal ON chat_typed_start (proposal);\n";
+export declare const V159_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+export declare const V159_TABLES: readonly ["chat_typed_start"];
+/** The v159 migration's steps, in order (a test seam may stop after each). */
+export declare const V159_STEPS: readonly ["one-step-chat-tables", "one-step-chat-columns"];

package/dist/one-step-chat-schema.js

@@ -0,0 +1,37 @@
+/**
+ * v159: one-step start from chat (docs/plans/one-step-chat.md). Adds only: a saved row reads as it did. Kept beside
+ * nothing else so the update road can read the lists without the store, and so the version is easy to renumber.
+ *
+ * - `fast_preview.turn`: the lead turn a chat start's preview was prepared in (fast-start.ts prepareChatStart). Saved
+ *   rows read NULL; a chat preview without a turn is unusable, and the form's previews never have one.
+ * - `chat_typed_start` (C5): a typed yes to a Start card, recorded with the inbound message in the transaction that saves
+ *   it (typed-start.ts): which card it answered (the proposal and the chat message that carried it), the card's action
+ *   stamp then, how it was tied to the card (`reply` to it, or the `next` message after it), and once settled, the
+ *   outcome and the task it started. A new table: nothing saved changes. `proposal` is a plain number, not a reference:
+ *   the record has to outlive its card. Ending the chat deletes the card's proposal, and a yes already recorded for it
+ *   must still be answered by Toolroll ("didn't start anything") and never handed to the lead as a new message. Proposal
+ *   ids are never reused (AUTOINCREMENT), so a kept number can't come to name another card.
+ */
+export const V159_SCHEMA = `
+CREATE TABLE IF NOT EXISTS chat_typed_start (
+  provider     TEXT NOT NULL CHECK (provider IN ('telegram')),
+  event        TEXT NOT NULL,
+  proposal     INTEGER NOT NULL,
+  card_message TEXT NOT NULL,
+  stamp        TEXT NOT NULL,
+  how          TEXT NOT NULL CHECK (how IN ('reply', 'next')),
+  created      TEXT NOT NULL,
+  outcome      TEXT CHECK (outcome IS NULL OR outcome IN ('started', 'refused', 'not-counted')),
+  task_id      TEXT,
+  finished     TEXT,
+  PRIMARY KEY (provider, event),
+  FOREIGN KEY (provider, event) REFERENCES chat_event(provider, id)
+);
+CREATE INDEX IF NOT EXISTS chat_typed_start_proposal ON chat_typed_start (proposal);
+`;
+export const V159_ADDED_COLUMNS = Object.freeze({
+    fast_preview: { turn: { definition: "INTEGER", saved: "NULL" } },
+});
+export const V159_TABLES = Object.freeze(["chat_typed_start"]);
+/** The v159 migration's steps, in order (a test seam may stop after each). */
+export const V159_STEPS = Object.freeze(["one-step-chat-tables", "one-step-chat-columns"]);

package/dist/operate.d.ts

@@ -5,7 +5,7 @@ import { type TriggerIo } from "./flow-triggers.js";
 import { type GhRead } from "./nightly-github.js";
 import type { StepIo } from "./flow-steps.js";
 import type { FetchLike } from "./flow-share.js";
-import { type Store } from "./store.js";
+import { type Store, type Publication } from "./store.js";
 import { type LaptopSeams } from "./laptop-background.js";
 import { type DispatchAdapter } from "./sync.js";
 import { type ParentToRole, type RolePort, type UpRoleStart, type UpStartAuthority } from "./up-processes.js";
@@ -373,3 +373,29 @@ export declare function upLaptopPortCandidates(store: Store, fromSeam?: readonly
 /** The watch loop's background learning pass (docs/plans/learning-loops.md): advisory reads, each project at most every
  * 30 minutes through the plane's own gh. A failure here never reaches the loop: it is tried on the next pass. */
 export declare function refreshLearning(store: Store, now: () => Date, reads?: GhRead): Promise<void>;
+/** A project loop's share in its process's service beats. */
+export type ServiceBeatMember = {
+    context: Context;
+    progress: (line: string) => void;
+    /** This loop's reconciliation stands and it is not stopping: the fast CI pass runs only while every member's does. */
+    ciReady: () => boolean;
+};
+/** The delivery beat: web push and outgoing webhooks, off the build path. */
+export declare const DELIVERY_EVERY_MS = 5000;
+/** The fast CI beat: only while an opened pull request waits on its checks or its merge. */
+export declare const FAST_CI_EVERY_MS = 30000;
+/** The most pull requests one fast CI pass reads. */
+export declare const FAST_CI_LIMIT = 10;
+/**
+ * The opened pull requests the fast CI pass reads, oldest read or tried (`attempted`) first, at most `limit`: checks not settled (never read,
+ * running, or "none" shortly after an update), or green with its merge still waiting (a merge intent in flight, or a
+ * followed pull request not yet marked ready on its accepted commit). Failing and settled ones stay on the 5 minute pass.
+ */
+export declare function fastCiWaiting(store: Store, now: Date, limit?: number, attempted?: ReadonlyMap<number, string>): Publication[];
+/**
+ * Join this process's service beats: one delivery beat (web push and outgoing webhooks every 5 s, and at once when
+ * the wake moves with new notifications) and one fast CI beat (every 30 s, the existing `observeChecks` reader, only
+ * for pull requests that wait). One set per store, however many project loops join; the last to leave stops them.
+ * Opening a pull request stays on the tick path, and the 5 minute pass alone may set reconciliation ready.
+ */
+export declare function joinServiceBeats(member: ServiceBeatMember): () => Promise<void>;