@wenathlan/devthink 2.0.14 → 2.0.19

package/dist/agent.d.ts

@@ -1,837 +0,0 @@
-/** The agent module of the 1.1.88 consolidation: every correlated variation of the agent logic interned in this one file, so the module family carries one surface without duplicate variations. */
-import type { agentbudget, agentrecord, agentscope, agentrole, budgetstate, runrecord, taskqueue, toolnamespace, agentidentity, agentmailbox, agentmessage, messagerouting, comparisonrecord, consensusrecord, consensusvote, escalationrecord, replayrecord, reviewrecord, reviewverdict, callcontext, cancelframe, capabilityset, eventkind, jsonrpcframe, progressnotice, promptdef, protocoleventsubscription, resourcewatch, samplingrequest, streamchunk, aggregatecell, aggregaterecord, arbitrationcase, costentry, depthlimit, interleaveevent, lessonrecord, loadreport, spawnrecord, subagentspec, tasklane, agentevent, agenteventkind, agentusage, killswitch, spawnrequest, swarmstate, taskitem, workflowrun, actionrisk, blackboard, blackboardsection, conflictscan, conflictwriter, handoffrecord, mergeentry, mergerule, outputcomparison, resourcelock, resultreport, swarmaction, swarmcost } from "./types.js";
-/**
- * Agent fleet logic of the 1.1.72 family.
- * Every correlated rule for the fleet registry, the unique lowercase agent naming with its reserved words, the scope intersection that narrows the requested origins and action kinds to the session grants, the read only observer scope, the per agent budget grant from user configuration with its spending and refusal, the remaining budget report, the single agent pause that leaves the peers and their run records untouched, and the global killswitch that cancels every agent run and clears every queue in one call lives in this file.
- * The fleet never bypasses review: the scope keeps every step inside the session grants, every budget ceiling stays a user choice with no hardcoded cap, and the killswitch needs the user action because no agent ever triggers it.
- */
-/** The reserved fleet names no agent may take: the user, the operator, the human and the system identities stay outside the agent namespace. */
-export declare const reservedagentnames: ReadonlySet<string>;
-/** Assigns one fleet record with its unique lowercase name: the helper lowercases the user proposal, refuses names outside the lowercase identifier rule, reserved words and duplicates, and registers the record with its role and home origin before its first run. */
-export declare function agentname(input: {
-    records: agentrecord[];
-    id: string;
-    proposed: string;
-    role?: agentrole;
-    origin: string;
-    now: number;
-}): agentrecord;
-/** Intersects the requested scope with the session grants: the requested origins keep only the granted entries, the requested action kinds keep only the allowed catalog entries, an absent request stays unbounded inside the grants, and a request that lands entirely outside the grants refuses loudly instead of silently widening. */
-export declare function agentscopeof(input: {
-    agentid: string;
-    requested?: {
-        origins?: string[];
-        toolnamespaces?: toolnamespace[];
-        actionkinds?: string[];
-    };
-    grants?: string[];
-    allowedkinds?: string[];
-}): agentscope;
-/** Builds the read only scope of an observer agent: the observer reads the page and the fleet state through the read side kinds only and never acts on it. */
-export declare function readonlyscope(input: {
-    agentid: string;
-    readkinds: string[];
-}): agentscope;
-/** Grants one per agent budget from user configuration: the ceilings copy the user values with no hardcoded cap and the fresh budgetstate starts at zero spent. */
-export declare function agentbudgetof(input: {
-    agentid: string;
-    maxsteps?: number;
-    maxtokens?: number;
-    maxdurationms?: number;
-    currency?: string;
-    now: number;
-}): {
-    budget: agentbudget;
-    state: budgetstate;
-};
-/** Spends one unit per executed step against the budget state: the spend adds its steps, tokens and duration, and a spend past a user configured ceiling refuses the execution until the user raises the ceiling or stops the agent. */
-export declare function spendbudget(input: {
-    state: budgetstate;
-    steps?: number;
-    tokens?: number;
-    durationms?: number;
-    now: number;
-}): budgetstate;
-/** Reports the remaining budget of one agent: every ceiling the user configured reports its remaining value while an absent ceiling reports unbounded. */
-export declare function budgetremaining(state: budgetstate): {
-    steps?: number;
-    tokens?: number;
-    durationms?: number;
-    reason: string;
-};
-/** Pauses one agent of the fleet without stopping its peers: the pause holds only the named agent while every other record and every other run record stays exactly as it was. */
-export declare function pauseagent(input: {
-    records: agentrecord[];
-    agentid: string;
-    now: number;
-}): agentrecord[];
-/** Resumes one paused agent of the fleet: the resume lifts only the named agent while the peers never changed. */
-export declare function unpauseagent(input: {
-    records: agentrecord[];
-    agentid: string;
-    now: number;
-}): agentrecord[];
-/** Engages the global killswitch in one call: every fleet record stops, every agent run cancels, every queued item of every queue clears, and the return carries one stop entry per agent so the audit trail records each stopped agent. */
-export declare function engagekillswitch(input: {
-    records: agentrecord[];
-    runs: runrecord[];
-    queues?: taskqueue[];
-    reason?: string;
-    now: number;
-}): {
-    records: agentrecord[];
-    runs: runrecord[];
-    queues: taskqueue[];
-    stopped: Array<{
-        agentid: string;
-        name: string;
-        runs: string[];
-        queued: number;
-    }>;
-    engagedat: number;
-    reason: string;
-};
-/** Reads the fleet at a glance for the sidepanel and the protocol envelope: the records with their control states, the budget states, the open escalations and reviews and the timestamp of the last killswitch stop. */
-export declare function fleetoverview(input: {
-    records: agentrecord[];
-    budgets: budgetstate[];
-    openescalations: number;
-    openreviews: number;
-    killswitchat?: number;
-}): {
-    agents: number;
-    active: number;
-    paused: number;
-    stopped: number;
-    openescalations: number;
-    openreviews: number;
-    lastkillswitchat?: number;
-};
-/**
- * Agent mailbox logic of the 1.1.58 multi agent family.
- * Every correlated rule for the direct, broadcast and role addressed routing, the inbox and outbox records, the unread counters and the receive drain with ack tracking lives in this file.
- * The messages stay inside the swarm: a message that carries page content grades as an egress event in the audit trail, and no mailbox delivery ever bypasses a consent gate.
- */
-/** The broadcast recipient marker: a message addressed to it reaches every agent of the swarm but the sender. */
-export declare const broadcastrecipient = "*";
-/** Returns the mailbox of one agent; an agent without a mailbox yet reads an empty one. */
-export declare function mailboxof(mailboxes: agentmailbox[], agentid: string): agentmailbox;
-/** Returns every agent id of one role for the role addressed routing. */
-export declare function roleaddress(agents: agentidentity[], role: string): string[];
-/** Resolves the recipients of one message: a direct message names one agent, a broadcast reaches every live agent but the sender and a role message reaches every live agent of the role. */
-export declare function resolverecipients(input: {
-    agents: agentidentity[];
-    senderid: string;
-    recipient: string;
-    routing: messagerouting;
-}): string[];
-/** Delivers one message to the recipient inboxes: the sender outbox records it, the unread counters rise and the delivery stays visible to every reader of the swarm. */
-export declare function sendmessage(input: {
-    mailboxes: agentmailbox[];
-    agents: agentidentity[];
-    id: string;
-    senderid: string;
-    recipient: string;
-    routing: messagerouting;
-    payload: string;
-    now: number;
-}): agentmailbox[];
-/** Drains one inbox with ack tracking: every message receives its read time, the unread counter resets and the drain returns the read messages oldest first. */
-export declare function receivemessages(input: {
-    mailboxes: agentmailbox[];
-    agentid: string;
-    now: number;
-}): {
-    mailboxes: agentmailbox[];
-    messages: agentmessage[];
-};
-/** Returns the unread count of one agent mailbox. */
-export declare function unreadcount(mailboxes: agentmailbox[], agentid: string): number;
-/**
- * Agent review logic of the 1.1.72 family.
- * Every correlated rule for the human escalation hold that blocks the raising agent until the user answers, the agent to agent review requests with the reviewer verdict recorded beside the original output, the runreplay capture of the ordered steps and results of one agent run with its reconstruction from the audit trail when the run memory is gone, the field by field outputcompare of two competing agent outputs and the consensusvote with one vote per agent, the user configured quorum rule and the dissenting votes kept for the audit trail lives in this file.
- * The review layer never touches the page and never bypasses a gate: an escalation stays human decided, a review request stays between two agents of the shared origin, a replay reads the records only and every vote counts exactly once.
- */
-/** Reads the escalation hold of one agent: an open escalation blocks its raising agent until the human answers, so the run of a blocked agent waits instead of guessing. */
-export declare function escalationblock(input: {
-    escalations: escalationrecord[];
-    agentid: string;
-}): {
-    blocked: boolean;
-    open: number;
-    reason: string;
-};
-/** Sends one agent output to a peer agent for review: the review record carries the original output exactly as produced and waits open until the reviewing agent records its verdict. */
-export declare function reviewrecordof(input: {
-    id: string;
-    fromagentid: string;
-    toagentid: string;
-    subject: string;
-    output: string;
-    now: number;
-}): reviewrecord;
-/** Records the reviewer verdict beside the original output: the answered review keeps the verdict, the issues the reviewer named and the answer time while the original output stays untouched. */
-export declare function recordverdict(input: {
-    records: reviewrecord[];
-    id: string;
-    reviewerid: string;
-    verdict: reviewverdict;
-    issues?: string[];
-    now: number;
-}): reviewrecord;
-/** Captures one runreplay of an agent run: the ordered steps with their results and times freeze into one replay record the audit trail keeps per agent. */
-export declare function runreplay(input: {
-    id: string;
-    agentid: string;
-    runid: string;
-    steps: Array<{
-        stepid: string;
-        kind: string;
-        summary: string;
-        state: string;
-        at: number;
-    }>;
-    now: number;
-}): replayrecord;
-/** Reconstructs one runreplay from the audit trail when the run memory is gone: the recorded events of the agent and its run order into the same replay shape a live capture produced, and the reconstruction marks itself. */
-export declare function reconstructreplay(input: {
-    id: string;
-    agentid: string;
-    runid: string;
-    events: Array<{
-        id: string;
-        kind: string;
-        summary: string;
-        at: number;
-        agentid?: string;
-        stepid?: string;
-        planid?: string;
-    }>;
-    now: number;
-}): replayrecord;
-/** Aligns two competing agent outputs field by field: every field of both sides grades matching when the values agree, conflicting when they differ and missing when one side carries no value, so the user reads exactly where the agents disagree. */
-export declare function outputcompare(input: {
-    id: string;
-    subject: string;
-    left: {
-        agentid: string;
-        fields: Record<string, string>;
-    };
-    right: {
-        agentid: string;
-        fields: Record<string, string>;
-    };
-    now: number;
-}): comparisonrecord;
-/** Collects one vote per agent on one proposal and computes the outcome by the user configured quorum rule: duplicate voters refuse, yes votes carry the proposal at the quorum, a complete round under the quorum fails it, an incomplete round stays open and every dissenting vote stays in the record for the audit trail. */
-export declare function consensusrecordof(input: {
-    id: string;
-    proposal: string;
-    votes: Array<{
-        agentid: string;
-        vote: consensusvote;
-        reason?: string;
-        castat: number;
-    }>;
-    quorum: number;
-    voters?: number;
-    now: number;
-}): consensusrecord;
-/**
- * Agent stream of the 1.1.56 agent protocol part three.
- * Every subscription, resource, sampling, prompt, streaming, progress and cancellation concern lives in this file: the event subscriptions with their kinds and filters, the event notifications that push protocol events to matching subscribers, the resource watchers with their page state baselines and the page state deltas they deliver, the sampling callbacks that ask a client model for a completion behind its declared capabilities and the page content grant, the prompt defs exposed as callable tools with their template rendering, the stream chunks of progressive tool results, the progress notices of long tools with their cancel hints and the cancellation frames that abort an in flight tool call while preserving its partial result.
- * The stream stays pure and consent-first: a subscription never widens what the session grants, a sampling prompt never leaves the browser with ungranted page content and a cancellation never bypasses the audit trail.
- */
-/** The protocol event kinds a client may subscribe to; the callstarted kind mirrors every tool call including calls with side effects. */
-export declare const protocoleventkinds: eventkind[];
-/** The observation event kinds that stay read only: every kind except the callstarted mutation mirror. */
-export declare const readonlyeventkinds: eventkind[];
-/** Registers one client event subscription: the kinds validate against the protocol event kinds while an absent kinds list subscribes the read only observation kinds so a subscription never widens what the session grants. */
-export declare function subscriberegister(input: {
-    clientid: string;
-    kinds?: string[];
-    origin?: string;
-    tool?: string;
-    now: number;
-    id?: string;
-}): {
-    subscription?: protocoleventsubscription;
-    reason?: string;
-};
-/** Cancels one client event subscription; the record stays for the audit trail with its cancel time. */
-export declare function unsubscriberegister(subscriptions: protocoleventsubscription[], id: string, now: number): protocoleventsubscription[];
-/** Pushes one protocol event to every matching subscriber: active subscriptions whose kinds carry the event kind, whose origin filter matches when set and whose tool filter matches when set receive one notification frame; the delivery stamps the last delivery time. */
-export declare function notifyevent(input: {
-    subscriptions: protocoleventsubscription[];
-    kind: eventkind;
-    origin?: string;
-    tool?: string;
-    payload?: Record<string, unknown>;
-    now: number;
-}): {
-    deliveries: Array<{
-        subscriptionid: string;
-        clientid: string;
-        frame: jsonrpcframe;
-    }>;
-    subscriptions: protocoleventsubscription[];
-};
-/** Starts one page state watcher for a client: the resource names the watched page state and the baseline freezes the page state at watch time so later deltas compare against it. */
-export declare function watchresource(input: {
-    clientid: string;
-    resource: string;
-    state?: Record<string, unknown>;
-    now: number;
-    id?: string;
-}): {
-    watch?: resourcewatch;
-    reason?: string;
-};
-/** Cancels one page state watcher; the record stays for the audit trail with its cancel time. */
-export declare function unwatchresource(watches: resourcewatch[], id: string, now: number): resourcewatch[];
-/** Pushes the page state deltas of one resource to its active watchers: every changed key against the baseline lands in the delta, the baseline absorbs the new state and the delivery stamps the last delivery time. */
-export declare function notifyresource(input: {
-    watches: resourcewatch[];
-    resource: string;
-    state: Record<string, unknown>;
-    now: number;
-}): {
-    deliveries: Array<{
-        watchid: string;
-        clientid: string;
-        delta: Record<string, unknown>;
-    }>;
-    watches: resourcewatch[];
-};
-/** Sends one sampling callback to a client model: the client must have declared its sampling capability, the page content stays stripped unless the user granted it and the request records its provenance for the round trip. */
-export declare function requestsampling(input: {
-    clientid: string;
-    capabilities?: capabilityset;
-    prompt: string;
-    system?: string;
-    pagecontent?: string;
-    pagegrant?: boolean;
-    maxtokens?: number;
-    now: number;
-    id?: string;
-}): {
-    request?: samplingrequest;
-    reason?: string;
-};
-/** Completes one sampling round trip: the client answer closes the pending request with its provenance times while answered, refused and unknown requests stay untouched. */
-export declare function answersampling(input: {
-    requests: samplingrequest[];
-    id: string;
-    answer?: string;
-    refused?: boolean;
-    now: number;
-}): {
-    requests: samplingrequest[];
-    request?: samplingrequest;
-    reason?: string;
-};
-/** Lists the prompt defs the server exposes as callable tools: every prompt carries its name, description, declared arguments and render template. */
-export declare function listprompts(): promptdef[];
-/** Renders one prompt def with its arguments: every double braced placeholder substitutes its argument value while a required argument left empty keeps its placeholder so the review sees the gap. */
-export declare function renderprompt(prompt: promptdef, args: Record<string, unknown>): string;
-/** Calls one prompt: the render validates the declared arguments, substitutes the defaults the prompt reviewed and returns the rendered prompt with its arguments as one tool call the client dispatches behind the consent gates. */
-export declare function callprompt(input: {
-    name: string;
-    args?: Record<string, unknown>;
-    now?: number;
-}): {
-    toolcall?: {
-        name: string;
-        params: Record<string, unknown>;
-    };
-    rendered?: string;
-    reason?: string;
-};
-/** Emits one stream chunk of a progressive tool result: the sequence number orders the chunks while the done marker closes the stream. */
-export declare function streamchunkof(input: {
-    callid: string;
-    seq: number;
-    content: string;
-    done?: boolean;
-    now: number;
-}): streamchunk;
-/** Splits one tool result content into ordered stream chunks; the final chunk carries the done marker so the client reassembles the progressive result. */
-export declare function chunkcontent(input: {
-    callid: string;
-    content: string;
-    size?: number;
-    now: number;
-}): streamchunk[];
-/** Reassembles ordered stream chunks into the progressive result content they carry. */
-export declare function assemblechunks(chunks: streamchunk[]): string;
-/** Emits one progress notice of a long tool call: the percent, the plain language message and the cancel hint the panel renders. */
-export declare function notifyprogress(input: {
-    callid: string;
-    percent?: number;
-    message: string;
-    cancellable?: boolean;
-    now: number;
-}): progressnotice;
-/** Builds one cancellation frame that aborts an in flight tool call: the call id and the reason in plain language. */
-export declare function cancelframeof(input: {
-    callid: string;
-    reason?: string;
-    now: number;
-}): cancelframe;
-/** Aborts one in flight tool call on its cancellation frame: the call context turns cancelled with its end time while the partial result survives for the answer; a finished or unknown call reports why nothing aborted. */
-export declare function canceltool(input: {
-    contexts: callcontext[];
-    callid: string;
-    reason?: string;
-    partial?: callcontext["partial"];
-    now: number;
-}): {
-    contexts: callcontext[];
-    context?: callcontext;
-    reason?: string;
-};
-/**
- * Agent work logic of the 1.1.73 family.
- * Every correlated rule for the on demand sub agent spawning under the user configured depth limit with the parent scope copied into the child unless narrowed, the lineage depth computed from the spawn records, the aggregatereport that merges parallel agent outputs into one document with per agent sections, provenance and conflicts resolved by policy order or sent to escalation, the interleaved timeline that orders the actions of every agent into one merged view with the per agent lanes kept visible, the lessonshare that records reusable lessons of finished runs, serves the matching lessons to agents starting similar tasks and counts reuse while stale lessons decay, the arbitrate cases that open when two agents contest one resource and grant it to the first requester or the priority lane winner and release when the holder finishes, the prioritylane ranking that keeps sensitive steps in the interactive lane and prevents lane starvation through the round robin fallback, the scaleworkers load reports per origin with their spawn and pause suggestions that never act without consent, and the costshare ledger that attributes shared costs to the agents that caused them lives in this file.
- * The work layer never bypasses a gate: a spawn stays inside the parent scope, the depth ceiling stays the user's choice with no hardcoded number, an aggregation never rewrites the original outputs, a verdict never bypasses the sessionlock or the origin grants, a suggestion never spawns a worker without consent and every lesson sanitizes before storage.
- */
-/** Spawns one sub agent under its parent: the child registers with its unique lowercase name through the same agentname rule of the fleet, the spawn refuses a paused or stopped parent, the child depth sits exactly one level under the parent lineage depth, the parent scope copies into the child unless the spec narrows it, and a narrowing that widens past the parent refuses loudly. */
-export declare function spawnsubagent(input: {
-    records: agentrecord[];
-    spawns: spawnrecord[];
-    spec: subagentspec;
-    parentscope?: agentscope;
-    id: string;
-    name?: string;
-    now: number;
-}): {
-    record: agentrecord;
-    scope: agentscope;
-    spawn: spawnrecord;
-};
-/** Copies the parent scope into the child unless narrowed: a narrowing keeps only the parent origins and action kinds so the child scope stays a subset of its parent, and a narrowing that lands entirely outside the parent refuses instead of silently widening. */
-export declare function childscopeof(input: {
-    agentid: string;
-    parent?: agentscope;
-    narrowed?: {
-        origins?: string[];
-        actionkinds?: string[];
-    };
-}): agentscope;
-/** Computes the spawn depth of one agent lineage: the chain of spawn records from the agent up through its parents counts one level per spawn, an agent nobody spawned sits at depth zero, and a cycle in the lineage refuses instead of looping. */
-export declare function depthoflineage(input: {
-    spawns: spawnrecord[];
-    agentid: string;
-}): number;
-/** Checks one spawn depth against the user configured depth limit: the depth refuses past the configured ceiling while an absent limit stays unbounded because the ceiling stays the user's choice with no hardcoded number. */
-export declare function depthlimitof(input: {
-    spawns: spawnrecord[];
-    agentid: string;
-    limit: depthlimit;
-}): {
-    depth: number;
-    allowed: boolean;
-    reason: string;
-};
-/** Merges the parallel outputs of several agents into one aggregatereport: every agent keeps its own section with its run provenance, a section two agents wrote conflicts, a conflict resolves through the user configured policy order that names its agent precedence while a conflict without an order stays unresolved and the record stays open for the escalation. */
-export declare function aggregatereport(input: {
-    id: string;
-    subject: string;
-    cells: aggregatecell[];
-    conflictorder?: string[];
-    expected?: string[];
-    now: number;
-}): aggregaterecord;
-/** Orders the actions of different agents into one interleaved timeline: the events sort by their time and id across every agent while each event carries its lane so the merged view keeps every per agent lane visible inside the one stream. */
-export declare function interleave(input: {
-    events: Array<{
-        id?: string;
-        agentid: string;
-        kind: string;
-        summary: string;
-        at: number;
-        lane?: string;
-    }>;
-    lanes: tasklane[];
-}): interleaveevent[];
-/** Records one reusable lesson of a finished run: the finding in plain language, the agent that found it and the origin it holds on, with the reuse count starting at zero until another agent serves it. */
-export declare function lessonrecordof(input: {
-    id: string;
-    agentid: string;
-    finding: string;
-    origin: string;
-    now: number;
-}): lessonrecord;
-/** Serves the matching lessons to an agent starting a similar task: the lessons of the same origin match first, the findings that share words with the task follow, and the reuse count of every served lesson grows so the fleet reads which lessons carry their weight. */
-export declare function lessonmatches(input: {
-    lessons: lessonrecord[];
-    task: string;
-    origin?: string;
-    limit?: number;
-}): lessonrecord[];
-/** Counts one reuse of a served lesson: the reuse count grows by one and the last used time moves to now while the lessons nobody serves stay exactly as they were. */
-export declare function lessonreuse(input: {
-    lessons: lessonrecord[];
-    id: string;
-    now: number;
-}): lessonrecord[];
-/** Decays the stale lessons: a lesson nobody reused for the whole user configured window retires from the serving list while the lessons still carrying reuse stay; an absent window keeps every lesson because the decay stays the user's choice. */
-export declare function lessondecay(input: {
-    lessons: lessonrecord[];
-    now: number;
-    stalewindow?: number;
-}): lessonrecord[];
-/** Opens one arbitration case of a contested resource and grants its first verdict: the case needs at least two requesting agents because one requester contests nothing, the first requester holds the resource by default, a requester of a higher priority lane takes the grant over the first requester, and the verdict names its lane and its reason for the audit trail. */
-export declare function arbitrationcaseof(input: {
-    id: string;
-    resource: string;
-    origin: string;
-    requesters: string[];
-    lanes: tasklane[];
-    now: number;
-}): arbitrationcase;
-/** Releases the verdict of one arbitration case when its holder finishes: the release frees the resource for the next requester and closes the case while a release without the finished holder refuses. */
-export declare function releasecase(input: {
-    cases: arbitrationcase[];
-    id: string;
-    holderfinished: boolean;
-    now: number;
-}): arbitrationcase;
-/** Ranks the queued tasks by the user configured lane priority: the sensitive tasks stay in the interactive lane whatever lane asked for them, the interactive lane always serves first, and every further lane serves one task per round robin cycle in its priority order so no lane starves behind a busy higher priority lane. */
-export declare function prioritylaneof(input: {
-    tasks: Array<{
-        id: string;
-        lane: string;
-        priority?: number;
-        sensitive?: boolean;
-        enqueuedat: number;
-    }>;
-    lanes: tasklane[];
-}): Array<{
-    id: string;
-    lane: string;
-    priority?: number;
-    sensitive?: boolean;
-    enqueuedat: number;
-}>;
-/** Builds one load report sample of an origin: the concurrency of the live workers and the latency of the waits freeze into one sample the scaleworkers pass reads. */
-export declare function loadreportof(input: {
-    origin: string;
-    concurrency: number;
-    latency: number;
-    now: number;
-}): loadreport;
-/** Reads the scaleworkers suggestions from the load reports: an origin whose load stays low suggests spawning one more worker, an origin whose latency passes the throttle threshold suggests pausing a worker, and every suggestion stays a suggestion because the spawn itself needs the user consent; absent thresholds hold the suggestions. */
-export declare function scalesuggestion(input: {
-    reports: loadreport[];
-    lowthreshold?: number;
-    throttlethreshold?: number;
-}): Array<{
-    origin: string;
-    suggestion: "spawn" | "pause" | "hold";
-    reason: string;
-}>;
-/** Builds one cost entry of the shared fleet ledger: the agent that caused the cost, the run it belongs to, the units it spent and the plain language description of what the units bought. */
-export declare function costentryof(input: {
-    agentid: string;
-    runid?: string;
-    units: number;
-    description: string;
-    now: number;
-}): costentry;
-/** Splits the shared costs of the fleet ledger to the agents that caused them: a cost one agent caused attributes fully to it while a cost several agents share through the same description splits equally among its causers, and every agent reads its own share. */
-export declare function sharedcostsplit(input: {
-    entries: costentry[];
-}): Array<{
-    agentid: string;
-    units: number;
-    share: number;
-    sharedwith?: string[];
-}>;
-/**
- * Multi agent lifecycle logic of the 1.1.58 family.
- * Every correlated rule for agent identities, roles, tab binding, sub agent spawning with depth limits, pause, resume, stop, the killswitch, per agent budgets and permission scopes, per agent usage and the swarm overview lives in this file.
- * The swarm never bypasses review: an agent claims queue tasks and proposes work through the same plan review a single agent passes, and the killswitch stays available with no configuration barrier.
- */
-/** The default tool namespaces of a role: planners compose and read, workers also act on the browser, critics review agent outputs read only, verifiers re-read the page to check claims and observers stay read only; a custom role grades with the worker defaults until the user narrows its scope. */
-export declare function roledefaults(role: agentrole): {
-    toolnamespaces: toolnamespace[];
-    description: string;
-};
-/** Registers one agent identity bound to a tab; the user names the agent for dashboards and audit, and one tab never holds two agents. */
-export declare function registeragent(input: {
-    agents: agentidentity[];
-    id: string;
-    name: string;
-    tabid?: number;
-    sessionid?: string;
-    role?: agentrole;
-    now: number;
-}): agentidentity[];
-/** Attaches one role to a registered agent; the role carries its defaults and the change reads in the audit trail. */
-export declare function assignrole(input: {
-    agents: agentidentity[];
-    agentid: string;
-    role: agentrole;
-    now: number;
-}): agentidentity[];
-/** Binds one agent to one tab session; a tab bound to another live agent refuses the binding, so one tab runs one agent. */
-export declare function opentabagent(input: {
-    agents: agentidentity[];
-    agentid: string;
-    tabid: number;
-    sessionid?: string;
-    now: number;
-}): agentidentity[];
-/** Spawns one sub agent under a spawn request; the child carries its parent, its depth and the requested role, and the spawn refuses recursion past the configured depth limit. */
-export declare function spawn(input: {
-    agents: agentidentity[];
-    request: spawnrequest;
-    limit: depthlimit;
-    id: string;
-    name?: string;
-    now: number;
-}): agentidentity[];
-/** Pauses one agent without stopping the others; a paused agent claims no task until its resume. */
-export declare function pauseone(input: {
-    agents: agentidentity[];
-    agentid: string;
-    now: number;
-}): agentidentity[];
-/** Resumes one paused agent; the other agents never changed. */
-export declare function resumeone(input: {
-    agents: agentidentity[];
-    agentid: string;
-    now: number;
-}): agentidentity[];
-/** Stops one agent; its claims release through the queue requeue pass. */
-export declare function stopone(input: {
-    agents: agentidentity[];
-    agentid: string;
-    now: number;
-}): agentidentity[];
-/** Triggers the killswitch and cancels every agent run at once: every agent stops whatever it holds and the switch records why. */
-export declare function killall(input: {
-    agents: agentidentity[];
-    reason?: string;
-    now: number;
-}): {
-    agents: agentidentity[];
-    killswitch: killswitch;
-};
-/** Disarms the killswitch so the user may register or resume agents again. */
-export declare function disarmkillswitch(now: number): killswitch;
-/** Checks one agent against its budget: a reached token, cost or step ceiling halts the agent until the user raises the ceiling; absent ceilings never halt. */
-export declare function agentbudgetcheck(input: {
-    agent: agentidentity;
-    usage: agentusage | undefined;
-}): {
-    halted: boolean;
-    reason?: string;
-};
-/** Checks one agent scope: an origin or a tool namespace outside the grant refuses, and an absent scope stays unbounded inside the session grants. */
-export declare function scopegate(input: {
-    scope: agentscope | undefined;
-    origin?: string;
-    namespace?: toolnamespace;
-}): {
-    allowed: boolean;
-    reason?: string;
-};
-/** Refreshes one agent heartbeat so the panel and the queue read a live agent. */
-export declare function agentheartbeat(input: {
-    agents: agentidentity[];
-    agentid: string;
-    now: number;
-}): agentidentity[];
-/** Accumulates one usage delta into the per agent usage counters held against the agent budget. */
-export declare function recordagentusage(input: {
-    usage: agentusage | undefined;
-    agentid: string;
-    tokens?: number;
-    cost?: number;
-    steps?: number;
-    now: number;
-}): agentusage;
-/** Builds one per agent run context that reuses the workflow engine: the run id carries the agent and the task so concurrent agent runs stay isolated through the same run records the workflow engine keeps. */
-export declare function agentruncontext(input: {
-    agent: agentidentity;
-    task: taskitem;
-    now: number;
-}): {
-    agentid: string;
-    taskid: string;
-    run: workflowrun;
-};
-/** Builds one agent lifecycle event notification for the protocol envelope and the audit trail. */
-export declare function agenteventof(input: {
-    id: string;
-    kind: agenteventkind;
-    summary: string;
-    agentid?: string;
-    taskid?: string;
-    now: number;
-}): agentevent;
-/** Returns the swarm at a glance: the agents with their live states, the tasks by claim state and the message counters. */
-export declare function swarmoverview(input: {
-    agents: agentidentity[];
-    queue: taskqueue;
-    mailboxes: agentmailbox[];
-}): {
-    agents: number;
-    active: number;
-    paused: number;
-    stopped: number;
-    tasks: number;
-    queued: number;
-    claimed: number;
-    done: number;
-    cancelled: number;
-    messages: number;
-    unread: number;
-};
-/** Reads the swarm state snapshot the protocol envelope and the panel render: the agents, the queue, the mailboxes and the killswitch. */
-export declare function swarmstateof(input: {
-    agents: agentidentity[];
-    queue: taskqueue;
-    mailboxes: agentmailbox[];
-    killswitch: killswitch;
-}): swarmstate;
-/**
- * Multi agent coordination logic of the 1.1.59 family.
- * Every correlated rule for tab handoffs between agents mid run, resource locks keyed by one origin and one selector, conflict scans of overlapping writes, result merging with conflict rules and provenance, output comparison, the interleaved swarm timeline, verified lessons on the blackboard, the aggregate report across agents, the shared cost accounting and the replay of one agent run from the audit trail lives in this file.
- * Coordination never bypasses review: a handoff preserves the original session grants, a lock only serializes work the same review already approved and every merged report that includes page content grades as an egress event on export.
- */
-/** Composes the lock key of exactly one origin and one selector; a lock never spans unrelated origins because the key names one target of one origin. */
-export declare function lockkey(origin: string, selector: string): string;
-/** Packages one tab handoff for transfer: the transferring agent names the receiving agent, the tab and the task state in plain language; the record waits prepared until its transfer. */
-export declare function preparehandoff(input: {
-    agents: agentidentity[];
-    id: string;
-    fromagentid: string;
-    toagentid: string;
-    taskstate: string;
-    tabid?: number;
-    reason?: string;
-    now: number;
-}): handoffrecord;
-/** Moves one tab binding between agents: the prepared handoff transfers the tab from the transferring agent to the receiving agent under the one agent per tab rule, and the record marks the transfer. */
-export declare function transferhandoff(input: {
-    agents: agentidentity[];
-    handoffs: handoffrecord[];
-    id: string;
-    now: number;
-}): {
-    agents: agentidentity[];
-    handoffs: handoffrecord[];
-};
-/** Continues one transferred task from its packaged state: the receiving agent owns the task from the recorded task state and the record marks the resume. */
-export declare function resumehandoff(input: {
-    handoffs: handoffrecord[];
-    id: string;
-    now: number;
-}): handoffrecord;
-/** Acquires one resource lock keyed by one origin and one selector: an exclusive lock refuses every second holder while a shared lock admits further shared holders only; a held key refuses the newcomer whatever the kinds. */
-export declare function acquirelock(input: {
-    locks: resourcelock[];
-    holder: string;
-    origin: string;
-    selector: string;
-    kind?: "exclusive" | "shared";
-    expiresat?: number;
-    now: number;
-}): {
-    locks: resourcelock[];
-    acquired: boolean;
-    reason: string;
-};
-/** Releases one lock with the holder named: the freed key returns to the pool for the next agent. */
-export declare function releaselock(input: {
-    locks: resourcelock[];
-    key: string;
-    holder: string;
-    now: number;
-}): {
-    locks: resourcelock[];
-    released: boolean;
-};
-/** Returns the abandoned locks to the pool: a lock past its user configured expiry releases on the sweep while a lock without an expiry never expires. */
-export declare function expirelocks(input: {
-    locks: resourcelock[];
-    now: number;
-}): {
-    locks: resourcelock[];
-    expired: string[];
-};
-/** Scans the parallel writes for overlapping targets before the runs start: two writers on the same origin and selector overlap, the scan lists the overlapping targets with their writers and the suggested ordering keeps the writers deterministic by agent id. */
-export declare function scanconflicts(input: {
-    id: string;
-    writers: conflictwriter[];
-    now: number;
-}): conflictscan;
-/** Folds the parallel results into one report with conflict rules: the entries group by key, first keeps the earliest value, last keeps the latest, preferagent keeps the value of the agent the user named and fail refuses the fold on any conflict; every merged value keeps its provenance and every conflict lands its resolution note. */
-export declare function mergeresults(input: {
-    entries: mergeentry[];
-    rule: mergerule;
-    preferagent?: string;
-    now: number;
-}): {
-    entries: mergeentry[];
-    conflicts: string[];
-    refused: boolean;
-};
-/** Builds the final report across agents: the outputs fold under the merge rule the user picked, the sections group by task and every section keeps the agent sources of its entries with the provenance. */
-export declare function swarmreport(input: {
-    id: string;
-    title: string;
-    outputs: mergeentry[];
-    rule: mergerule;
-    preferagent?: string;
-    confidence?: string;
-    now: number;
-}): {
-    report: resultreport;
-    conflicts: string[];
-    refused: boolean;
-};
-/** Contrasts the competing agent outputs for the user: the comparison lists every output with its agent and names the keys where the agents disagree. */
-export declare function compareoutputs(input: {
-    id: string;
-    subject: string;
-    outputs: Array<{
-        agentid: string;
-        value: string;
-    }>;
-    now: number;
-}): outputcomparison;
-/** Interleaves the actions of every agent into one stream: the actions order by time and the ties keep their arrival order, so one timeline reads the whole swarm. */
-export declare function interleavetimeline(actions: swarmaction[]): swarmaction[];
-/** Writes one verified lesson to the blackboard: the lesson lands in the findings section under its own key with the agent and its verifier named, so every agent of the swarm reads it. */
-export declare function sharelesson(input: {
-    board: blackboard;
-    id: string;
-    agentid: string;
-    statement: string;
-    verifiedby: string;
-    section?: blackboardsection;
-    consentclass?: actionrisk;
-    now: number;
-}): blackboard;
-/** Sums the per agent usage into the swarm totals of the shared cost accounting: tokens, cost and steps of every agent in one record. */
-export declare function swarmcosts(input: {
-    usage: agentusage[];
-    currency?: string;
-    now: number;
-}): swarmcost;
-/** Rebuilds one agent run from the audit trail: the actions that name the agent order by time into one replay stream the panel scrolls. */
-export declare function replayagentrun(input: {
-    events: Array<{
-        id: string;
-        kind: string;
-        summary: string;
-        at: number;
-        agentid?: string;
-    }>;
-    agentid: string;
-}): swarmaction[];
-//# sourceMappingURL=agent.d.ts.map