toolroll 0.9.55 → 0.9.57

package/dist/{mate-progress.d.ts → lead-progress.d.ts}

@@ -1,7 +1,7 @@
 /** Live progress of one lead turn (chat streaming): what the lead is doing
  * and the reply as it is written. Nothing here is durable or authoritative —
  * the finished turn's saved message and cards remain the record. */
-export type MateProgress = {
+export type LeadProgress = {
     kind: "started";
     turn: number;
 } | {
@@ -19,33 +19,33 @@ export type MateProgress = {
     turn: number;
     step: number;
     id: string;
-    outcome: MateToolOutcome;
+    outcome: LeadToolOutcome;
 } | {
     kind: "text";
     turn: number;
     step: number;
     text: string;
 };
-export type MateToolOutcome = {
+export type LeadToolOutcome = {
     state: "succeeded";
 } | {
     state: "failed";
     reason: string;
 };
-export type MateLiveTool = {
+export type LeadLiveTool = {
     id: string;
     label: string;
 } & ({
     state: "running";
-} | MateToolOutcome);
+} | LeadToolOutcome);
 /** Keep tools as labels for older clients; toolCalls adds per-call outcomes. */
-export type MateLiveStep = {
+export type LeadLiveStep = {
     tools: string[];
-    toolCalls: MateLiveTool[];
+    toolCalls: LeadLiveTool[];
     text: string;
 };
-export declare function mateToolLabel(name: string): string;
-export declare function mateToolFailureReason(name: string, message: string): string;
+export declare function leadToolLabel(name: string): string;
+export declare function leadToolFailureReason(name: string, message: string): string;
 /** The `text` of a structured answer still being written, when the answer
  * opens with it (`{"text": "…`); null until then. Escapes are decoded, and
  * an escape cut off at the end is left for the next chunk. */

package/dist/{mate-progress.js → lead-progress.js}

@@ -38,7 +38,7 @@ const TOOL_LABELS = {
     remember: "Preparing a card for you to confirm",
     get_person: "Looking them up",
 };
-export function mateToolLabel(name) {
+export function leadToolLabel(name) {
     if (name in TOOL_LABELS)
         return TOOL_LABELS[name];
     return name.startsWith("propose_") ? "Preparing a card for you to confirm" : "Working";
@@ -64,8 +64,8 @@ const TOOL_FAILURE_REASONS = new Map([
     ["Task text cannot contain credentials.", "The task text contains a password or secret key."],
     ["that tool refused — the plane could not answer it right now", "Toolroll couldn't finish that step right now."],
 ]);
-export function mateToolFailureReason(name, message) {
-    return TOOL_FAILURE_REASONS.get(message) ?? `That step didn't work (${mateToolLabel(name)}).`;
+export function leadToolFailureReason(name, message) {
+    return TOOL_FAILURE_REASONS.get(message) ?? `That step didn't work (${leadToolLabel(name)}).`;
 }
 /** The `text` of a structured answer still being written, when the answer
  * opens with it (`{"text": "…`); null until then. Escapes are decoded, and

package/dist/lead-status.d.ts

@@ -105,7 +105,7 @@ export declare function repairStaleStatuses(store: Store, now: Date): {
  * `repos`: the only projects to report (a remote person limited to some projects); null is the whole installation.
  * A limited report counts only those projects' tasks and leaves out what belongs to the installation as a whole:
  * the release check, plan windows and the lead line are empty, never another project's. */
-export declare function installationStatus(store: Store, now: Date, viewer?: string | null, repos?: readonly string[] | null): InstallationStatus;
+export declare function installationStatus(store: Store, now: Date, viewer?: string | null, repos?: readonly string[] | null, root?: string): InstallationStatus;
 /** `limited`: a report over some projects (installationStatus's `repos`), which has no release check or plan windows to state. */
 export declare function renderInstallationStatus(status: InstallationStatus, limited?: boolean): string[];
 export declare function renderTaskWait(snapshot: TaskWaitSnapshot, outcome?: string): string;

package/dist/lead-status.js

@@ -183,7 +183,7 @@ export function repairStaleStatuses(store, now) {
  * `repos`: the only projects to report (a remote person limited to some projects); null is the whole installation.
  * A limited report counts only those projects' tasks and leaves out what belongs to the installation as a whole:
  * the release check, plan windows and the lead line are empty, never another project's. */
-export function installationStatus(store, now, viewer = currentActor()?.account ?? null, repos = null) {
+export function installationStatus(store, now, viewer = currentActor()?.account ?? null, repos = null, root) {
     const admitted = (row) => repos === null || typeof row["repo"] === "string" && repos.includes(row["repo"]);
     const access = { principal: "operator", repos, includeUnplaced: repos === null };
     const runningRows = store.handle.prepare(`SELECT run.id, run.role, run.phase, ref.id AS task_ref, ref.external_id AS task, ref.repo
@@ -262,7 +262,7 @@ export function installationStatus(store, now, viewer = currentActor()?.account
             observedAt: String(row["observed_at"]),
         })),
         signIn: pauses.map(one => ({ provider: one.provider, reason: signInReason(one), command: signInCommand(one), since: one.openedAt })),
-        tasks: workIndexPage(store, now, { ...access, viewer }, { limit: 8 }).items
+        tasks: workIndexPage(store, now, { ...access, viewer }, { limit: 8, ...(root === undefined ? {} : { root }) }).items
             .map(one => ({ task: one.rootId, title: one.title, headline: one.status.label, sentence: one.status.detail })),
         lead: repos !== null ? null : (() => {
             // Only the asker's own lead: another person's lead is never "Your lead".

package/dist/{mate-tools.d.ts → lead-tools.d.ts}

@@ -3,18 +3,18 @@ import { type Integration } from "./integrations.js";
 import type { AuthMode } from "./keys.js";
 import type { ProviderId } from "./provider.js";
 import { type ReviewSnapshot } from "./chat-review.js";
-import { type Store, type MateProposalKind, type MateTurnEvidence } from "./store.js";
+import { type Store, type LeadProposalKind, type LeadTurnEvidence } from "./store.js";
 import type { VerifiedApprover } from "./principal.js";
-import type { MateToolSchema } from "./converse.js";
+import type { LeadToolSchema } from "./converse.js";
 import { type AcceptanceCriterion } from "./scope.js";
 import { type ContractResult } from "./contracts/contract.js";
-export declare const MATE_MAX_PROPOSALS_PER_TURN = 5;
-export type MateToolContext = {
+export declare const LEAD_MAX_PROPOSALS_PER_TURN = 5;
+export type LeadToolContext = {
     store: Store;
     who: VerifiedApprover;
     now: Date;
     /** Records a proposal as `drafting` under the running turn; null when the turn may draft no more. */
-    draft: (kind: MateProposalKind, payload: Record<string, unknown>) => number | null;
+    draft: (kind: LeadProposalKind, payload: Record<string, unknown>) => number | null;
     /** The step this call runs in, and which decisions were read (by get_decision) at which step —
      * an answer may be proposed only for a decision read in an EARLIER step (v3 review, finding 6). */
     step: number;
@@ -27,7 +27,7 @@ export type MateToolContext = {
     evidenceRoot?: string;
     /** Records the screenshots this turn selected, under the turn, for a channel that delivers files; returns how many are recorded. Absent: nothing durable is kept. */
     /** Return the exact artifact ids reserved under this running turn, including earlier calls. */
-    selectEvidence?: (rows: readonly Omit<MateTurnEvidence, "turn" | "ordinal" | "createdAt">[]) => readonly number[];
+    selectEvidence?: (rows: readonly Omit<LeadTurnEvidence, "turn" | "ordinal" | "createdAt">[]) => readonly number[];
     /** How this surface delivers selected images: Telegram sends them as documents after the reply; every other surface shows identity only. */
     mediaDelivery?: "documents";
     /** The conversation and turn this call runs in: where a promise (commit_to) is reported. Absent: no promise can be kept. */
@@ -49,7 +49,7 @@ export type MateToolContext = {
     /** Records this turn's one question to its owner; false when it already asked one. Absent: this surface cannot ask. */
     ask?: (question: string, options: readonly string[]) => boolean;
 };
-export type MateToolResult = {
+export type LeadToolResult = {
     ok: true;
     body: unknown;
 } | {
@@ -57,18 +57,18 @@ export type MateToolResult = {
     message: string;
 };
 export { reportSummaryFor } from "./report-summary.js";
-export type MateViewContext = {
+export type LeadViewContext = {
     repos: readonly string[];
     names: readonly string[];
 };
 /** Scrub one string. Exact repo paths and their basenames go first (v13: no paths, no basenames), then shapes. */
-export declare function redactForMate(text: string, view: MateViewContext): string;
+export declare function redactForLead(text: string, view: LeadViewContext): string;
 /** The choke point: every string inside a tool result, recursively, scrubbed. */
-export declare function mateView<T>(value: T, view: MateViewContext): T;
-export declare function mateViewContextFor(store: Store, who: VerifiedApprover): MateViewContext;
+export declare function leadView<T>(value: T, view: LeadViewContext): T;
+export declare function leadViewContextFor(store: Store, who: VerifiedApprover): LeadViewContext;
 /** Project names are deliberate display metadata, not a general basename
  * exemption. Invalid, sensitive or account-identifying labels stay opaque. */
-export declare function projectLabelForMate(path: string, index: number, names: readonly string[]): string;
+export declare function projectLabelForLead(path: string, index: number, names: readonly string[]): string;
 /** The same text rule, for the gateway's proposals. */
 export declare function honestText(value: unknown, maxChars: number): value is string;
 export declare function readOptionalText(value: unknown, maxChars: number): string | null | undefined;
@@ -78,9 +78,9 @@ export declare function readTouches(value: unknown): string[] | null;
  * the argument did not even parse into a non-empty rubric. */
 export declare function readAcceptanceArg(value: unknown): AcceptanceCriterion[] | null;
 /** A lead tool as the model is shown it (its inputSchema derived from its contract) and as a call is read and run. */
-export type MateTool = MateToolSchema & {
-    read: (ctx: MateToolContext, raw: Record<string, unknown>) => ContractResult<Record<string, unknown>>;
-    handle: (ctx: MateToolContext, args: Record<string, unknown>) => MateToolResult;
+export type LeadTool = LeadToolSchema & {
+    read: (ctx: LeadToolContext, raw: Record<string, unknown>) => ContractResult<Record<string, unknown>>;
+    handle: (ctx: LeadToolContext, args: Record<string, unknown>) => LeadToolResult;
 };
 /** Replace every `repoIndex` with a `repo` label, recursively. */
 export declare function labelRepos<T>(value: T, label: (index: number) => string): T;
@@ -106,7 +106,7 @@ export declare const ISO_STAMP_RULE: RegExp;
  */
 export declare function agentsOver(store: Store, taskId: string, now: Date): Record<string, unknown> | null;
 /** The lead's tools, in the order the model is shown them: each one's inputSchema is its contract, derived. */
-export declare const MATE_TOOLS: MateTool[];
+export declare const LEAD_TOOLS: LeadTool[];
 /** A unified diff, file by file, with each file's added and removed lines. */
 export declare function patchFiles(patch: string): {
     path: string;
@@ -114,10 +114,10 @@ export declare function patchFiles(patch: string): {
     removed: number;
     text: string;
 }[];
-export declare const MATE_TOOL_SCHEMAS: MateToolSchema[];
-export declare function isMateTool(name: string): boolean;
+export declare const LEAD_TOOL_SCHEMAS: LeadToolSchema[];
+export declare function isLeadTool(name: string): boolean;
 /** Scrub every result. Only list_repos then adds validated display metadata
  * from the same admitted project list; no user-authored result gets an exemption. */
-export declare function executeMateTool(ctx: MateToolContext, name: string, args: Record<string, unknown>, view?: MateViewContext): MateToolResult;
+export declare function executeLeadTool(ctx: LeadToolContext, name: string, args: Record<string, unknown>, view?: LeadViewContext): LeadToolResult;
 /** Bytes of a serialized tool result as it will sit inside the request body. */
 export declare function toolResultBytes(text: string): number;