toolroll 0.9.104 → 0.9.105

package/dist/releases.d.ts

@@ -1,94 +0,0 @@
-/**
- * Knowing, calmly, when a newer Toolroll exists.
- *
- * At most once a day one anonymous GET asks the npm registry for the latest
- * version, and one more reads that version's GitHub release notes (the body
- * only). Nothing identifies this installation: no telemetry, no id, no
- * query string. The answer is cached in a small JSON file beside the
- * database; offline or any other failure is silent and changes nothing.
- * TOOLROLL_NO_UPDATE_CHECK=1 or the switch on Settings → Updates turns the
- * check off entirely.
- */
-import type { Store } from "./store.js";
-export declare const RELEASE_CACHE_FILE = "latest-release.json";
-/** Holds "off" while a person has switched the daily check off on Settings → Updates. */
-export declare const UPDATE_SWITCH_FILE = "update-check";
-export declare const RUNNER_VERSIONS_FILE = "runner-versions.json";
-export declare const CHECK_EVERY_MS: number;
-export declare const CHECK_TIMEOUT_MS = 5000;
-/** The npm registry `toolroll update` downloads releases from. */
-export declare const REGISTRY = "https://registry.npmjs.org";
-export declare const REGISTRY_URL = "https://registry.npmjs.org/toolroll/latest";
-export declare const RELEASES_PAGE = "https://github.com/ap9000/toolroll/releases/tag/";
-export type Release = {
-    version: string;
-    notes: string;
-    url: string;
-    security: boolean;
-};
-export type ReleaseIo = {
-    fetch?: typeof fetch;
-    now?: () => Date;
-    env?: Record<string, string | undefined>;
-};
-/** Off by the environment (it wins) or by the Settings switch. */
-export declare function updateChecksOff(env: Record<string, string | undefined>, dir: string): {
-    off: boolean;
-    byEnv: boolean;
-};
-export declare function setUpdateChecks(dir: string, on: boolean): void;
-/** What the last check found, whenever it ran; null when none has succeeded. Never touches the network. */
-export declare function cachedRelease(dir: string): Release | null;
-/**
- * The latest published release, checked at most once a day. Returns what the
- * cache knows while it is fresh, asks again once it is a day old, and on any
- * failure keeps what it knew before (null when it knew nothing). Never throws.
- */
-export declare function latestRelease(dir: string, io?: ReleaseIo): Promise<Release | null>;
-/** Notes that mention "Security" mark a security release. */
-/** A release marks itself as a security release with a line or heading that starts with "Security" (for example
- * "## Security" or "- **Security fix.**"), not by mentioning the word ("no security changes"). */
-export declare function isSecurityRelease(notes: string): boolean;
-/** a > b for dotted versions; a pre-release sorts before its release. */
-export declare function isNewer(a: string, b: string): boolean;
-/** The release worth mentioning: newer than `current`, else null. */
-export declare function newerRelease(release: Release | null, current: string): Release | null;
-/** The one status line, only when a newer release exists. */
-export declare function updateLine(release: Release | null, current: string, updateCommand: string): string | null;
-/**
- * A security release tells each instance operator once per version, through
- * the outbox and addressed to them (like a sign-in pause): only someone at
- * this computer can update it. Returns how many messages were queued.
- */
-export declare function notifySecurityRelease(store: Store, release: Release | null, current: string, updateCommand: string, now: Date): number;
-/** Each runner's Toolroll version, as it last said at start. */
-export type RunnerVersion = {
-    runner: string;
-    version: string;
-    at: string;
-};
-export declare function recordRunnerVersion(dir: string, runner: string, version: string, now: Date): void;
-export declare function runnerVersions(dir: string): RunnerVersion[];
-/**
- * The console's background check: at start and then hourly (the daily limit
- * is latestRelease's own), and a security release notifies operators.
- */
-export declare function startUpdateChecks(store: Store, dir: string, current: string, updateCommand: string, io?: ReleaseIo & {
-    everyMs?: number;
-}): () => void;
-/** The latest version, asked of npm now: for an explicit update (the command, Check now), not the once-a-day
- * notice, so neither its cache nor its switch applies. Throws with npm's own reason. */
-export declare function latestVersionNow(io?: {
-    fetch?: typeof fetch;
-}): Promise<{
-    version: string;
-}>;
-/** What a release says about itself in one line ("Release 0.9.9: lighter tests, cleaner status"), when its notes
- * have such a line; null otherwise. */
-export declare function releaseSummary(notes: string, version: string): string | null;
-/**
- * A deploy says one thing in chat: "Toolroll 0.9.9 is live." (with the release's own one-line summary when its
- * notes have one). Once per version, addressed to each instance operator, and only when a worker on this
- * computer last ran an older version: a fresh install is not news. Call before recording this runner's version.
- */
-export declare function notifyVersionLive(store: Store, dir: string, version: string, now: Date): number;

package/dist/remote-audit.d.ts

@@ -1,79 +0,0 @@
-import type { ApiTokenRow, Store } from "./store.js";
-export declare const AUDIT_SOURCES: readonly ["api", "mcp"];
-export type AuditSource = typeof AUDIT_SOURCES[number];
-export type AuditOutcome = "ok" | "refused" | "error";
-export declare const AUDIT_LIMIT: {
-    readonly default: 20;
-    readonly max: 100;
-};
-export type AuditFilters = {
-    person: string | null;
-    token: string | null;
-    source: AuditSource | null;
-    since: string | null;
-};
-/** One remote action. `kind` says whether a person's CLI ran a command or their agent called a tool over MCP. */
-export type AuditAction = {
-    id: number;
-    at: string;
-    person: string;
-    token: string | null;
-    source: AuditSource;
-    kind: "command" | "tool";
-    /** The command row (`task show`), or for a tool call the tool's name when the line recorded it. */
-    name: string;
-    command: string;
-    tool: string | null;
-    repo: string | null;
-    taskId: string | null;
-    outcome: AuditOutcome;
-    /** A refusal's stable reason (`read-only`, `not-found`, ...), never free text. */
-    reason: string | null;
-};
-/**
- * Who is reading. `self` null: the machine's own owner, reading the database here. Otherwise a person:
- * `everyone` when they approve; `repos` their project ceiling (null: every project); `unplaced` whether lines in no
- * project (refused before a project was known) are theirs to see for other people.
- */
-export type AuditReader = {
-    self: string | null;
-    everyone: boolean;
-    repos: readonly string[] | null;
-    unplaced: boolean;
-};
-export declare const OWNER_READER: AuditReader;
-export type AuditPage = {
-    ok: true;
-    actions: AuditAction[];
-    nextCursor: string | null;
-    limit: number;
-} | {
-    ok: false;
-    reason: "not-found";
-    message: string;
-};
-/** The old final words, in the vocabulary people read. Anything unrecognized reads as an error, never as ok. */
-export declare function auditOutcome(outcome: string): AuditOutcome | null;
-/** `7d` → the instant that many days before `now`; null for anything else (no zero, sign, fraction or other unit). */
-export declare function sinceOf(value: string, now: Date): string | null;
-export declare const cursorOf: (value: string) => number | null;
-/**
- * A line's token, tool and reason. The detail is `token <name>` then ` · `-separated parts: the token name is the
- * longest of this person's token names (or ids, for a line written before the token was proved) that matches up to a
- * separator, since a name may itself contain ` · `. Unmatched text is never echoed.
- */
-export declare function readDetail(detail: string | null, tokens: readonly Pick<ApiTokenRow, "id" | "name">[]): {
-    token: string | null;
-    tool: string | null;
-    reason: string | null;
-};
-/**
- * One page of remote actions, newest first, keyed by entry id so new lines never shift an older page. The reader's
- * visibility and every filter are applied before the page is cut; the token filter is an exact name match.
- */
-export declare function remoteAudit(store: Store, reader: AuditReader, filters: AuditFilters, page?: {
-    limit?: number;
-    before?: number | null;
-}): AuditPage;
-/** A token's standing, for People. */
-export declare function tokenStatus(token: Pick<ApiTokenRow, "revokedAt" | "expiresAt">, now: Date): "active" | "expired" | "revoked";

package/dist/remote-command.d.ts

@@ -1,45 +0,0 @@
-import { type CommandFlag } from './surface.js';
-export type RemoteMode = 'yes' | 'no' | 'step-up';
-export type RemoteCommand = {
-    invocation: string;
-    mode: RemoteMode;
-    mutation: string;
-    flags?: readonly Pick<CommandFlag, 'name' | 'takesValue'>[];
-};
-export type RemoteCommandLookup = (argv: readonly string[]) => RemoteCommand | null;
-export declare const STEP_UP_MESSAGE = "approve in the console or chat";
-type PathPolicy = 'inline' | 'refuse';
-export type RemotePathArgument = {
-    invocation: string;
-    argument: {
-        flag: string;
-    } | {
-        position: number;
-        name: string;
-        rest?: true;
-    };
-    policy: PathPolicy;
-    literal?: 'json' | 'url';
-};
-/**
- * Filesystem arguments audited against operate.ts, flows-cli.ts and cli.ts's local dispatchers.
- * Keep this inventory command-specific: --file runs a project executable for scripts, but is a
- * boolean for template apply; --to is a directory for link and a date for ledger export.
- * Project selectors (--repo), scope globs (--touches/--paths) and saved IDs are not input files;
- * their authority belongs to runOperateAs. Local installers' explicit destinations are refused.
- * '*' is reserved for the credentials/database and cli.ts's output redirection, on every command.
- */
-export declare const REMOTE_PATH_ARGUMENTS: readonly RemotePathArgument[];
-type FileProblem = {
-    problem: string;
-    code: 'local-only-flag' | 'server-path' | 'missing-file' | 'invalid-arguments';
-};
-/**
- * Parse once using declared arity, so a flag's value cannot be mistaken for another flag or a
- * file positional. Unknown arity fails closed. File keys and argv stay exactly as typed.
- * All failures describe the argument slot, never a supplied path, credential or other value.
- */
-export declare function fileArguments(argv: readonly string[], row: RemoteCommand): string[] | FileProblem;
-/** The longest declared invocation named by the leading words. Missing remote metadata means local only. */
-export declare const contractRow: RemoteCommandLookup;
-export {};

package/dist/remote-destination.d.ts

@@ -1,36 +0,0 @@
-export type Lookup = (host: string) => Promise<readonly string[]>;
-export declare const lookupAll: Lookup;
-export type Destination = {
-    scheme: "https" | "ssh";
-    host: string;
-    port: number;
-    literal: boolean;
-};
-export type Pin = {
-    /** `-c` settings for git, or nothing for ssh. */
-    gitArgs: string[];
-    /** Environment on top of remote-main.ts's ENV. */
-    env: Record<string, string>;
-    /** The proxy's host name when the read goes through the operator's proxy. */
-    proxy: string | null;
-};
-export type PinResult = {
-    ok: true;
-    pin: Pin;
-} | {
-    ok: false;
-    why: string;
-};
-/** Whether an address is loopback, unspecified, link-local, or an IPv4-mapped or NAT64 form of these. */
-export declare function addressRefused(address: string): boolean;
-/** The host, effective port and scheme a recorded URL connects to; null when it can't be read. The caller has already
- * passed remoteUrlProblem. Node's URL parser normalizes every spelling of a literal host. */
-export declare function destinationOf(url: string): Destination | null;
-/** Whether curl would skip the proxy for this host; "unknown" when an entry can't be decided. */
-export declare function noProxyApplies(noProxy: string, host: string): boolean | "unknown";
-/**
- * Decide the route and pin it. `env` is what git will see (the names remote-main.ts's ENV_ALLOWLIST passes). ssh never
- * uses a proxy. Through a proxy, the proxy's own address is checked and pinned; the operator's proxy then chooses the
- * final destination, and the caller says so.
- */
-export declare function pinDestination(url: string, env: Readonly<Record<string, string | undefined>>, lookup?: Lookup): Promise<PinResult>;

package/dist/remote-exec.d.ts

@@ -1,38 +0,0 @@
-import { type ConnectOptions } from './connect-cli.js';
-import { type CliRequest } from './cli-http.js';
-import { type RemoteCommandLookup } from './remote-command.js';
-export { contractRow, STEP_UP_MESSAGE, type RemoteMode } from './remote-command.js';
-export type RemoteExecOptions = ConnectOptions & {
-    sleep?: (milliseconds: number, signal: AbortSignal) => Promise<void>;
-    cwd?: string;
-    /** Raw output streams; remote bytes are written exactly as the server returned them. */
-    stdout?: (chunk: string) => void;
-    stderr?: (chunk: string) => void;
-    /** Injected by tests: the contract row lookup (default: COMMAND_GUIDE's `remote` field). */
-    modeOf?: RemoteCommandLookup;
-};
-type Answer = {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-};
-export type Outcome = {
-    kind: 'answer';
-    answer: Answer;
-} | {
-    kind: 'refused';
-    status: number;
-    code: string;
-    message: string;
-} | {
-    kind: 'unconfirmed';
-};
-/** One request, never retried. */
-export declare function postCli(origin: string, token: string, request: CliRequest, options: RemoteExecOptions): Promise<Outcome>;
-/**
- * null: run locally with argv unchanged. `{ local }`: run locally with this argv (`--local` removed).
- * A number: the command ran remotely (or was refused before sending) and this is its exit code.
- */
-export declare function maybeRunRemoteCommand(argv: readonly string[], options?: RemoteExecOptions): Promise<number | {
-    local: string[];
-} | null>;

package/dist/remote-main.d.ts

@@ -1,111 +0,0 @@
-import { type ExecResult } from "./exec.js";
-import type { BoundedOptions, BoundedResult, BoundedRunner } from "./bounded-spawn.js";
-import type { Pin } from "./remote-destination.js";
-import type { Store } from "./store.js";
-import type { Runner } from "./worktree.js";
-/** What the private directory's git may see of this process's environment: nothing that names a repository, an
- * object store or config. The fixed settings below go on top. Teardown git (teardown-git.ts) uses the same. */
-export declare const ENV_ALLOWLIST: string[];
-export declare const ENV: Record<string, string>;
-/** The only credential helper https may use: the system keychain on macOS; elsewhere none, so a private https remote
- * fails closed instead of asking. */
-export declare const CREDENTIAL_HELPER: string;
-export type RemoteUrl = {
-    kind: "network";
-    url: string;
-};
-/**
- * A URL Toolroll may fetch remote main from: https or ssh (either form). Local paths, file URLs and loopback hosts
- * (this machine is where builds run) are always refused. Remote helpers (ext::, fd:: and the like), plain http and
- * git:// (no authentication), relative paths, embedded passwords and anything odd are refused.
- */
-export declare function parseRemoteUrl(url: string): RemoteUrl | {
-    why: string;
-};
-/** Why a recorded URL may not be used as the trusted remote; null when it may. */
-export declare function remoteUrlProblem(url: string): string | null;
-export type RemoteGit = (args: readonly string[]) => Promise<ExecResult>;
-export type RemoteMain = {
-    url: string;
-    /** The private Git directory the read fetched into (plane-owned; gone at `close`). */
-    gitDir: string;
-    /** The commit the recorded remote's main is at, as fetched just now. */
-    main: string;
-    /** Git in the private directory, hardened as above. */
-    git: RemoteGit;
-    /** Bring this exact commit (with its history) from the project by fetch, for a content comparison. */
-    bring: (repo: string, head: string) => Promise<boolean>;
-};
-export type RemoteMainRead = {
-    ok: true;
-    remote: RemoteMain;
-} | {
-    ok: false;
-    why: string;
-    reason?: "moved";
-};
-/** What every reader of a remote main shows when its address redirects. The target is remote-supplied text: it is never
- * shown, stored or followed, and the new remote is never adopted automatically. */
-export declare const REMOTE_MOVED = "The repository moved: its address now redirects. Update the project's remote in Toolroll (Settings \u2192 Projects), then try again.";
-/** git's words for a refused redirect (http.followRedirects=false), read for the status code alone. */
-export declare function redirected(stderr: string): boolean;
-/**
- * One pass's reads of recorded remotes. Every `read` fetches again (the pre-teardown re-check is never older than
- * the teardown); a project's private directory lasts until `close`, so a fetch after the first only brings what
- * changed. Close removes every directory.
- */
-export declare class RemoteMains {
-    private readonly store;
-    private readonly runner;
-    private readonly scratch;
-    private readonly helper;
-    private readonly dirs;
-    constructor(store: Store, runner: Runner | undefined, scratch: string, helper?: string);
-    private exec;
-    /** Nothing but fetched objects decides: a private directory that grew alternates, grafts or shallow state is
-     * not trusted. */
-    private clean;
-    private dirFor;
-    read(repo: string): Promise<RemoteMainRead>;
-    close(): void;
-}
-export declare const MAP_FETCH_LIMITS: {
-    readonly timeoutMs: 120000;
-    readonly memoryBytes: number;
-    readonly diskBytes: number;
-    readonly fileBytes: number;
-    readonly maxStderr: number;
-};
-export type MapGitOptions = {
-    helper?: string;
-    extra?: readonly string[];
-};
-/** Git in a private directory under the map's rules: the same hardening as `RemoteMains`, plus the pin. */
-export declare function mapGitArgs(dir: string, pin: Pin, args: readonly string[], options?: MapGitOptions): string[];
-/** The environment for it: exactly the allowed names, the fixed settings, and the pin's. */
-export declare function mapGitEnv(pin: Pin, from?: Readonly<Record<string, string | undefined>>): Record<string, string>;
-export declare function initPrivateDir(dir: string, bounded: BoundedRunner): Promise<BoundedResult>;
-export type MapPeek = {
-    ok: true;
-    commit: string | null;
-} | {
-    ok: false;
-    why: string;
-    reason?: "moved";
-};
-/** The commit the recorded remote's main is at, without fetching: null when the remote has no `main`. */
-export declare function peekMain(url: string, dir: string, pin: Pin, bounded: BoundedRunner, helper?: string): Promise<MapPeek>;
-/** A depth-1 private folder is clean when it holds only what the fetch made: a `shallow` file naming exactly the fetched
- * commit, and no grafts or alternates. */
-export declare function shallowClean(dir: string, commit: string): boolean;
-export type MapFetch = {
-    ok: true;
-    commit: string;
-    enforced: "system" | "checked";
-} | {
-    ok: false;
-    why: string;
-    reason?: "moved";
-};
-/** Fetch main at depth 1 into `dir`, under the map's limits. `onStart` records the spawn for crash cleanup. */
-export declare function readShallowMain(url: string, dir: string, pin: Pin, bounded: BoundedRunner, onStart?: BoundedOptions["onStart"], helper?: string): Promise<MapFetch>;

package/dist/remote-run.d.ts

@@ -1,20 +0,0 @@
-/** A principal re-proved against the store for one remote run. */
-export type RemoteRun = {
-    readonly account: string;
-    readonly scope: "read" | "act";
-    readonly tokenName: string;
-    readonly source: "api" | "mcp";
-    /** What credential lookups hand back for this person in place of a password: unguessable, this run only. */
-    readonly secret: string;
-    /** Whether the person may use `repo` now (their token's projects and their account's current access). */
-    readonly allows: (repo: string | null) => boolean;
-    /** The projects listings and task references may disclose (remoteLensOf); null shows every project. */
-    readonly lens: readonly string[] | null;
-    /** Called with the task a remote `task add` filed (or replayed), so its action history names it. */
-    readonly noteTask: (taskId: string) => void;
-    /** Files the caller sent, keyed by the argument that names them. Nothing else is read for input. */
-    readonly files: Readonly<Record<string, string>>;
-};
-/** The remote run this code is inside, or null for every local command. */
-export declare function activeRemote(): RemoteRun | null;
-export declare function withRemote<T>(run: RemoteRun, fn: () => T): T;

package/dist/remote.d.ts

@@ -1,67 +0,0 @@
-/**
- * The half of "in flight" that is not on this machine.
- *
- * Branches come off the local filesystem in milliseconds. Pull requests and
- * issues are a network round trip per repository, and that difference is the
- * whole reason this is a separate module with a budget attached rather than
- * three more lines inside discovery.
- *
- * An earlier draft kept these behind their own command precisely because of
- * the cost, and the milestone still asks for one command that shows every
- * branch, pull request, and issue in flight. Both concerns are real, so this
- * follows the rule the rest of the tool already uses for expensive reads:
- * price it, bound it, and **say what you withheld**. Twenty-four repositories
- * on hotel wifi will not hang; they will come back with what fitted in the
- * budget and a line naming what did not.
- *
- * The budget is for the whole phase, not per repository. A per-call timeout
- * bounds the worst case at repos × timeout, which for a machine full of work
- * is not a bound anybody would recognise as one.
- */
-import { type Pull } from "./pulls.js";
-import { type BackendTask, type Runner } from "./backend.js";
-export type RemoteState = {
-    pulls: Pull[];
-    issues: BackendTask[];
-    /**
-     * Whether each read actually succeeded.
-     *
-     * An empty list means nothing without these. A repository with issues
-     * switched off, one whose token expired, and one that genuinely has no open
-     * issues all produce `issues: []`, and only the first two are a reason to
-     * stop trusting the number above it.
-     */
-    pullsRead: boolean;
-    issuesRead: boolean;
-    /** What could not be read, in words. */
-    problems: string[];
-    /** True when the budget ran out before this repository was asked. */
-    skipped: boolean;
-};
-export type RemoteOptions = {
-    runner?: Runner;
-    /** Total wall clock for the whole phase, not per repository. */
-    budgetMs?: number;
-    concurrency?: number;
-    now?: () => number;
-    issueLimit?: number;
-};
-/**
- * Long enough for a dozen repositories on an ordinary connection, short enough
- * that somebody who typed a command still feels like it answered.
- */
-export declare const DEFAULT_BUDGET_MS = 15000;
-/** GitHub is the bottleneck here, not the local machine. */
-export declare const DEFAULT_REMOTE_CONCURRENCY = 6;
-export declare const EMPTY: RemoteState;
-/**
- * Read pull requests and issues for each repository, within one budget.
- *
- * Only repositories that look like they are on a remote are asked; a local-only
- * repo has no pull requests by definition, and spending part of a shared budget
- * to be told so would come out of the repositories that do.
- */
-export declare function readRemote(repos: readonly {
-    path: string;
-    remoteUrl: string | null;
-}[], options?: RemoteOptions): Promise<Map<string, RemoteState>>;

package/dist/render.d.ts

@@ -1,64 +0,0 @@
-/**
- * Turning snapshots into something worth reading.
- *
- * Pure string building. The clock is a parameter rather than a call, so the
- * output is deterministic under test and the same report can be re-rendered
- * later against the time it was taken.
- */
-import type { RepoSnapshot } from "./discover.js";
-import type { TrackingState } from "./git.js";
-import { type BackendKind, type Detection } from "./graph.js";
-import { type Pull } from "./pulls.js";
-import type { RemoteState } from "./remote.js";
-export type ReportOptions = {
-    now: Date;
-    /** Where the scan looked, used only to make the empty result actionable. */
-    roots?: readonly string[];
-    maxBranches?: number;
-    /**
-     * Pull requests and issues per repository path. Undefined means they were
-     * never read — which the report says out loud rather than showing zeroes,
-     * because "none" and "did not look" are different answers.
-     */
-    remote?: RemoteMap;
-};
-export type RemoteMap = ReadonlyMap<string, RemoteState>;
-export declare const DEFAULT_MAX_BRANCHES = 6;
-export declare function formatAge(iso: string, now: Date): string;
-export declare function formatTrack(track: TrackingState): string;
-export declare function renderReport(snapshots: readonly RepoSnapshot[], options: ReportOptions): string;
-/** One repository's open pull requests, as read. */
-export type PullGroup = {
-    repo: string;
-    pulls: readonly Pull[];
-    problems: readonly string[];
-};
-export type PullsOptions = {
-    now: Date;
-    staleDays?: number;
-};
-/**
- * How long since anything happened. Phrased as idleness rather than age
- * because a pull request opened in May and discussed yesterday is not old in
- * any sense the operator cares about.
- */
-export declare function formatIdle(iso: string, now: Date): string;
-/**
- * Grouped by whose move it is, because that is the only question being asked.
- * Drafts and running builds are counted but not listed — nobody is blocked on
- * them, and a report that lists everything is the attention problem it was
- * written to solve.
- */
-export declare function renderPulls(groups: readonly PullGroup[], options: PullsOptions): string;
-/**
- * What work graph is already here.
- *
- * The recommended backend is marked with a pointer and nothing else is, because
- * the one thing this report must not read as is a menu of things already
- * switched on. Every line ends by saying what is *not* authorized, since
- * detection is not authorization and a report that omitted that would be
- * inviting exactly the wrong conclusion.
- */
-export declare function renderGraph(detections: readonly Detection[], options?: {
-    enrolled?: BackendKind;
-}): string;

package/dist/reply-shape.d.ts

@@ -1,106 +0,0 @@
-/**
- * The lead's voice, enforced: every chat surface (console, terminal, Telegram, Slack, Discord, Teams) runs a reply
- * through here before it is sent. The contract asks for plain text; this makes it so, without changing what the reply
- * says. Shaping is channel-neutral and idempotent — it yields a small canonical form (`**anchor**`, `[label](url)`,
- * `code`) — and each channel renders that form in its own format.
- *
- * - Markdown headers become plain lines.
- * - Bold stays on at most three short anchors; the rest is plain.
- * - Bare URLs become labelled links, named from their target: "the task", "the result", "Settings → Lead", else the host.
- * - Internal ids (run #12, digests, r1-style project ids) are removed unless the owner asked for them. When a reply names
- *   several of one kind (two runs, two projects), they stay: two items must never read the same.
- * - Runs of blank lines collapse to one.
- * Code (inline or fenced) is left exactly as written.
- */
-import { type Html } from "./html.js";
-export type ReplyChannel = "console" | "terminal" | "telegram" | "slack" | "discord" | "teams";
-export type ShapeOptions = {
-    /** The owner's message this reply answers: when it asks for ids, the ids stay. */
-    asked?: string;
-    /** This app's own origin (or origins: the console's address and its public one). Only a link there is named as the
-     * app's page ("the task"); every other link is named by its real host, whatever label the model wrote, so a reply can
-     * never dress a foreign link up as ours. */
-    appOrigin?: string | readonly (string | null)[] | null;
-};
-export declare const BOLD_ANCHORS = 3;
-/** A bold anchor is a few words, not a sentence. */
-export declare const BOLD_ANCHOR_CHARS = 40;
-/** Did the owner ask for ids (an id, a digest, a hash, a run number or a project's r-number)? */
-export declare function askedForIds(asked: string | undefined): boolean;
-/** What a link is called, from where it goes: the app's own task, result and settings pages by name (only on `appOrigin`); anything else by host. */
-export declare function linkLabel(url: string, appOrigin?: ShapeOptions["appOrigin"]): string;
-/**
- * The canonical shaped reply: plain lines, at most three bold anchors, labelled links, no internal ids unless asked
- * (or unless several of a kind would otherwise read the same), single blank lines. Idempotent: shaping a shaped reply
- * changes nothing.
- */
-export declare function shapeReply(text: string, options?: ShapeOptions): string;
-/**
- * A reply still being written, shaped with the final reply's presentation policy (docs/plans/responsive-chat.md §2.2),
- * except that ids are dropped unless the owner asked for them: whether a reply names several of a kind isn't known
- * until it ends, so a prefix never keeps them on that ground. Presentation, not redaction.
- */
-export declare function shapeReplyPrefix(text: string, options?: ShapeOptions): string;
-/** The first window of a shaped text of at most `size` characters, cut where a part would be (never inside code, a link,
- * a bold anchor or an emoji's two halves). A single link longer than the window stays whole, so the caller measures. */
-export declare function shapedWindow(shaped: string, size: number): string;
-/**
- * A long reply split into parts of at most `size` characters, then each part shaped: the cut is made on the reply as
- * written, at a paragraph or line where possible and never inside code, a link or a bold anchor, so no part carries
- * half of one. The parts share one bold budget and one rule for ids, as if the reply were shaped whole. `measure` is
- * how long a shaped part is once the channel renders it (its own link and escape format): a part that renders past
- * `size` is cut again, smaller. Only a single link longer than a part can exceed it, and it is never cut.
- */
-export declare function shapeReplyParts(text: string, size: number, options?: ShapeOptions, measure?: (shaped: string) => number): string[];
-export type ReplyPiece = {
-    kind: "text";
-    text: string;
-} | {
-    kind: "bold";
-    text: string;
-} | {
-    kind: "code";
-    text: string;
-} | {
-    kind: "link";
-    label: string;
-    url: string;
-};
-/** A shaped reply as pieces: plain text, bold anchors, inline code and labelled links. Fenced code stays text. */
-export declare function replyPieces(shaped: string): ReplyPiece[];
-/** Discord's presentation syntax, escaped; mentions are broken so nothing pings. */
-export declare const discordPlain: (text: string) => string;
-/** One line of a shaped reply as console HTML (the console lays out paragraphs and lists itself). */
-export declare function replyHtmlInline(shapedLine: string): Html;
-/** A shaped reply in a channel's own text format (Telegram's formatting rides entities: see `telegramReply`). */
-export declare function renderReply(shaped: string, channel: ReplyChannel): string;
-export type TelegramEntity = {
-    type: "bold" | "code";
-    offset: number;
-    length: number;
-} | {
-    type: "text_link";
-    offset: number;
-    length: number;
-    url: string;
-};
-/** A shaped reply for Telegram: plain text plus entities (bold anchors, code, labelled links). Offsets are UTF-16, as JS strings are. */
-export declare function telegramReply(shaped: string): {
-    text: string;
-    entities: TelegramEntity[];
-};
-/** Shape and render in one step, for a surface that sends the reply as text. */
-export declare function voiceReply(text: string, channel: ReplyChannel, options?: ShapeOptions): string;
-/**
- * The words in a reply that say something is being sent or attached ("I've attached the log", "here's the
- * screenshot"), or null. A claim needs an attachment noun and a send verb; one whose content the reply lists itself
- * ("I've included the files I changed: a.ts") is not a claim.
- */
-export declare function deliverableClaim(text: string): string | null;
-/** Does the reply carry the thing itself: a link, or content quoted in a code block? */
-export declare function replyCarriesDeliverable(text: string): boolean;
-export declare const NOTHING_ATTACHED = "I couldn't attach that to this reply.";
-/** The reply without its claims of an attachment, said plainly once; whatever a claim listed stays; never the claim alone. */
-export declare function dropDeliverableClaims(text: string): string;
-/** The one repair step's words to the lead: attach it, or drop the claim. */
-export declare function deliverableRepair(claim: string): string;