toolroll 0.9.104 → 0.9.105

package/dist/stream-scope.d.ts

@@ -1,18 +0,0 @@
-/**
- * Whose event is this (docs/plans/agents-view.md §2.1): Claude's `stream-json` interleaves the session's own events
- * with its subagents', and a subagent's carry `parent_tool_use_id` (the parent's Task/Agent call). Only the session's
- * own events drive its lifecycle, identity and accounting: the receipt, the primary result, the saved session, live
- * input, the turn and activity marks, and the billing observations. A subagent's init, words or result prove nothing
- * about the main query.
- *
- * Unknown shapes fail toward "not the parent": any present, non-null `parent_tool_use_id` (an id, `""`, a number)
- * makes the event a subagent's. Pure, no imports: every reader shares this one copy.
- */
-/** The session's own event: `parent_tool_use_id` absent or null. */
-export declare function topLevelEvent(event: Record<string, unknown>): boolean;
-/**
- * The main query's `result`, selected structurally (finding 10): top-level, and its `origin` absent, null or
- * `{kind: "human"}`. An allowlist, so a background task's result, a subagent's result, or any future origin kind is
- * never the run's envelope.
- */
-export declare function primaryResultEvent(event: Record<string, unknown>): boolean;

package/dist/structured-output.d.ts

@@ -1,57 +0,0 @@
-/**
- * Shared structured-output recovery primitives for planner and reviewer.
- *
- * The normalizer is deliberately syntax-only. It may remove transport
- * wrappers that carry no meaning; it never extracts a likely-looking object
- * from prose, fills a field, truncates a note, changes an id, or chooses a
- * judgement. Semantic repair belongs to the same agent session and remains
- * subject to the phase's strict parser.
- */
-import type { Store } from "./store.js";
-export declare const STRUCTURED_REPAIR_ATTEMPTS = 2;
-export declare const STRUCTURED_REPAIR_MAX_TURNS = 4;
-export declare const STRUCTURED_REPAIR_TIMEOUT_MS: number;
-/** Native parsing counts UTF-16 code units. A shorter writing target keeps
- * notes concise without imposing a second, stricter transport contract. */
-export declare const REVIEW_OUTPUT_LIMITS: {
-    readonly comments: 40;
-    readonly criteria: 12;
-    readonly note: 500;
-    readonly path: 300;
-};
-export declare const REVIEW_NOTE_CODE_POINTS: number;
-export type StructuredNormalization = {
-    text: string;
-    changed: boolean;
-    changes: readonly ("bom" | "whitespace" | "json-fence" | "json-string")[];
-};
-/** Strip only unambiguous, whole-payload wrappers. */
-export declare function normalizeStructuredJson(raw: string): StructuredNormalization;
-export type StructuredAttemptPhase = "planner" | "reviewer" | "builder-proof";
-/**
- * Keep the exact emitted payload unless it contains a high-confidence secret
- * shape, in which case the same line-redaction discipline as terminal diffs
- * keeps the audit record useful without creating a second credential copy.
- */
-export declare function storeStructuredAttempt(store: Store, root: string, logicalRunId: number, args: {
-    phase: StructuredAttemptPhase;
-    attempt: number;
-    authoredRunId: number;
-    raw: string | Buffer;
-    /** Exact source size when `raw` is an intentionally bounded prefix. */
-    sourceBytesOriginal?: number;
-    /**
-     * The exact bytes passed the phase parser and every eligibility gate the
-     * caller had checked when it captured them. This is never the workflow's
-     * final acceptance: custody, evidence bindings, or the atomic finalizer
-     * may still refuse them. The run's terminal outcome is that authority.
-     */
-    accepted: boolean;
-    normalized: boolean;
-    now: Date;
-}): number;
-/** JSON-quote parser errors so agent-authored ids/paths remain data. */
-export declare function validationErrorsJson(problems: readonly {
-    reason: string;
-    message?: string;
-}[]): string;

package/dist/style-asset.d.ts

@@ -1,7 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-/** Only application-owned CSS belongs here. Never pass rendered HTML or
- * session data: this asset is public, immutable and compressed. */
-export declare function styleAsset(css: string): {
-    path: string;
-    serve(request: IncomingMessage, response: ServerResponse): void;
-};

package/dist/subagent-admin.d.ts

@@ -1,53 +0,0 @@
-/**
- * Looking after subagents (v92): making one from a template or a soul
- * file, editing its soul (a new version each time), pausing or removing it,
- * telling it something, and the daily summary it sends its manager.
- *
- * Shared by the Subagents pages and the lead chat, so both do the same thing.
- */
-import type { Store, SubagentRow } from "./store.js";
-export type Done = {
-    ok: true;
-    said: string;
-    id?: number;
-} | {
-    ok: false;
-    said: string;
-};
-export declare const SUBAGENT_MODELS: readonly ["default", "sonnet", "opus", "haiku"];
-/** A soul file with a different name: the template's, renamed. */
-export declare function renamedSoul(soul: string, name: string): string;
-/** A new subagent in a project, from a template (optionally renamed) or a whole soul file. */
-export declare function createSubagentFrom(store: Store, input: {
-    repo: string;
-    template?: string | null;
-    name?: string | null;
-    soul?: string | null;
-    by: string;
-}, now: Date): Done;
-/** Save a new version of a subagent's soul file. Its name stays: zones name it by handle. */
-export declare function saveSoul(store: Store, mate: SubagentRow, soul: string, by: string, now: Date): Done;
-/** Pause, resume or remove. Paused, its decisions go to people and the zones it handles wait. */
-export declare function setSubagentState(store: Store, mate: SubagentRow, state: "active" | "paused" | "removed", by: string, now: Date): Done;
-export declare function subagentSettings(store: Store, mate: SubagentRow, change: {
-    model?: string;
-    dailyTurns?: number;
-    manager?: string;
-}, by: string, now: Date): Done;
-export declare const nameOf: (mate: SubagentRow) => string;
-export declare const labelOf: (mate: SubagentRow) => string;
-/** Every zone a subagent works, in every flow of its project. */
-export declare function zonesOf(store: Store, mate: SubagentRow): {
-    flow: number;
-    flowName: string;
-    zone: string;
-    title: string;
-    kind: "decides" | "handles";
-}[];
-/** What a subagent did since a time, in words its manager reads at a glance. */
-export declare function summaryOf(store: Store, mate: SubagentRow, since: string | null): {
-    said: string;
-    quiet: boolean;
-};
-/** The daily summary, to each subagent's manager, once a day after 5 pm (this computer's time), or now when asked. */
-export declare function sendSubagentSummaries(store: Store, repo: string, now: Date, only?: number | null): number;

package/dist/subagent-desk.d.ts

@@ -1,59 +0,0 @@
-import type { FlowCardRow, FlowRow, Store, SubagentRow } from "./store.js";
-/** The zone on a desk where the subagent handles what it's asked. */
-export declare const DESK_ZONE = "handle";
-type Done = {
-    ok: true;
-    said: string;
-} | {
-    ok: false;
-    said: string;
-};
-/** Its desk, when it has one. */
-export declare function deskOf(store: Store, mate: SubagentRow): FlowRow | null;
-/** Its desk, made the first time it's needed: owned by its manager, drawn like any flow. */
-export declare function ensureDesk(store: Store, mate: SubagentRow, now: Date): FlowRow;
-/** Who a desk card's answer goes to: the person who asked (when they can see the project), else its manager. */
-export declare function askerOf(store: Store, flow: FlowRow, card: FlowCardRow, mate: SubagentRow): string;
-/** The answer a subagent wrote, back to whoever asked, under its name. Once per visit. */
-export declare function replyToAsker(store: Store, flow: FlowRow, card: FlowCardRow, mate: SubagentRow, text: string, now: Date): void;
-/**
- * The lead delegates (D5): "ask Rosa to …", once its person confirms the card, is a card on Rosa's desk from that
- * person. Rosa works it within her own rules and tools (asking them first where her rules say to), and her answer goes
- * back to whoever asked. It gives her nothing her rules don't: a code change is still a task a person approves.
- */
-export declare function askSubagent(store: Store, given: SubagentRow, from: {
-    who: string;
-    via: string;
-}, text: string, now: Date): {
-    ok: true;
-    said: string;
-    card: number;
-    link: {
-        label: string;
-        path: string;
-    };
-} | {
-    ok: false;
-    said: string;
-};
-export type Routine = {
-    id: number;
-    schedule: string;
-    text: string;
-    state: "active" | "paused" | "removed";
-    lastAt: string | null;
-    lastOutcome: string | null;
-    nextAt: string | null;
-};
-/** Its routines: the schedules on its desk that start in its zone. */
-export declare function routinesOf(store: Store, mate: SubagentRow): Routine[];
-/** This computer's time zone: what a routine's time means when it names none. */
-export declare const localZone: () => string;
-/** A routine's schedule as kept: a calendar time with no zone is this computer's time, not UTC. */
-export declare function routineSchedule(words: string): string | null;
-/** A routine: on this schedule ("weekdays 09:00", "daily 17:00 Europe/London", "every 2 hours"), a card on its desk saying what to do. */
-export declare function addRoutine(store: Store, mate: SubagentRow, schedule: string, text: string, by: string, now: Date, dir: string | null): Done;
-export declare function removeRoutine(store: Store, mate: SubagentRow, id: number, now: Date, dir: string | null): Done;
-/** Try a routine now: its card lands on the desk at once. */
-export declare function runRoutine(store: Store, mate: SubagentRow, id: number, by: string, now: Date): Done;
-export {};

package/dist/subagent-memory.d.ts

@@ -1,65 +0,0 @@
-import type { Store, SubagentCallRow, SubagentMemoryRow, SubagentRow } from "./store.js";
-export declare const MEMORY_CHARS = 300;
-/** Facts a subagent keeps on its own: past this, its oldest are forgotten. What people told it is never dropped this way. */
-export declare const MEMORY_CAP = 300;
-/** Approvals in a row of one action before the subagent suggests loosening its rule. */
-export declare const SUGGEST_AFTER = 5;
-export declare const ACCEPT = "accept", DISMISS = "dismiss";
-type Done = {
-    ok: true;
-    said: string;
-} | {
-    ok: false;
-    said: string;
-};
-/** The words a text is about: lower case, four letters or more, no filler. */
-export declare function wordsOf(text: string): string[];
-/** Two lines about the same thing: most of their words are shared. */
-export declare function similar(a: string, b: string): boolean;
-/** A memory as it may be kept: one line, plain, short, no secrets. */
-export declare function cleanMemory(text: string): {
-    ok: true;
-    text: string;
-} | {
-    ok: false;
-    said: string;
-};
-/** Keep one thing: from a person (what they told it), or from the subagent itself on a turn. The same words twice are kept once. */
-export declare function remember(store: Store, mate: SubagentRow, text: string, from: {
-    source: SubagentMemoryRow["source"];
-    card?: number | null;
-    by: string;
-}, now: Date): Done & {
-    id?: number;
-};
-/** Something a person tells a subagent (the page's "Tell Maya something", or the lead): kept in its memory, read by every turn while it's among the latest ten. */
-export declare function tellSubagent(store: Store, mate: SubagentRow, note: string, by: string, now: Date): Done;
-export declare function editMemory(store: Store, mate: SubagentRow, id: number, text: string, by: string, now: Date): Done;
-export declare function forgetMemory(store: Store, mate: SubagentRow, id: number, by: string, now: Date): Done;
-/** Memories whose text holds every word searched for. */
-export declare function searchMemories(store: Store, mate: SubagentRow, query: string): SubagentMemoryRow[];
-/**
- * What one turn reads: what its people told it lately (oldest first), and
- * what it kept that fits the card — the facts sharing most of the card's
- * words, then its newest — up to eight.
- */
-export declare function memoriesFor(store: Store, mate: SubagentRow, cardText: string, now: Date): {
-    told: SubagentMemoryRow[];
-    kept: SubagentMemoryRow[];
-};
-/** A limit a person would pick: rounded up to a round number. */
-export declare const roundUp: (value: number) => number;
-/**
- * After a person approves an ask-first call: when they have approved this
- * action enough times in a row since it last suggested anything about it,
- * the subagent suggests the rule that would have let it make them all.
- */
-export declare function considerSuggestion(store: Store, mate: SubagentRow, approved: SubagentCallRow, now: Date): number | null;
-/** Its manager answers a suggestion: accept changes the one rule (if it is still what it was), anything else leaves it; their words are remembered. */
-export declare function answerSuggestion(store: Store, mate: SubagentRow, suggestion: number, answer: {
-    choice: string | null;
-    text: string | null;
-    by: string;
-    widening?: "proved";
-}, now: Date): Done;
-export {};

package/dist/subagent-question.d.ts

@@ -1,59 +0,0 @@
-import type { ChatBinding, ChatContent, ChatEvent, ChatState } from "./chat-delivery-state.js";
-import type { Store, TelegramBinding, SubagentQuestionRow } from "./store.js";
-import type { InlineButton } from "./telegram-lead.js";
-/** The key notifyPeople gives a subagent's question: flow-card:<card>:teammate-q:<question>:<person>. */
-export declare const SUBAGENT_Q_KEY: RegExp;
-export declare const IN_WORDS = "Answer in words";
-/** The question a notice is about, while it is still open. */
-export declare function openQuestionOf(store: Store, dedupeKey: string): SubagentQuestionRow | null;
-/** Buttons for the question, minted before the send (for the person it asks only); `place` stamps the message they land on. */
-export declare function telegramQuestionButtons(store: Store, binding: TelegramBinding, question: SubagentQuestionRow, now: Date): {
-    keyboard: InlineButton[][];
-    tokens: string[];
-} | null;
-export type QuestionTapEffect = {
-    kind: "ack";
-    text: string;
-} | {
-    kind: "edit";
-    text: string;
-} | {
-    kind: "prompt";
-    text: string;
-    placeholder: string;
-    question: number;
-};
-/** A tapped question button, inside the update's transaction. */
-export declare function applyTelegramQuestionTap(store: Store, binding: TelegramBinding, action: NonNullable<ReturnType<Store["getTelegramQuestionAction"]>>, message: {
-    text: string;
-}, now: Date): QuestionTapEffect[];
-/** A reply to the "answer in words" prompt, inside the update's transaction. */
-export declare function applyTelegramQuestionReply(store: Store, binding: TelegramBinding, prompt: NonNullable<ReturnType<Store["telegramQuestionPrompt"]>>, text: string, now: Date): string | null;
-/** A question notice as chat parts (the buttons on the last), or null when it isn't one, isn't for this person, or was answered. */
-export declare function questionParts(store: Store, notification: {
-    dedupeKey: string;
-    subject: string;
-    body: string;
-    link: string | null;
-}, binding: ChatBinding): ChatContent[] | null;
-/** The live buttons on one part, in the order they were minted. */
-export declare function chatQuestionButtons(state: ChatState, part: number, now: Date): Array<{
-    token: string;
-    label: string;
-    words: boolean;
-}>;
-/** A tapped question button, inside the action's transaction; false when the token isn't one. */
-export declare function applyChatQuestionTap(options: {
-    store: Store;
-    state: ChatState;
-    label: string;
-}, event: ChatEvent, binding: ChatBinding, token: string, now: Date): boolean;
-/** The person's message while an "answer in words" prompt is open: the answer. false when none is open. */
-export declare function answerChatQuestionPrompt(options: {
-    store: Store;
-    state: ChatState;
-    label: string;
-}, event: ChatEvent, binding: ChatBinding, input: {
-    text: string;
-    originalLength?: number;
-}, now: Date): boolean;

package/dist/subagent-tools.d.ts

@@ -1,125 +0,0 @@
-import type { ToolCaller } from "./flow-actions.js";
-import { type ProjectTool, type ToolSpec } from "./project-tools.js";
-import type { Store, SubagentCallRow, SubagentGrantRow, SubagentRow, ToolActionInfo, ToolRule } from "./store.js";
-/** Lists what a tool offers; injectable so tests never start a server. */
-export type ToolLister = (spec: ToolSpec, values: Record<string, string>) => Promise<{
-    ok: true;
-    actions: ToolActionInfo[];
-} | {
-    ok: false;
-    problem: string;
-}>;
-export type ToolIo = {
-    callTool?: ToolCaller;
-    listTools?: ToolLister;
-    toolHome?: string | undefined;
-    fenceAvailable?: () => boolean;
-};
-/** Actions whose names say they only read start as "do it"; everything else asks first until its manager says otherwise. */
-export declare const READ_VERB: RegExp;
-export declare const defaultRule: (action: Pick<ToolActionInfo, "name" | "readOnly">) => ToolRule;
-type Done = {
-    ok: true;
-    said: string;
-} | {
-    ok: false;
-    said: string;
-};
-/** How a turn names an action: "shop.refund_order". */
-export declare const callName: (tool: string, action: string) => string;
-/** A fresh listing merged into a grant: rules already set are kept, new actions get the default, and gone ones drop out. */
-export declare function withActions(rules: Record<string, ToolRule>, actions: readonly ToolActionInfo[]): {
-    actions: ToolActionInfo[];
-    rules: Record<string, ToolRule>;
-};
-/** The rule that applies to one call with this input, and why, in words. */
-export declare function ruleFor(grant: Pick<SubagentGrantRow, "actions" | "rules">, action: string, input: Record<string, unknown>): {
-    use: ToolRule["use"];
-    why: string;
-};
-/** A rule in words, for the subagent's turn and its page. */
-export declare function ruleWords(rule: ToolRule): string;
-/** Number fields an action's input declares: what a limit can be set on. */
-export declare function numberFields(action: Pick<ToolActionInfo, "input">): string[];
-/** What's wrong with an input, by what the action declares: its required fields and their simple types. */
-export declare function inputProblem(action: Pick<ToolActionInfo, "input">, input: Record<string, unknown>): string | null;
-/** A call in a few words: "shop → refund_order · order 1044 · amount 400". */
-export declare function callWords(tool: string, action: string, input: Record<string, unknown>, cap?: number): string;
-/** An action as a turn is offered it. */
-export type OfferedTool = {
-    name: string;
-    about: string;
-    input: string;
-    rule: string;
-};
-/** What a subagent may use now: its grants' actions on tools the project still has, "never" left out. */
-export declare function offeredTools(store: Store, mate: SubagentRow): OfferedTool[];
-/** Before a turn: re-list tools whose listing is old (or never happened), so the turn sees what they offer today. A tool that can't be reached keeps its last listing. */
-export declare function refreshGrants(store: Store, mate: SubagentRow, now: Date, io: ToolIo): Promise<void>;
-/** Let a subagent use one of the project's tools. Its actions start at their defaults: reading is free, everything else asks first.
- * A grant widens what it does unasked, so it takes the person's proof (a password, or a session under Passwordless):
- * `widening: "proved"` (chat-management.md §0a.3). */
-export declare function grantTool(store: Store, mate: SubagentRow, tool: string, by: string, now: Date, io?: ToolIo, 
-/** `stillProved`: the proof re-checked after the listing's wait, in the same synchronous step as the save. */
-options?: {
-    widening?: "proved";
-    stillProved?: () => boolean;
-}): Promise<Done>;
-/** A grant from what the tool offers (or, not reachable now, the names its last test found). Every road to a grant
- * comes here: it takes the person's proof, and a tool it already uses keeps its rules (a grant never resets them). */
-export declare function grantListed(store: Store, mate: SubagentRow, tool: ProjectTool, actions: ToolActionInfo[] | null, by: string, now: Date, options?: {
-    widening?: "proved";
-}): Done;
-export declare function revokeTool(store: Store, mate: SubagentRow, tool: string, by: string, now?: Date): Done;
-/** Check one rule: an action the tool offers, a known use, and a limit on one of its number fields. */
-export declare function checkRule(grant: Pick<SubagentGrantRow, "tool" | "actions">, action: string, rule: {
-    use: unknown;
-    limit?: {
-        field: unknown;
-        over: unknown;
-    } | null;
-    undo?: unknown;
-}): {
-    ok: true;
-    rule: ToolRule;
-} | {
-    ok: false;
-    said: string;
-};
-/** Whether `next` lets the subagent do more unasked than `before` (chat-management.md §0a.3): a higher rank, or a limit
- * on another number or a higher one. The undo action is never authority. */
-export declare function ruleLoosens(before: ToolRule, next: ToolRule): boolean;
-/** Set the rules for some of a granted tool's actions; the others keep theirs. Loosening any of them takes the
- * person's proof (a password, or a session under Passwordless): `widening: "proved"`; tightening never does. */
-export declare function setToolRules(store: Store, mate: SubagentRow, tool: string, changes: Record<string, {
-    use: unknown;
-    limit?: {
-        field: unknown;
-        over: unknown;
-    } | null;
-    undo?: unknown;
-}>, by: string, now: Date, options?: {
-    widening?: "proved";
-}): Done;
-/**
- * Make one call now: a free one, or one a person approved (exactly as they
- * saw it). What the tool said is kept on the receipt, secrets scrubbed; a
- * tool that says it failed is an answer the subagent reads, not trouble.
- */
-export declare function makeCall(store: Store, call: SubagentCallRow, repo: string, io: ToolIo, now: Date, options?: {
-    byPerson?: boolean;
-}): Promise<SubagentCallRow>;
-/** A receipt in words: what happened to the call. */
-export declare function callOutcome(call: SubagentCallRow): string;
-/** A receipt as a person reads it on the card: what happened, and who decided. */
-export declare function receiptWords(store: Store, call: SubagentCallRow): string;
-/** The Tools section's form, read into rule changes: every action the grant knows. */
-export declare function rulesFromForm(grant: Pick<SubagentGrantRow, "actions">, field: (key: string) => string | null): Record<string, {
-    use: unknown;
-    limit?: {
-        field: unknown;
-        over: unknown;
-    };
-    undo?: unknown;
-}>;
-export {};

package/dist/subagent-week.d.ts

@@ -1,68 +0,0 @@
-import type { Store, SubagentCallRow, SubagentRow } from "./store.js";
-import { type ToolIo } from "./subagent-tools.js";
-type Done = {
-    ok: true;
-    said: string;
-} | {
-    ok: false;
-    said: string;
-};
-export type Week = {
-    since: string;
-    turns: number;
-    failedTurns: number;
-    costUsd: number | null;
-    minutes: number;
-    decided: number;
-    handled: number;
-    handed: number;
-    asked: number;
-    calls: {
-        made: number;
-        approved: number;
-        denied: number;
-        refused: number;
-        undone: number;
-    };
-    overrides: {
-        said: string;
-        at: string;
-        href: string | null;
-    }[];
-    undoable: {
-        call: number;
-        words: string;
-        undo: string;
-        at: string;
-        href: string | null;
-    }[];
-};
-/** The undo action a call's rule names, when there is one and the call can still be undone. */
-export declare function undoFor(store: Store, call: SubagentCallRow): string | null;
-/** The last seven days (or since a time) for one subagent. */
-export declare function weekOf(store: Store, mate: SubagentRow, now: Date, since?: string): Week;
-/** The week in words its manager reads at a glance. */
-export declare function weekWords(mate: SubagentRow, week: Week): string;
-/** Each Monday from 9:00 (this computer's time), the week's report to each active subagent's manager, once; or now, for one. */
-export declare function sendSubagentWeeklies(store: Store, repo: string, now: Date, only?: number | null): number;
-/**
- * A person asks to undo one of its tool calls with the action its manager
- * named: the undo call is recorded at once (the same input, as them), and
- * made by finishUndo — right away on the page, or by the worker's next pass
- * when it was asked for in chat. Both calls keep their receipts.
- */
-export declare function requestUndo(store: Store, mate: SubagentRow, id: number, by: string, now: Date): {
-    ok: true;
-    call: number;
-    said: string;
-} | {
-    ok: false;
-    said: string;
-};
-/** Make a requested undo call; if the tool says it failed, the original call stands (and can be undone again). */
-export declare function finishUndo(store: Store, id: number, io: ToolIo, now: Date): Promise<Done>;
-/** The worker's pass: undo calls asked for in chat, made now. */
-export declare function runRequestedUndos(store: Store, io: ToolIo, now: Date): Promise<number>;
-/** Undo, on the page: asked for and made at once. */
-export declare function undoCall(store: Store, mate: SubagentRow, id: number, by: string, io: ToolIo, now: Date): Promise<Done>;
-export {};

package/dist/subagent-work.d.ts

@@ -1,76 +0,0 @@
-/**
- * A subagent's turn on a card (v92), run by the flow step pass.
- *
- * The turn reads the zone, the card (as data) and what its people told it,
- * and answers with one decision (subagents.ts). This carries the decision
- * out within the zone's own choices, and writes it down — what it did and
- * why — in the card's history and the subagent's log:
- *
- * - "Person decides" zone: approve (the draft as written, or as it rewrote
- *   it), send back with a note, or hand it to the zone's person, whose
- *   decision then arrives in their chat app as always.
- * - "Subagent handles it" zone: pick one of the zone's answers (its text is
- *   kept for the next zones), ask its person a question and wait for the
- *   answer, or say it can't and take the failure path.
- *
- * Either way (v94), before it decides it may use the project tools its
- * manager let it use: each call is checked against its rule for that action
- * (subagent-tools.ts), made at once or put to its person first, and kept as
- * a receipt; the turn goes on with what the tool answered.
- */
-import type { FlowCardRow, FlowRow, Store, SubagentRow } from "./store.js";
-import type { FlowDefinition, FlowStage } from "./flows.js";
-import { type TurnRunner } from "./subagents.js";
-import { type ToolIo } from "./subagent-tools.js";
-/** A question waits for its answer this long before the step is due again on its own: never, in practice. */
-export declare const ASKED = "9999-12-31T00:00:00.000Z";
-/** v94: tool calls one visit of a card may make, and turns one step run may take, before it must decide with what it has. */
-export declare const CALLS_PER_VISIT = 12;
-/** The two answers an ask-first call offers; words instead tell the subagent what to do. */
-export declare const APPROVE = "approve", DENY = "deny";
-export type SubagentOutcome = {
-    state: "passed" | "failed" | "retry" | "waiting";
-    said: string;
-    log?: string;
-    decisionJson?: string;
-    nextAt?: string;
-};
-/** The Claude model a subagent's turns run on: its own, or the lead chat's Claude model, or Claude's default. */
-export declare function subagentModel(store: Store, mate: SubagentRow): string;
-/** Whether a subagent can take a turn now: active, readable, and under its daily limit. */
-export declare function subagentReady(store: Store, mate: SubagentRow | null, now: Date): {
-    ok: true;
-} | {
-    ok: false;
-    why: string;
-};
-/** The answers a "Subagent handles it" zone offers, each with the zone it leads to. */
-export declare function handleAnswers(stage: FlowStage): {
-    answer: string;
-    to: string | null;
-}[];
-/**
- * Run one subagent turn on a card and carry out what it decided. With tools
- * (v94) a turn is a short loop: each tool call it asks for is made (or put to
- * its person, and the turn waits), and it decides again with the answer —
- * until it decides, or it has used its tools as much as a visit allows.
- */
-export declare function subagentTurn(store: Store, flow: FlowRow, definition: FlowDefinition, stage: FlowStage, card: FlowCardRow, mate: SubagentRow, now: Date, io: {
-    turn?: TurnRunner;
-    evidenceRoot?: string;
-} & ToolIo): Promise<SubagentOutcome>;
-/** A person answers a subagent's question: once, by the person it was asked of; the card's turn is due again. */
-export declare function answerSubagentQuestion(store: Store, id: number, answer: {
-    choice: string | null;
-    text: string | null;
-    by: string;
-    via: string;
-    /** The person proved themselves for this answer: only then may accepting a suggested rule loosen it. */
-    widening?: "proved";
-}, now: Date): {
-    ok: true;
-    said: string;
-} | {
-    ok: false;
-    said: string;
-};

package/dist/subagents-ui.d.ts

@@ -1,22 +0,0 @@
-/**
- * The Subagents pages (v92): who is on the team, and one page per subagent —
- * what it asks you, its soul file, what it did and why, what you told it,
- * and its settings. Server-rendered forms, like the other settings pages.
- */
-import type { Store, SubagentRow } from "./store.js";
-import { type Html } from "./html.js";
-/** v94: the Tools section's rule rows; a limit's fields show only while "Up to a limit" is chosen. */
-export declare const SUBAGENT_CSS = ".subagent-tools .tool-grant{border-top:1px solid var(--so-line);padding-top:12px;margin-top:12px}.subagent-tools .tool-grant:first-of-type{border-top:0;margin-top:0;padding-top:0}.subagent-tools h3{font-size:1rem;margin:0 0 4px}.subagent-tools .tool-rule{display:grid;gap:6px;padding:10px 0;border-bottom:1px solid var(--so-line)}.subagent-tools .tool-rule:last-of-type{border-bottom:0}.subagent-tools .tool-rule .meta{display:block}.subagent-tools select,.subagent-tools input{max-width:100%;box-sizing:border-box}.subagent-tools .tool-limit{display:none;flex-wrap:wrap;align-items:center;gap:6px}.subagent-tools .tool-rule:has(option[value=\"limit\"]:checked) .tool-limit{display:flex}.subagent-tools .tool-rule>select{width:auto;min-width:16em}.subagent-tools .tool-limit select{width:auto}.subagent-tools .tool-limit input{width:7em}.subagent-tools .tool-buttons{display:flex;flex-wrap:wrap;gap:8px;margin-top:8px}.subagent-tools button{min-height:44px}.subagent-activity li{overflow-wrap:anywhere}.subagent-memory .memory-tell,.subagent-memory .memory-search{display:flex;flex-wrap:wrap;gap:8px;align-items:flex-end;margin:0 0 12px}.subagent-memory .memory-tell textarea{flex:1 1 280px}.subagent-memory .memory-search input{flex:1 1 220px}.subagent-memory button{min-height:44px}.subagent-memories{list-style:none;padding:0;margin:0}.subagent-memories li{padding:10px 0;border-top:1px solid var(--so-line);overflow-wrap:anywhere}.subagent-memories li:first-child{border-top:0}.subagent-memories .meta{display:block;font-size:.85rem}.subagent-memories details.memory-edit{border:0;padding:0;margin:2px 0 0;background:transparent;box-shadow:none}.memory-edit summary{cursor:pointer;min-height:32px;display:inline-flex;align-items:center;font-size:.85rem;font-weight:400;color:var(--so-muted)}.tool-undo{border:0;padding:0;margin:8px 0;background:transparent;box-shadow:none}.tool-undo summary{cursor:pointer;min-height:36px;display:inline-flex;align-items:center;font-size:.9rem}.tool-undo-row{display:flex;flex-wrap:wrap;gap:6px;align-items:center;margin:6px 0}.tool-undo-row select{width:auto}.subagent-overrides,.subagent-undo{padding-left:18px}.subagent-undo li{margin:6px 0}.subagent-undo form{display:inline}.subagent-week h3{font-size:1rem;margin:14px 0 4px}.subagent-week button{min-height:44px}.subagent-routines{list-style:none;padding:0;margin:8px 0}.subagent-routines li{display:grid;gap:4px;padding:10px 0;border-top:1px solid var(--so-line)}.subagent-routines li:first-child{border-top:0}.routine-buttons{display:flex;flex-wrap:wrap;gap:8px}.routine-buttons button,.routine-add button{min-height:44px}.routine-add{display:flex;flex-wrap:wrap;gap:8px;align-items:flex-end;margin:8px 0}.routine-add label{display:grid;gap:4px;flex:1 1 200px}.routine-add label:first-of-type{flex:0 1 180px}.subagent-actions,.question-options{display:flex;flex-wrap:wrap;gap:8px;margin:8px 0}.subagent-actions form,.question-options form{margin:0}.memory-edit form{display:grid;gap:8px;margin-top:6px}.memory-buttons{display:flex;flex-wrap:wrap;gap:8px}@media(max-width:600px){.subagent-tools select,.subagent-tools input{font-size:16px}}";
-/** A blank soul file: the sections a subagent reads, to fill in. */
-export declare const BLANK_SOUL = "---\nname: \nrole: \n---\n\n## Who you are\n\n\n## How you write\n\n\n## What you know\n\n\n## Decide on your own\n- \n\n## Ask first\n- \n\n## Never\n- \n";
-export declare function subagentsListHtml(store: Store, mates: readonly SubagentRow[], projects: readonly string[], projectName: (repo: string) => string, canCreate: boolean, notice: {
-    said?: string | null;
-    problem?: string | null;
-    adding?: boolean;
-}): Html;
-export declare function subagentPageHtml(store: Store, mate: SubagentRow, viewer: string, projectName: (repo: string) => string, canManage: boolean, approvers: readonly string[], notice: {
-    said?: string | null;
-    problem?: string | null;
-    soulDraft?: string | null;
-    query?: string | null;
-}): Html;