@leuduan/lagent 0.1.2 → 44.0.0

package/dist/loop/completion.d.ts

@@ -0,0 +1,17 @@
+import type { ModelRoute } from '../llm/provider.js';
+import type { Seq, ThreadEnvironment } from '../records/journal.js';
+import type { CompletionRequest } from './hooks.js';
+import type { LoopRuntime } from './runtime.js';
+/** Dispatches a pure completion plan once, under its candidate's durable identity and current policy. */
+export declare function prepareCompletion(options: {
+    runtime: LoopRuntime;
+    threadId: string;
+    agentName: string;
+    environment: ThreadEnvironment;
+    route: ModelRoute;
+    turn: number;
+    candidateSeq: Seq;
+    request: CompletionRequest;
+    signal: AbortSignal;
+    validate(): void;
+}): Promise<'settled' | 'blocked'>;

package/dist/loop/errors.d.ts

@@ -1,6 +1,5 @@
 import type { ReadonlyJsonValue } from '../util/json.js';
-import type { Refusal } from './inbox.js';
-import type { ReplacementRule, RowRef } from './surface.js';
+import type { Refusal, RowRef } from '../state/index.js';
 /** What holds a thread while an operation on it is refused busy. */
 export type ThreadHolding = 'run' | 'compact' | 'rebuild' | 'configure' | 'release' | 'cancel';
 /** A human's answer to an approval request. */
@@ -13,12 +12,10 @@ export declare class UnknownAgentError extends ReferenceError {
     readonly agentName: string;
     constructor(agentName: string);
 }
-/** No thread has this id. */
-export declare class UnknownThreadError extends ReferenceError {
-    readonly threadId: string;
-    constructor(threadId: string);
-}
-/** A turn is already running on this thread; one driver at a time. */
+/**
+ * An operation already holds this thread: a run, compaction, prompt rebuild, configuration change,
+ * release or cancel (`holding`), admitted one at a time.
+ */
 export declare class ThreadBusyError extends Error {
     readonly threadId: string;
     readonly holding?: ThreadHolding;
@@ -48,7 +45,7 @@ export declare class StaleActivation extends Error {
     constructor();
 }
 /**
- * Thrown by a judgment whose fence broke while the activation stayed valid (`LoopAgent.fenced`): a
+ * Thrown by a judgment whose fence broke while the activation stayed valid (`TurnRunner.fenced`): a
  * required registration is gone or was replaced, or a fact a stop check declared it observed
  * changed. The turn ends `interrupted` (`judgment-invalidated`), the answer still owed its checks.
  */
@@ -60,12 +57,6 @@ export declare class RecordedTurnFailure extends Error {
     readonly cause: unknown;
     constructor(cause: unknown);
 }
-/** A fork was asked for at a row it cannot be cut at; nothing was appended. */
-export declare class ForkCutError extends Error {
-    readonly threadId: string;
-    readonly seq: number;
-    constructor(threadId: string, seq: number, reason: string);
-}
 /** What a thread's recorded birth says about one field of a request that differs from it. */
 export type BirthConflict = {
     readonly field: 'agent' | 'origin' | 'kind' | 'cut' | 'route' | 'environment' | 'installations' | 'requires';
@@ -123,20 +114,6 @@ export declare class ThreadUnsettledError extends Error {
     readonly threadId: string;
     constructor(threadId: string, reason: string);
 }
-/**
- * A replacement `replaceSurface` refused: it breaks a rule of the surface it would land on (see
- * `judgeReplacement`). Nothing of its group was recorded. Distinct from any other failure, so a
- * strategy can tell a plan the surface refused from a journal that could not write.
- */
-export declare class ReplacementRefusedError extends Error {
-    readonly index: number;
-    readonly rule: ReplacementRule;
-    constructor(message: string, 
-    /** The refused replacement's position in the group it was offered with. */
-    index: number, 
-    /** The surface rule it breaks. */
-    rule: ReplacementRule);
-}
 /**
  * A thread whose surface refused a replacement row, one written past `replaceSurface`: a bug or a
  * hand-edited store. Its history can be read, and forked before that row, but nothing executes on

package/dist/loop/hooks.d.ts

@@ -1,7 +1,12 @@
-import type { AgentDefinition, ExtensionRecord, JournalEvent, JournalEventInput, QueuedInput, Seq, StepContribution, StepContributionInput, TurnRejection } from '../models/index.js';
-import type { ModelCallClient, ModelRequest, ModelRoute, ParsedToolCall, RequestPurpose, ResponseFinish, StreamingLLMResponse, ThinkingEffort } from '../llm/index.js';
+import type { AgentDefinition } from './agent.js';
+import type { ExtensionRecord, JournalEvent, JournalEventInput, QueuedInput, Seq, StepContribution, StepContributionInput, TurnRejection } from '../records/journal.js';
+import type { ModelCallClient } from '../llm/failure.js';
+import type { JsonObject, ParsedToolCall, ResponseFinish, ThinkingEffort } from '../llm/primitives.js';
+import type { ModelRequest, RequestPurpose } from '../llm/request.js';
+import type { ModelRoute } from '../llm/provider.js';
+import type { StreamingLLMResponse } from '../llm/client.js';
 import type { LoopRuntime } from './runtime.js';
-import type { RowRef } from './surface.js';
+import type { RowRef } from '../state/index.js';
 import type { InvocationContext, Tool, ToolOutcome } from './tool.js';
 /**
  * Every point at which the loop hands control to a plugin.
@@ -24,6 +29,12 @@ export interface ToolAuthorizationRequest {
     readonly toolCall: ParsedToolCall;
     readonly agent: AgentDefinition;
     readonly threadId: string;
+    /** Runtime provenance is explicit; an absent origin is an ordinary model tool call. */
+    readonly origin?: {
+        readonly owner: string;
+        readonly candidateSeq: Seq;
+        readonly requestSeq: Seq;
+    };
 }
 /** A denial that tells the model why, so it can change course rather than retry the call. */
 export interface ToolDenial {
@@ -147,6 +158,18 @@ export type StopVerdict = {
     decision: 'reject';
     reason: string;
     source: ExtensionRecord;
+} | {
+    decision: 'prepare';
+    request: CompletionRequest;
+};
+/** A pure plan. Core owns its durable dispatch after every stop check permits preparation. */
+export type CompletionRequest = {
+    readonly owner: string;
+    readonly key: string;
+    readonly operation: {
+        readonly name: string;
+        readonly arguments: JsonObject;
+    };
 };
 /** What the checks concluded together. */
 export type StopJudgement = {
@@ -157,16 +180,26 @@ export type StopJudgement = {
 } | {
     kind: 'reject';
     rejections: TurnRejection[];
+} | {
+    kind: 'prepare';
+    requests: CompletionRequest[];
 };
 /**
  * Asks every stop check about an answer. The outcome is independent of registration order: any
- * rejection ends the turn, otherwise any continuation sends the model back, otherwise the answer
- * is accepted. A throwing check, or an invalid verdict, fails the check without deciding anything.
+ * rejection ends the turn, otherwise any continuation sends the model back, otherwise a preparation
+ * plan runs before rejudgment, otherwise the answer is accepted. A throwing check, or an invalid
+ * verdict, fails the check without deciding anything.
  * The facts the checks declare they observed collect in `observations`, which the caller validates
  * when it records the outcome.
  */
 export declare function judgeAnswer(runtime: LoopRuntime, stop: Omit<TurnStop, 'observe'>, observations: StopObservation[]): Promise<StopJudgement>;
-/** Runs a tool through its listeners. One that does not call `next()` has answered the call itself. */
+/**
+ * Runs `use` with the confinement operation of one tool execution, opened for it and ended when it
+ * settles, whatever it did: the file access its tool was given dies with the call, and what it still
+ * had open is closed.
+ */
+export declare function withOperation<T>(runtime: LoopRuntime, threadId: string, signal: AbortSignal, use: (operation: InvocationContext['operation']) => Promise<T>): Promise<T>;
+/** Runs middleware and binds its final result to the dispatched call, for every execution path. */
 export declare const executeTool: (runtime: LoopRuntime, invocation: ToolInvocation, run: () => Promise<ToolOutcome>) => Promise<ToolOutcome>;
 /**
  * A model request as `lagent/llm/request` middleware sees it. The turn's route is fixed, so `model`

package/dist/loop/index.d.ts

@@ -1,37 +1,16 @@
 /**
- * What the rest of the package may use from the loop.
- *
- * Journal operations (projections, inbox, recovery) need no execution runtime. A live thread
- * activation drives execution through LoopAgent; plugins extend it through tools and hooks.
+ * What the rest of the package may use from the loop: live execution against an activation. A live
+ * thread activation drives execution through TurnRunner; plugins extend it through tools and hooks.
+ * What the journal records, without a runtime, is `state/`.
  */
-export * from './projections.js';
-export * from './surface.js';
-export * from './threadState.js';
 export * from './chunks.js';
 export * from './errors.js';
-export * from './limits.js';
 export * from './runtime.js';
-export { Inbox } from './inbox.js';
-export { isVeto } from './inbox.js';
-export type { BirthSpec, ForkOpening, FreshOpening } from './opening.js';
-export type { Refusal, RowsResult, RowsWrite, InputReceipt, SendOptions, SendOutcome, WithdrawOptions, WithdrawOutcome, WithdrawRows, WriteRows, } from './inbox.js';
-export { closeInterruptedTurn, hasThreadWork, inputFate, lastAssistantMessage, refusedReplacement, unfinishedConfirmations, } from './state.js';
-export type { InputFate } from './state.js';
-export * from './summary.js';
-export * from './requests.js';
-export { chainStanding } from './chain.js';
-export type { ChainStanding } from './chain.js';
-export * from './wake.js';
-export * from './route.js';
-export * from './holds.js';
-export * from './continuation.js';
-export * from './forks.js';
 export * from './hooks.js';
 export type { AuxiliaryCall, AuxiliaryReply } from './auxiliary.js';
-export { replaceSurface } from './replace.js';
-export type { ReplacementContext, ReplacementInput } from './replace.js';
+export * from './agent.js';
 export * from './strategy.js';
 export * from './tool.js';
-export { declarePolicyState, errorResult } from './toolCalls.js';
-export { LoopAgent } from './agent.js';
-export type { CompactOptions, ServedRun } from './agent.js';
+export { declarePolicyState } from './authorization.js';
+export { TurnRunner } from './runner.js';
+export type { CompactOptions, ServedRun } from './runner.js';

package/dist/loop/runner.d.ts

@@ -0,0 +1,134 @@
+import type { Seq, TurnEndReason } from '../records/journal.js';
+import type { DeepReadonly, JsonValue } from '../util/json.js';
+import type { SurfacePrepareOutcome } from './hooks.js';
+import type { Lease, LoopRuntime } from './runtime.js';
+/**
+ * What one `compact()` is given: a cancellation signal, and options for the strategy, which the
+ * engine passes on as they are and never reads.
+ */
+export type CompactOptions = {
+    readonly signal?: AbortSignal;
+    readonly options?: JsonValue;
+};
+/**
+ * The run request an execution serves, as its turns see it: the id every `turn/start` records, the
+ * attempt cutoff of the execution, and the continuation decision, asked after each turn whether to
+ * open another.
+ */
+export type ServedRun = {
+    readonly id: string;
+    readonly attemptCutoff: Seq;
+    continueAfter(ending: DeepReadonly<TurnEndReason>, turnStart: Seq): boolean;
+};
+/** Executes journal-driven turns. Admission, readiness and cancellation ownership live outside the loop. */
+export declare class TurnRunner {
+    private readonly runtime;
+    private readonly threadId;
+    private readonly agentName;
+    private readonly inbox;
+    constructor(options: {
+        runtime: LoopRuntime;
+        threadId: string;
+        agentName: string;
+    });
+    private stepsTaken;
+    /**
+     * The caller already owns the lease, has resolved the agent in a ready runtime, has decided the
+     * run should advance, and supplies a combined turn signal and the run it serves. Opens a turn,
+     * then another for as long as the run's continuation decision says to advance.
+     */
+    run(options: {
+        signal: AbortSignal;
+        lease: Lease;
+        served: ServedRun;
+    }): Promise<void>;
+    /**
+     * One turn: decide, do it, append what happened, decide again.
+     *
+     * Every branch of the decision lives in {@link nextAction}; this only carries out what it asked
+     * for.
+     */
+    private turn;
+    /**
+     * Why a judgment made under `fence` may not stand, or `null` when it does. `activation-changed`:
+     * the activation's plugins changed since readiness, and takes precedence. `judgment-invalidated`:
+     * the constraint registrations the thread requires, by origin too, are not those it was judged
+     * under, one missing or replaced, or a fact a check declared it observed reads differently now.
+     * Such a registration's owner, or a plugin of the activation, can be the checker that would
+     * object, and core accepts whatever no check objects to; one that came back meanwhile did not
+     * judge it; and a verdict resting on a fact that moved while another check awaited is no verdict
+     * on the answer as it stands. Read inside the write that records the judgment.
+     */
+    private fenced;
+    /**
+     * Records how a judged turn ends, `ending` the checks' verdict or their failure, decided inside
+     * the write: one whose fence broke ends the turn `interrupted` instead, the answer still owed its
+     * checks, so a later run judges it again, held while a required owner is missing, rather than
+     * accepting it unchecked or failing the task because its checker was briefly gone or a fact it
+     * read moved. Returns the reason recorded.
+     */
+    private endJudged;
+    /**
+     * Records `turn/start` with the thread's route and the run the turn serves, decided in the write's
+     * builder, the turn's opening point: a cancel that landed while the loop awaited opens nothing,
+     * and a route whose provider is not registered opens nothing either, claims no input, and throws
+     * `RouteUnavailableError`, which fails the run before the turn. A provider lost once the row is
+     * built, its append still waiting on storage included, fails the opened turn.
+     *
+     * The route is the turn's for good, since every model step builds its client from it; it cannot
+     * change under an execution, which holds the thread while its request is pending.
+     */
+    private openTurn;
+    /** The thread's route as its rows stand. */
+    private threadRoute;
+    /**
+     * Asks the thread's strategy for a plan for a caller between turns (the `request` trigger): no turn
+     * opens, no step hook runs and no queued input is claimed; the route is resolved as a turn's would
+     * be. The caller owns the lease, as for a run, and composed the signal as a run's is. An
+     * interrupted open turn is closed first, as a run closes it; a thread with a tool call unanswered,
+     * a confirmation open or an answer unjudged is refused with `ThreadUnsettledError`. Resolves with
+     * the outcome, cancellation included.
+     */
+    compact(options: {
+        signal: AbortSignal;
+        lease: Lease;
+        options: JsonValue | null;
+    }): Promise<SurfacePrepareOutcome>;
+    /** One request to the thread's strategy, carried out by the engine. */
+    private prepare;
+    /**
+     * Asks the stop checks about the provisional answer. Returns how the turn ends — accepted as
+     * `completed`, or `rejected` — or `null` once their continuation messages are recorded.
+     *
+     * An acceptance ends the turn at once. Steering that arrived while the checks ran is still in the
+     * `next-step` inbox, and `run()` opens another turn for it.
+     */
+    private judge;
+    /**
+     * Lets the surface be prepared (`pressure`), then records plugin contributions and the claimed
+     * input, then asks the model.
+     *
+     * The dispatch is the first `await` between deciding this step and recording its input, and the
+     * lease does not exclude `send()` or `withdraw()`. So once it settles the signal is checked and the
+     * inbox read again: only input this step was decided on that is still queued is claimed, so a
+     * withdrawn input stays withdrawn, and input that arrived meanwhile waits for the next step. A step
+     * left with nothing to claim and no reply owed ends without a model call, and the decider decides
+     * again.
+     */
+    private askModel;
+    /** Reports a dispatch a listener ended in failure; one that was cancelled is the turn's to report. */
+    private reportFailedDispatch;
+    /** Runs a step's tool calls. What they did — answered, waited, ended the turn — lands in the journal. */
+    private answerCalls;
+    /**
+     * One model call. What it produced goes to the journal — `assistant/message`, or
+     * `assistant/attempt` when the stream gave nothing usable, which keeps it off the conversation.
+     *
+     * A request the provider refused as longer than the context window is recorded as an attempt
+     * marked `overflow`, and the thread's strategy is asked with `overflow` inside this step, before
+     * any `error` row. The rule is one sentence: an overflow fails the turn unless that request
+     * committed a replacement, however it ended. When it did, the step ends without an error and the
+     * decider asks the model again, from the replaced surface, in a new step.
+     */
+    private callModel;
+}

package/dist/loop/runtime.d.ts

@@ -1,13 +1,15 @@
 import type { Context, Scoped } from '@leuduan/cordis';
-import type { ModelCallClient, ModelRoute, ThinkingEffort, ToolSpec } from '../llm/index.js';
+import type { ModelCallClient } from '../llm/failure.js';
+import type { ModelRoute, ModelSelection } from '../llm/provider.js';
+import type { ToolSpec } from '../llm/primitives.js';
 import type { DeepReadonly } from '../util/json.js';
 import type { Journal } from '../journal/index.js';
-import type { AgentDefinition } from '../models/index.js';
+import type { AgentDefinition } from './agent.js';
 import type { ChunkChannel } from './chunks.js';
-import type { TurnLimits } from './limits.js';
+import type { TurnLimits } from '../state/index.js';
 import type { SurfaceStrategy } from './strategy.js';
 import type { Tool } from './tool.js';
-/** Anything advertised to the model — a builtin tool or a sub-agent. */
+/** Anything advertised to the model — a registered tool or a sub-agent. */
 export type ToolEntry = {
     readonly name: string;
     readonly tool: Tool;
@@ -17,17 +19,6 @@ export type ToolEntry = {
      */
     readonly spec: DeepReadonly<ToolSpec>;
 };
-/**
- * Route fields to fold over a route (`LlmService.resolveRoute`): absent fields keep the route's own;
- * naming a different provider resets what is left unnamed to that provider's defaults. A `null`
- * effort names the provider's own default, as a route records it, so a complete route resolves to
- * itself.
- */
-export type ModelSelection = {
-    readonly provider?: string;
-    readonly model?: string;
-    readonly thinkingEffort?: ThinkingEffort | null;
-};
 /**
  * What the loop runs against.
  *
@@ -72,7 +63,7 @@ export interface LoopRuntime extends LoopServices {
      * new once they have, and ends the turn as `interrupted` at its next boundary.
      */
     stale(): boolean;
-    /** The strategy that prepares the thread's surface, if one is provided (`provideStrategy`). */
+    /** The strategy that prepares the thread's surface, if one is provided (`registerSurfaceStrategy`). */
     strategy(): SurfaceStrategy | undefined;
 }
 /**

package/dist/loop/strategy.d.ts

@@ -1,8 +1,9 @@
-import type { ExtensionRecord, QueuedInput, ReplacementTrigger } from '../models/index.js';
+import type { Context } from '@leuduan/cordis';
+import type { ExtensionRecord, QueuedInput, ReplacementTrigger } from '../records/journal.js';
 import type { JsonValue } from '../util/json.js';
-import type { ModelRoute } from '../llm/index.js';
+import type { ModelRoute } from '../llm/provider.js';
 import type { AuxiliaryCall, AuxiliaryReply } from './auxiliary.js';
-import type { ReplacementInput } from './replace.js';
+import type { ReplacementInput } from '../state/index.js';
 /** What a strategy is told about one request to prepare the surface. */
 export type SurfacePrepareInput = {
     readonly threadId: string;
@@ -69,3 +70,11 @@ export interface SurfaceStrategy {
     readonly name: string;
     plan(input: SurfacePrepareInput): SurfacePlan | Promise<SurfacePlan>;
 }
+/**
+ * Makes `strategy` the one that prepares `threadId`'s surface, for as long as the calling plugin's
+ * fiber lives. A thread runs one strategy: a second, from another mount or installation, throws, so
+ * the plugin that came later fails, and with it the activation, rather than running beside the first.
+ */
+export declare function registerSurfaceStrategy(ctx: Context, threadId: string, strategy: SurfaceStrategy): void;
+/** The strategy that prepares `threadId`'s surface, if any. */
+export declare function strategyOf(ctx: Context, threadId: string): SurfaceStrategy | undefined;

package/dist/loop/{prepare.d.ts → surfacePrepare.d.ts}

@@ -1,6 +1,6 @@
-import type { QueuedInput, ReplacementTrigger } from '../models/index.js';
+import type { QueuedInput, ReplacementTrigger } from '../records/journal.js';
 import type { JsonValue } from '../util/json.js';
-import { type ModelRoute } from '../llm/index.js';
+import { type ModelRoute } from '../llm/provider.js';
 import type { SurfacePrepareOutcome } from './hooks.js';
 import type { Lease, LoopRuntime } from './runtime.js';
 /** One request to prepare the surface, as the loop or `thread.compact()` starts it. */

package/dist/loop/tool.d.ts

@@ -1,7 +1,12 @@
 import type { Context } from '@leuduan/cordis';
-import type { InterruptionPolicy, JsonValue, Seq, ThreadEnvironment, ToolResult } from '../models/index.js';
+import type { InterruptionPolicy, Seq, ThreadEnvironment } from '../records/journal.js';
+import type { JsonValue } from '../util/json.js';
+import type { ToolResult } from '../records/toolResult.js';
 import type { ReadonlyJsonValue } from '../util/json.js';
-import type { ModelRoute, ParsedToolCall, ToolSpec } from '../llm/index.js';
+import type { ModelRoute } from '../llm/provider.js';
+import type { ParsedToolCall, ToolCall, ToolSpec } from '../llm/primitives.js';
+/** An error result answering the dispatched call. */
+export declare const errorResult: (call: ToolCall, output: string) => ToolResult;
 /**
  * How a tool's calls may overlap. `exclusive` forms a barrier: it starts only once the calls before
  * it have settled, and nothing starts beside it.
@@ -39,7 +44,7 @@ export type ResolvedWait = {
     };
 };
 /**
- * What a tool implements. `defineTool` in `kit/tool.ts` builds one, with validation and timing; this
+ * What a tool implements. `defineTool` in `services/tools.ts` builds one, with validation and timing; this
  * is the contract underneath it.
  */
 export interface Tool {
@@ -75,14 +80,14 @@ export interface InvocationContext {
     readonly threadId: string;
     readonly callId: string;
     /**
-     * The `tool/call` row this invocation answers. The durable identity of the dispatch: unique in the
-     * journal and kept across a re-dispatch, where a provider's `callId` may be neither.
+     * The `tool/call` or runtime `execution/requested` row this invocation serves. The durable
+     * identity of the dispatch: unique in the journal, where a provider's `callId` may not be.
      */
     readonly callSeq: Seq;
     /**
      * The `llm/request` row that produced this call: exactly what the model was sent when it asked.
      * Where a tool that forks this thread cuts, so the fork shares that request's cached prefix.
-     * `null` only for a reply recorded without its request, which the loop never writes.
+     * `null` for runtime completion preparation, which has no model request.
      */
     readonly requestSeq: Seq | null;
     /** Where this thread's work happens. */

package/dist/loop/toolCalls.d.ts

@@ -1,5 +1,6 @@
-import type { ExtensionRecord, ThreadEnvironment, ToolResult } from '../models/index.js';
-import type { ModelRoute, ToolCall } from '../llm/index.js';
+import type { ThreadEnvironment } from '../records/journal.js';
+import type { ToolCall } from '../llm/primitives.js';
+import type { ModelRoute } from '../llm/provider.js';
 import type { LoopRuntime } from './runtime.js';
 export type ExecuteToolCallsOptions = {
     runtime: LoopRuntime;
@@ -13,8 +14,6 @@ export type ExecuteToolCallsOptions = {
     calls: readonly ToolCall[];
     signal: AbortSignal;
 };
-/** An error result for a call. */
-export declare const errorResult: (call: ToolCall, output: string) => ToolResult;
 /**
  * Runs one step's tool calls.
  *
@@ -34,9 +33,3 @@ export declare const errorResult: (call: ToolCall, output: string) => ToolResult
  * disagreeing.
  */
 export declare function executeToolCalls(options: ExecuteToolCallsOptions): Promise<void>;
-/**
- * Declares the `ext` rows of one plugin event state a `lagent/tool/authorize` listener decides
- * from: one that lands while a call is authorized sends the decision round again, which no other
- * `ext` row does. `defineExtensionEvent({ policyState: true })` is the way in.
- */
-export declare function declarePolicyState(record: Pick<ExtensionRecord, 'plugin' | 'instance_id' | 'kind'>): void;

package/dist/plugin.d.ts

@@ -1,53 +1,50 @@
 /**
- * The plugin-authoring kit: what a plugin imports beside `@leuduan/cordis`.
+ * The plugin-authoring door: what a plugin imports beside `@leuduan/cordis`.
  *
  * Registering a tool, an agent or a prompt contribution; granting a tool; defining, mounting and
  * validating the configuration of a preset (`definePreset`, `mountPreset`, `parsePresetConfig`), and
  * handing one down to the children a thread's calls create (`handDown`);
  * defining a durable `ext` event, writing it beside a send or a creation (`WriteRows`), and reading what a thread was
  * told; defining a set of durable modes (`defineModes`); adding a typed value to every thread's catalog entry (`defineContribution`); claiming a thread for one plugin, refusing a mount in a thread's scope (`requireUnscoped`)
- * and refusing a missing root service (`requireService`); running a process, reading paths and git as
- * the shipped tools do (`sys/`);
+ * and refusing a missing root service (`requireService`); reading paths and git as the shipped tools
+ * do (`sys/`). A tool touches files and starts processes through `InvocationContext.operation`, so the
+ * confinement policy judges them; the raw process launches (`spawnCommand`, `runToCompletion`) are on
+ * the root door, for the host's own processes;
  * the contracts a tool and a step hook implement; and the `ctx.*` service types every plugin reads.
  * A value lives on one door: the application API is the root entry point, the model contracts are
  * `@leuduan/lagent/llm`, the serialized shapes (`JournalEvent`, `Seq`, `ToolResult`, `stepContribution`,
- * `toJsonSchema`) are `@leuduan/lagent/models`.
+ * `toJsonSchema`) are `@leuduan/lagent/records`.
  */
 export * from './context.js';
-export { defineTool, errorResult, provideTool } from './kit/tool.js';
-export type { JsonSchemaParameters, ToolDefinition, ToolReply } from './kit/tool.js';
-export { grantTool } from './kit/grants.js';
-export { drainBeforeUnload } from './kit/drain.js';
-export { defineModes } from './kit/modes.js';
-export type { Modes, ModesDefinition } from './kit/modes.js';
-export { AgentSelectorSchema, isScopedAgentName, requireUnscoped, selects } from './kit/scope.js';
-export { requireService } from './kit/service.js';
-export type { AgentSelector } from './kit/scope.js';
-export { registerAgent } from './services/agents.js';
-export { definePreset, mountPreset, parsePresetConfig } from './services/preset.js';
-export type { Preset, PresetInstallation, PresetMountOptions, PresetPlace, PresetPlacement, PresetSelection, } from './services/preset.js';
-export { handDown } from './services/presets.js';
-export type { HandDown } from './services/presets.js';
-export type { AgentDefinition, AgentDefinitionInput } from './models/index.js';
+export { defineTool, errorResult, grantTool, registerTool } from './services/tools.js';
+export type { JsonSchemaParameters, ToolDefinition, ToolReply } from './services/tools.js';
+export { claimThread, drainBeforeUnload, requireService, requireUnscoped } from './services/plugins.js';
+export { defineModes } from './services/modes.js';
+export type { Modes, ModesDefinition } from './services/modes.js';
+export { AgentSelectorSchema, isScopedAgentName, registerAgent, selects } from './services/agents.js';
+export type { AgentSelector } from './services/agents.js';
+export { definePreset, mountPreset, parsePresetConfig } from './services/presets/definition.js';
+export type { Preset, PresetInstallation, PresetMountOptions, PresetPlace, PresetPlacement, PresetSelection, } from './services/presets/definition.js';
+export { handDown } from './services/presets/installations.js';
+export type { HandDown } from './services/presets/installations.js';
+export type { AgentDefinition, AgentDefinitionInput } from './loop/index.js';
 export { contributePrompt } from './services/prompts.js';
-export { defineContribution } from './services/contributions.js';
-export type { ContributionDefinition, ContributionReading } from './services/contributions.js';
+export { defineContribution } from './services/catalogContributions.js';
+export type { ContributionDefinition, ContributionReading } from './services/catalogContributions.js';
 export type { PromptContribution, PromptRenderInput, PromptSlot } from './services/prompts.js';
-export { ExtensionVersionError, defineExtensionEvent, latestNotice, latestVisible, tellOnStep, } from './kit/extension.js';
-export type { NoticeEvent, StepNotice, ToldNotice, ToldNotices } from './kit/extension.js';
+export { ExtensionVersionError, defineExtensionEvent, latestNotice, latestVisible, tellOnStep, } from './services/extensionEvents.js';
+export type { NoticeEvent, StepNotice, ToldNotice, ToldNotices } from './services/extensionEvents.js';
 export { ProjectionFailedError, projection } from './journal/index.js';
 export type { AppendOptions, Committed, PluginJournal, PluginProjection, Transaction } from './journal/index.js';
 export type { CallerChain, OriginBreak, OriginOpening, Origins, RequiredOwner, RequiredOwners, } from './journal/index.js';
-export type { BirthSpec, ForkOpening, FreshOpening, Refusal, RowsResult, RowsWrite, WriteRows } from './loop/index.js';
-export { isWaitRequest, lastAssistantMessage, waitFor } from './loop/index.js';
-export { provideStrategy } from './kit/strategy.js';
-export type { AuxiliaryCall, AuxiliaryReply, InvocationContext, ModelRequestDraft, ModelStep, SentModelRequest, SentRequest, ReplacementInput, StopVerdict, AuxiliaryAnswer, FinalPlan, SurfacePlan, SurfacePrepareInput, SurfaceStrategy, Tool, ToolAuthorizationRequest, ToolDenial, ToolEntry, ToolExecutionMode, ToolInvocation, ToolOutcome, ToolPolicyDecision, TurnStop, WaitRequest, ResolvedWait, } from './loop/index.js';
+export type { BirthSpec, ForkOpening, FreshOpening, Refusal, RowsResult, RowsWrite, WriteRows } from './state/index.js';
+export { isWaitRequest, waitFor } from './loop/index.js';
+export { lastAssistantMessage } from './state/index.js';
+export { registerSurfaceStrategy } from './loop/index.js';
+export type { AuxiliaryCall, AuxiliaryReply, CompletionRequest, InvocationContext, ModelRequestDraft, ModelStep, SentModelRequest, SentRequest, StopVerdict, AuxiliaryAnswer, FinalPlan, SurfacePlan, SurfacePrepareInput, SurfaceStrategy, Tool, ToolAuthorizationRequest, ToolDenial, ToolEntry, ToolExecutionMode, ToolInvocation, ToolOutcome, ToolPolicyDecision, TurnStop, WaitRequest, ResolvedWait, } from './loop/index.js';
+export type { ReplacementInput } from './state/index.js';
 export { stableStringify } from './util/json.js';
-export { claimThread } from './kit/claim.js';
-export { systemClock, timerQueue } from './kit/timers.js';
-export type { Clock, TimerQueue } from './kit/timers.js';
-export { pathBoundary } from './sys/paths.js';
-export type { BoundaryScope, PathAccess, PathBoundary } from './sys/paths.js';
-export { runToCompletion, spawnCommand } from './sys/spawn.js';
+export { systemClock, timerQueue } from './util/timers.js';
+export type { Clock, TimerQueue } from './util/timers.js';
 export type { AppendEntry } from './journal/index.js';
-export type { SpawnEnvironment, SpawnOptions, SpawnResult, SpawnStdio, SpawnedCommand, SpawnedGroup, SpawnedPipes, StopCause, } from './sys/spawn.js';
+export type { SpawnEnvironment } from './sys/spawn.js';

package/dist/plugin.js

@@ -1 +1 @@
-import{a as F}from"./chunks/6ECI2GGV.js";import{a as T}from"./chunks/4XVRUSCQ.js";import{b as x,c as B}from"./chunks/SGGMBSBA.js";import{c as S}from"./chunks/3QCW4WDJ.js";import{b as N,d as R}from"./chunks/J5S4URAW.js";import{a as U}from"./chunks/SL2YLB2F.js";import{b as C}from"./chunks/RK3VP2Q4.js";import"./chunks/74HKUGRR.js";import{a as M}from"./chunks/QMMLQJBS.js";import{a as P}from"./chunks/YIR5MYGU.js";import{a as c,b as u,e as g}from"./chunks/L3N4FIEN.js";import{a as b,b as h}from"./chunks/NAOUTU7A.js";import"./chunks/UKXMCHHT.js";import{b as j}from"./chunks/CDQG7RKA.js";import{a as E}from"./chunks/G6RXC3AL.js";import{b as l,c as d}from"./chunks/DXFXAYDN.js";import{a as v,b as y,c as A,d as q,e as w}from"./chunks/DRYAN665.js";import{a as m,b as f,c as s,d as a}from"./chunks/2OSESBIL.js";import{R as t,ia as i,ja as n,ka as p}from"./chunks/YLNJXQ3Z.js";import"./chunks/DDANMY45.js";import{d as e,h as o,j as r}from"./chunks/37YOGDGY.js";import"./chunks/KESCTXGO.js";import"./chunks/TYTQRLTX.js";import"./chunks/D7E6EWIE.js";export{m as AgentSelectorSchema,v as ExtensionVersionError,r as ProjectionFailedError,F as claimThread,C as contributePrompt,U as defineContribution,y as defineExtensionEvent,j as defineModes,c as definePreset,b as defineTool,P as drainBeforeUnload,p as errorResult,B as grantTool,S as handDown,s as isScopedAgentName,n as isWaitRequest,t as lastAssistantMessage,A as latestNotice,q as latestVisible,u as mountPreset,g as parsePresetConfig,E as pathBoundary,o as projection,T as provideStrategy,h as provideTool,x as registerAgent,M as requireService,a as requireUnscoped,d as runToCompletion,f as selects,l as spawnCommand,e as stableStringify,N as systemClock,w as tellOnStep,R as timerQueue,i as waitFor};
+import{b as N}from"./chunks/DDZ7YF26.js";import{b as t}from"./chunks/KUZCL2SH.js";import{c as P}from"./chunks/CQEVREBT.js";import{b as w,d as F}from"./chunks/HK6ZSONF.js";import{a as M}from"./chunks/7VAPNE3L.js";import{b}from"./chunks/EPYQ5M3B.js";import"./chunks/5IRF47YB.js";import{a as u,b as S,e as E}from"./chunks/OL5A6ITQ.js";import{b as A,c as T,e as h}from"./chunks/JFX2MXBA.js";import{a as l,b as c,c as d,d as g}from"./chunks/S34ZA2R6.js";import{a as q,b as y,c as C,d as j,e as v}from"./chunks/6FRNHMCV.js";import{b as m,c as p,d as a,e as x}from"./chunks/CUK7CGC7.js";import{U as i,V as n,W as s,Y as f}from"./chunks/BPRCULZH.js";import"./chunks/FJLU4UH3.js";import"./chunks/DDANMY45.js";import{c as e,h as r,j as o}from"./chunks/BBCW2FZK.js";import"./chunks/MMNNZCBO.js";import"./chunks/G44LG6VL.js";import"./chunks/D4PQP5MA.js";export{p as AgentSelectorSchema,q as ExtensionVersionError,o as ProjectionFailedError,l as claimThread,b as contributePrompt,M as defineContribution,y as defineExtensionEvent,N as defineModes,u as definePreset,A as defineTool,c as drainBeforeUnload,i as errorResult,h as grantTool,P as handDown,x as isScopedAgentName,s as isWaitRequest,t as lastAssistantMessage,C as latestNotice,j as latestVisible,S as mountPreset,E as parsePresetConfig,r as projection,m as registerAgent,f as registerSurfaceStrategy,T as registerTool,d as requireService,g as requireUnscoped,a as selects,e as stableStringify,w as systemClock,v as tellOnStep,F as timerQueue,n as waitFor};