@vincemakes/kiso-runtime 0.45.3 → 0.46.1

package/dist/agent.d.ts

@@ -34,6 +34,12 @@ export interface AgentDefinition {
     /** 0.40.0: the config profile that named this binding, recorded per
      *  revision for display. Never part of drift. */
     readonly profileName?: string;
+    /** B1: a NEW session's initial reasoning (the CLI passes the effort last
+     *  picked for the profile). Recorded in the session's first profile
+     *  revision; never read for a session that has a recorded profile — its
+     *  own wins, and a changed binding resets to defaults as before.
+     *  `setModelBinding` stays the one way to change a live binding. */
+    readonly reasoning?: import("./provider/metadata.js").ReasoningSetting;
     /** `Tool<any>` like the registry: typed tools register without casts. */
     readonly tools: readonly Tool<any>[];
     readonly store: SessionStore;

package/dist/agent.js

@@ -155,7 +155,11 @@ export class AgentRuntime {
             ...((restored !== null ? restored.scope : startupScope) !== undefined
                 ? { continuationScope: (restored !== null ? restored.scope : startupScope) }
                 : {}),
-            ...(restored !== null ? { reasoning: restored.reasoning } : {}),
+            ...(restored !== null
+                ? { reasoning: restored.reasoning }
+                : newSession !== null && this.#definition.reasoning !== undefined
+                    ? { reasoning: this.#definition.reasoning }
+                    : {}),
             ...(profilePending ? { profilePending: true } : {}),
             ...(newSession !== null ? { newSession } : {}),
             ...(this.#definition.profileName !== undefined ? { profileName: this.#definition.profileName } : {}),

package/dist/internal.d.ts

@@ -31,3 +31,5 @@ export * from "./checkpoint.js";
 export * from "./request-budget.js";
 export { readProfile, readSummary, writeSummary, type ExecutionProfile, type ProfileReadResult } from "./profile.js";
 export { SUMMARY_MIGRATION_MARKER, listSessionSidecars, migrateSummaries, sessionSummary, summarizeEvents, summaryMigrationPending, type SessionListing, type SessionSummary } from "./session-summary.js";
+export * from "./tasks/journal.js";
+export * from "./tasks/manager.js";

package/dist/internal.js

@@ -40,3 +40,7 @@ export * from "./request-budget.js";
 // 0.40.0: the listing reads the recorded workspace and profile name.
 export { readProfile, readSummary, writeSummary } from "./profile.js";
 export { SUMMARY_MIGRATION_MARKER, listSessionSidecars, migrateSummaries, sessionSummary, summarizeEvents, summaryMigrationPending } from "./session-summary.js";
+// ADR-0058 §6: the task journal and the TaskManager (internal until the
+// public shape is proven by the shell and delegate steps)
+export * from "./tasks/journal.js";
+export * from "./tasks/manager.js";

package/dist/profile.js

@@ -90,7 +90,11 @@ function writeTenants(root, sessionId, tenants) {
         // this file comes into existence. Existing files are not migrated —
         // R6's choice, kept.
         writeFileSync(tmp, `${JSON.stringify(tenants, null, "\t")}\n`, { mode: 0o600 });
-        const fd = openSync(tmp, "r");
+        // Windows: only a write-capable handle can be flushed, and no
+        // directory opens as a file — the rename is not flushed there (a
+        // process crash loses nothing; the power-loss contract is P6's)
+        const windows = process.platform === "win32";
+        const fd = openSync(tmp, windows ? "r+" : "r");
         try {
             fsyncSync(fd);
         }
@@ -98,12 +102,14 @@ function writeTenants(root, sessionId, tenants) {
             closeSync(fd);
         }
         renameSync(tmp, path);
-        const dirFd = openSync(dirname(path), "r");
-        try {
-            fsyncSync(dirFd);
-        }
-        finally {
-            closeSync(dirFd);
+        if (!windows) {
+            const dirFd = openSync(dirname(path), "r");
+            try {
+                fsyncSync(dirFd);
+            }
+            finally {
+                closeSync(dirFd);
+            }
         }
     }
     finally {

package/dist/run.d.ts

@@ -3,7 +3,7 @@
  * persistence, the loop drive, the durable recovery state machine), moved
  * verbatim from session.ts.
  */
-import { type AbortSignalLike, type Adapter, type ContentBlock, type Event } from "@vincemakes/kiso-core";
+import { type AbortSignalLike, type TaskDeliveryItem, type Adapter, type ContentBlock, type Event } from "@vincemakes/kiso-core";
 import type { SessionStore } from "./store.js";
 import { type AgentSession, type SessionConfig } from "./session.js";
 /**
@@ -21,6 +21,14 @@ export declare class RunClosedError extends Error {
  * natural shape; the handle also carries the runId, the abort and the
  * steer.
  */
+/** ADR-0058 (3c): a task delivery handed to a run — one line per task
+ *  (the wire marking) and the transitions it carries (the receipt). */
+export interface TaskNotice {
+    readonly lines: readonly string[];
+    readonly items: readonly TaskDeliveryItem[];
+}
+/** The runtime's words, marked so the model never takes them for a person's. */
+export declare const NOTICE_FOOTER = "Runtime notice \u2014 not the user.";
 export declare class Run implements AsyncIterable<Event> {
     #private;
     runId: string;
@@ -34,9 +42,20 @@ export declare class Run implements AsyncIterable<Event> {
      * {@link RunClosedError} once the run has decided to end.
      */
     steer(content: string | readonly ContentBlock[]): void;
-    /** ADR-0057 — take back the input that has not been admitted yet. */
+    /** ADR-0058 (3c) — hand this run a task delivery. It is admitted at the
+     *  next Safe Admission boundary, in arrival order with the person's
+     *  steers, as a `source: "system"` user_input whose `via` is the receipt;
+     *  it never passes onUserMessage. False once the run has decided to end
+     *  — the caller keeps the notice for the next run or a wake. */
+    notify(notice: TaskNotice): boolean;
+    /** ADR-0057 — take back the person's input that has not been admitted
+     *  yet. A task notice is not the person's, and stays. */
     retract(): readonly (string | readonly ContentBlock[])[];
-    /** ADR-0057 — input that arrived but was not admitted when the run ended. */
+    /** ADR-0057 — the person's input that arrived but was not admitted when
+     *  the run ended. */
     unadmitted(): readonly (string | readonly ContentBlock[])[];
+    /** ADR-0058 (3c) — task notices still pending when the run ended: the
+     *  delivery takes them back, never lost. */
+    unadmittedNotices(): readonly TaskNotice[];
     [Symbol.asyncIterator](): AsyncIterator<Event>;
 }

package/dist/run.js

@@ -26,13 +26,8 @@ export class RunClosedError extends Error {
         this.runId = runId;
     }
 }
-/**
- * A single foreground execution, from its input to one terminal (ADR-0057:
- * it may admit further input at Safe Admission boundaries).
- * Async-iterable, so `for await (const ev of session.run(x))` is the
- * natural shape; the handle also carries the runId, the abort and the
- * steer.
- */
+/** The runtime's words, marked so the model never takes them for a person's. */
+export const NOTICE_FOOTER = "Runtime notice — not the user.";
 export class Run {
     runId;
     #store;
@@ -51,11 +46,14 @@ export class Run {
     #externalSignal;
     #decisionIds = [];
     #started = false;
-    // ADR-0057 — the ephemeral ingress: a person's input in arrival order,
-    // held in memory until an admission site takes it. The log owns what was
-    // admitted; nothing here is durable (a crash before admission loses it).
-    #pending = [];
+    // ADR-0057 — the ephemeral ingress: a person's input AND the runtime's
+    // task notices (ADR-0058 3c), ONE queue in arrival order, held in memory
+    // until an admission site takes it. The log owns what was admitted;
+    // nothing here is durable (a crash before admission loses it — a task
+    // notice is re-derived from the journal and the log's receipts).
+    #ingress = [];
     #unadmitted = [];
+    #unadmittedNotices = [];
     #sealed = false;
     constructor(store, adapter, config, session, input, externalSignal, resume, 
     // TV-1B: durable PROVENANCE for the input (e.g. source:"system"
@@ -89,23 +87,72 @@ export class Run {
     steer(content) {
         if (this.#sealed)
             throw new RunClosedError(this.runId);
-        this.#pending.push(content);
+        this.#ingress.push({ kind: "human", content });
+        // ADR-0057 §5: a long foreground command no longer holds the steer
+        this.#session.detachForSteer();
+    }
+    /** ADR-0058 (3c) — hand this run a task delivery. It is admitted at the
+     *  next Safe Admission boundary, in arrival order with the person's
+     *  steers, as a `source: "system"` user_input whose `via` is the receipt;
+     *  it never passes onUserMessage. False once the run has decided to end
+     *  — the caller keeps the notice for the next run or a wake. */
+    notify(notice) {
+        if (this.#sealed)
+            return false;
+        this.#ingress.push({ kind: "runtime", notice });
+        return true;
     }
-    /** ADR-0057 — take back the input that has not been admitted yet. */
+    /** ADR-0057 — take back the person's input that has not been admitted
+     *  yet. A task notice is not the person's, and stays. */
     retract() {
-        return this.#pending.splice(0);
+        const taken = [];
+        for (let i = this.#ingress.length - 1; i >= 0; i--) {
+            const entry = this.#ingress[i];
+            if (entry.kind === "human") {
+                taken.unshift(entry.content);
+                this.#ingress.splice(i, 1);
+            }
+        }
+        return taken;
     }
-    /** ADR-0057 — input that arrived but was not admitted when the run ended. */
+    /** ADR-0057 — the person's input that arrived but was not admitted when
+     *  the run ended. */
     unadmitted() {
         return [...this.#unadmitted];
     }
-    /** The kernel's `admit`: what is pending becomes ONE human input — a
-     *  single line as itself, several as text blocks in arrival order. */
+    /** ADR-0058 (3c) — task notices still pending when the run ended: the
+     *  delivery takes them back, never lost. */
+    unadmittedNotices() {
+        return [...this.#unadmittedNotices];
+    }
+    /** The kernel's `admit`: the ingress in arrival order, neighbours of one
+     *  kind merged — a person's lines as ONE human input (a single line as
+     *  itself, several as text blocks), task notices as ONE runtime input. */
     async #admit(mode) {
-        if (mode !== "seal" && this.#pending.length > 0) {
-            const lines = this.#pending.splice(0);
-            const content = lines.length === 1 ? lines[0] : lines.flatMap((l) => (typeof l === "string" ? [{ type: "text", text: l }] : l));
-            return [{ kind: "human", content, source: "user" }];
+        if (mode !== "seal" && this.#ingress.length > 0) {
+            // group neighbours of one kind, in arrival order
+            const groups = [];
+            for (const entry of this.#ingress.splice(0)) {
+                const last = groups.at(-1);
+                if (entry.kind === "human") {
+                    if (last?.kind === "human")
+                        last.contents.push(entry.content);
+                    else
+                        groups.push({ kind: "human", contents: [entry.content] });
+                }
+                else if (last?.kind === "runtime")
+                    last.notices.push(entry.notice);
+                else
+                    groups.push({ kind: "runtime", notices: [entry.notice] });
+            }
+            return groups.map((g) => {
+                if (g.kind === "human") {
+                    const content = g.contents.length === 1 ? g.contents[0] : g.contents.flatMap((l) => (typeof l === "string" ? [{ type: "text", text: l }] : l));
+                    return { kind: "human", content, source: "user" };
+                }
+                const content = [...g.notices.flatMap((n) => n.lines), NOTICE_FOOTER].join("\n");
+                return { kind: "runtime", content, source: "system", via: { kind: "tasks", items: g.notices.flatMap((n) => n.items) } };
+            });
         }
         if (mode !== "take")
             this.#seal();
@@ -113,7 +160,12 @@ export class Run {
     }
     #seal() {
         this.#sealed = true;
-        this.#unadmitted.push(...this.#pending.splice(0));
+        for (const entry of this.#ingress.splice(0)) {
+            if (entry.kind === "human")
+                this.#unadmitted.push(entry.content);
+            else
+                this.#unadmittedNotices.push(entry.notice);
+        }
     }
     async *[Symbol.asyncIterator]() {
         if (this.#started)

package/dist/session.d.ts

@@ -33,6 +33,8 @@ import { type ContinuationScope } from "@vincemakes/kiso-core";
 import { type ReasoningSetting } from "./provider/metadata.js";
 import { type SessionStore, type StoreRecord } from "./store.js";
 import { Run } from "./run.js";
+import { type TaskDeliveryOptions } from "./tasks/delivery.js";
+import type { TaskManager } from "./tasks/manager.js";
 /** TUI2-R3v2 ③ — one off-trajectory model request (session.sideQuery).
  *  Deliberately tiny: a purpose to mark it in the trace, its own short
  *  system prompt, one user message, and an abort. No tools — a side
@@ -89,6 +91,9 @@ export interface CompactInfo {
     /** The covered content's estimated tokens (the chars/4 proxy). */
     readonly tokens: number;
 }
+/** ADR-0057 §5 (3e D1): a steer detaches a foreground command only once it
+ *  is this old — a command about to end on its own is left to end. */
+export declare const AUTO_DETACH_MIN_AGE_MS = 2000;
 export declare class AgentSession {
     #private;
     readonly id: string;
@@ -122,6 +127,19 @@ export declare class AgentSession {
     persist(runId: string, event: Event): Promise<void>;
     beginRun(run: Run): void;
     endRun(run: Run): void;
+    /** Deliver this session's task transitions to the model: into a live
+     *  run at its next safe point, or — idle — held for the next run, or one
+     *  continuation run through `onWake` (off with `wake: false`). */
+    useTasks(manager: TaskManager, options?: Pick<TaskDeliveryOptions, "wake" | "onWake" | "windowMs"> & {
+        readonly autoDetachMinAgeMs?: number;
+    }): () => void;
+    /** ADR-0057 §5 (3e D1) — a person's steer arrived: the foreground
+     *  commands running NOW stop holding it back. Each is detached once it is
+     *  `autoDetachMinAgeMs` old — at once if it already is — so a command
+     *  about to end anyway is not turned into a task. Commands started after
+     *  the steer are never touched; a command that ends first unregistered
+     *  itself, and its detach is a no-op. Called by the run. */
+    detachForSteer(): void;
     /** The conversation so far, as the model sees it. */
     projected(): readonly Message[];
     /** 0.40.0: the context as the last bill measured it, plus what the log
@@ -309,6 +327,7 @@ export declare class AgentSession {
         signal?: AbortSignalLike;
         source?: import("@vincemakes/kiso-core").MessageSource;
         via?: import("@vincemakes/kiso-core").UserInputVia;
+        maxTurns?: number;
     }): Run;
     /**
      * Continue the interrupted run (Area 2): apply durable decisions,

package/dist/session.js

@@ -47,6 +47,7 @@ import { checkpointBoundarySeq } from "./checkpoint.js";
 import { ABORTED_BEFORE_EXECUTION, unansweredAbortedCalls } from "./aborted-calls.js";
 import { breakEvenFactor, guardedPruneSeq, KEEP_COMPACTABLE_RESULTS, microcompactBoundarySeq, outputReserve, phaseEnd, runsACheck, tierReason, tiersFor } from "./compaction-policy.js";
 import { Run } from "./run.js";
+import { TaskDelivery } from "./tasks/delivery.js";
 // TUI2-R3v2 ③ — the side query rides the SAME tracer the runs ride; that
 // sameness is the whole point (one ledger, one shape, no second path).
 import { RequestTracer, traceGuard } from "./trace/guard.js";
@@ -90,6 +91,9 @@ function summaryReasoning(model, baseUrl) {
     const r = resolveReasoning(model, { thinking: "disabled", effort: "default" }, baseUrl);
     return r.ok && r.wire.thinking !== undefined ? { reasoning: r.wire } : {};
 }
+/** ADR-0057 §5 (3e D1): a steer detaches a foreground command only once it
+ *  is this old — a command about to end on its own is left to end. */
+export const AUTO_DETACH_MIN_AGE_MS = 2_000;
 export class AgentSession {
     id;
     log;
@@ -266,9 +270,61 @@ export class AgentSession {
             throw new Error("this session already has an active run — one run at a time");
         }
         this.#activeRuns.add(run);
+        this.#delivery?.takeForRun(run); // ADR-0058: pending task notices ride its first admission
     }
     endRun(run) {
         this.#activeRuns.delete(run);
+        this.#delivery?.onRunSettled(run); // the slot is free: a wake may follow
+    }
+    // ── ADR-0058 (3c): the session's tasks reach the model ────────────────
+    #delivery;
+    #tasks;
+    #autoDetachMinAgeMs = AUTO_DETACH_MIN_AGE_MS;
+    /** Deliver this session's task transitions to the model: into a live
+     *  run at its next safe point, or — idle — held for the next run, or one
+     *  continuation run through `onWake` (off with `wake: false`). */
+    useTasks(manager, 
+    // autoDetachMinAgeMs (3e D1): how old a foreground command must be
+    // before a steer detaches it — default AUTO_DETACH_MIN_AGE_MS
+    options = {}) {
+        this.#delivery?.close();
+        const { autoDetachMinAgeMs, ...deliveryOptions } = options;
+        const delivery = new TaskDelivery({ ...deliveryOptions, manager, events: () => this.log.all, liveRun: () => [...this.#activeRuns][0] });
+        this.#delivery = delivery;
+        this.#tasks = manager;
+        this.#autoDetachMinAgeMs = autoDetachMinAgeMs ?? AUTO_DETACH_MIN_AGE_MS;
+        return () => {
+            delivery.close();
+            if (this.#delivery === delivery)
+                this.#delivery = undefined;
+            if (this.#tasks === manager)
+                this.#tasks = undefined;
+        };
+    }
+    /** ADR-0057 §5 (3e D1) — a person's steer arrived: the foreground
+     *  commands running NOW stop holding it back. Each is detached once it is
+     *  `autoDetachMinAgeMs` old — at once if it already is — so a command
+     *  about to end anyway is not turned into a task. Commands started after
+     *  the steer are never touched; a command that ends first unregistered
+     *  itself, and its detach is a no-op. Called by the run. */
+    detachForSteer() {
+        const manager = this.#tasks;
+        if (manager === undefined)
+            return;
+        const now = Date.now();
+        for (const { executionId, startedAt } of manager.detachable()) {
+            const wait = Math.max(0, this.#autoDetachMinAgeMs - (now - startedAt));
+            if (wait === 0)
+                manager.detach(executionId, "steer");
+            else
+                setTimeout(() => manager.detach(executionId, "steer"), wait).unref?.();
+        }
+    }
+    /** A summary carries the tasks as the model was last told of them —
+     *  never the live journal (a compaction is not a delivery). */
+    #withTasks(summary) {
+        const snapshot = this.#delivery?.snapshot(this.log.all) ?? "";
+        return snapshot === "" ? summary : `${summary}\n\n${snapshot}`;
     }
     /** The conversation so far, as the model sees it. */
     projected() {
@@ -414,10 +470,11 @@ export class AgentSession {
         // against an estimate). A checkpoint that fails it is discarded:
         // nothing is appended, the run goes on as before, and the failure
         // counts toward the breaker.
-        const fire = { type: "summarized", coversToSeq: boundary, summary: result.text };
+        const text = this.#withTasks(result.text);
+        const fire = { type: "summarized", coversToSeq: boundary, summary: text };
         const pre = estimateTokens(projectMessages(events));
         const post = estimateTokens(projectMessages([...events, { ...fire, seq: (events.at(-1)?.seq ?? -1) + 1 }]));
-        const written = estimateTokens([{ role: "user", content: `${SUMMARY_FRAMING}\n\n${result.text}` }]);
+        const written = estimateTokens([{ role: "user", content: `${SUMMARY_FRAMING}\n\n${text}` }]);
         const shrinks = pre - post >= written;
         // Every in-run fire is recorded — its reason and path are what the
         // measurement counts — and its usage when the provider reported one;
@@ -734,11 +791,15 @@ export class AgentSession {
      *  OpenAI-compatible family as `image_url` with a data URI. Only this
      *  signature narrowed it to text, which is why no caller could ever
      *  send one. */
-    run(input, options) {
+    run(input, 
+    // ADR-0058 3d: `maxTurns` bounds THIS run only (a background child's
+    // wrap-up gets one request), over the session's own limit
+    options) {
         this.ensureHealthy();
         if (this.#profilePending)
             this.#recordProfile(); // XP-1: legacy revision 1, before the first request
-        return new Run(this.#store, this.#learning(this.#adapter), this.#effectiveConfig(), this, input, options?.signal, false, options?.source, options?.via);
+        const config = options?.maxTurns !== undefined ? { ...this.#effectiveConfig(), maxTurns: options.maxTurns } : this.#effectiveConfig();
+        return new Run(this.#store, this.#learning(this.#adapter), config, this, input, options?.signal, false, options?.source, options?.via);
     }
     /**
      * Continue the interrupted run (Area 2): apply durable decisions,
@@ -862,7 +923,7 @@ export class AgentSession {
         // adapter returned must NOT persist — "nothing happened".
         if (options.signal !== undefined && options.signal.aborted)
             throw cancelled();
-        const full = this.log.append({ type: "summarized", coversToSeq: boundary, summary });
+        const full = this.log.append({ type: "summarized", coversToSeq: boundary, summary: this.#withTasks(summary) });
         // The record rides the LAST recorded run's id — a summarized fact
         // must never open a run of its own: the open-run gate keys on
         // terminal-less runIds, and a "compact" runId would block the next

package/dist/store.js

@@ -42,7 +42,7 @@
  * - load is strict (A group round 1): a partial final line is the only
  *   tolerated damage; everything else throws StoreCorruptionError.
  */
-import { appendFileSync, closeSync, existsSync, fsyncSync, fstatSync, statSync, ftruncateSync, mkdirSync, openSync, readFileSync, readdirSync, readSync, } from "node:fs";
+import { appendFileSync, closeSync, constants, existsSync, fsyncSync, fstatSync, statSync, ftruncateSync, mkdirSync, openSync, readFileSync, readdirSync, readSync, writeSync, } from "node:fs";
 import { dirname, join } from "node:path";
 import { isKisoEvent } from "@vincemakes/kiso-core";
 import { LockedError, nativeLockAdapter, } from "./lock-adapter.js";
@@ -135,7 +135,8 @@ function contentText(content) {
 export function sessionTitle(records) {
     const asked = records
         .map((r) => r.event)
-        .filter((e) => e.type === "user_input")
+        // ADR-0058: a task notice is the runtime's, never the person's words
+        .filter((e) => e.type === "user_input" && e.via?.kind !== "tasks")
         // 0.40.0: a skill turn is named by what the person TYPED — its
         // content is a SKILL.md body the person never wrote.
         .map((e) => (typeof e.via?.line === "string" ? e.via.line : contentText(e.content)).trim())
@@ -312,7 +313,13 @@ export class SessionStore {
         if (event.seq !== expected) {
             throw new StaleWriterError(expected, event.seq);
         }
-        appendFileSync(fd, `${JSON.stringify({ runId, ts: Date.now(), event })}\n`);
+        const line = `${JSON.stringify({ runId, ts: Date.now(), event })}\n`;
+        // Windows: the log is open read-write (see fd()), so the append is a
+        // write at the end — the lock makes this the only writer
+        if (process.platform === "win32")
+            writeSync(fd, line, fstatSync(fd).size);
+        else
+            appendFileSync(fd, line);
         // A streamed fragment is not a durability boundary: it belongs to a
         // turn that is uncommitted until its stop is durable, and the next
         // synced event (the call's end, the text's end, the stop) flushes
@@ -340,7 +347,10 @@ export class SessionStore {
         const path = this.pathFor(sessionId);
         // R6: the mode applies at CREATION only — an existing log keeps
         // whatever it has, which is the not-migrated rule above.
-        const fd = openSync(path, "a+", 0o600);
+        // Windows: a handle opened for append can be neither flushed nor
+        // truncated (FlushFileBuffers and SetEndOfFile need the write access
+        // append mode drops), so the log opens read-write there
+        const fd = openSync(path, process.platform === "win32" ? constants.O_RDWR | constants.O_CREAT : "a+", 0o600);
         repairTornTail(fd);
         fsyncDir(dirname(path));
         this.#fds.set(sessionId, fd);

package/dist/tasks/delivery.d.ts

@@ -0,0 +1,82 @@
+/**
+ * ADR-0058 §7–§8, step 3c — a task's transitions reach the model.
+ *
+ * One delivery per session. It hears the TaskManager's transitions,
+ * decides each by the §8 defaults (silent | notify | wake), merges what
+ * arrives within a window into ONE notice, and hands it on:
+ *
+ *   a live run      → `run.notify` — admitted at the next safe point, in
+ *                     arrival order with the person's steers (ADR-0057);
+ *   an idle session → held for the next run a person starts, or — when a
+ *                     transition asks to wake — ONE continuation run whose
+ *                     first input is the notice (the host starts it, after
+ *                     the previous run has fully settled).
+ *
+ * Exactly once, from the log: a transition counts as delivered when a
+ * `user_input` whose `via.items` names it is in the session's log (ADR-0051
+ * Amendment 8). The set is a cache rebuilt from the log, never a second
+ * truth. Lineage from the log too: a task started inside a wake run (a run
+ * whose first input is a task notice) never wakes — depth 1.
+ *
+ * The summary snapshot is what the MODEL was told, never the live journal:
+ * a compaction must not reveal a transition that has not been delivered.
+ *
+ * A transition a tool result reports (ADR-0058 Amendment 7) is CLAIMED in
+ * the task journal by that execution and never noticed — the manager does
+ * not announce it, and a restart does not deliver it. The claim decides
+ * only that; what the model knows stays the log's: the summary learns a
+ * claimed transition from the claiming execution's durable, successful
+ * tool_result, never from the journal alone.
+ *
+ * Background children (ADR-0058 3d) arrive as a GROUP: the agent tasks
+ * started by the calls of one model turn. The group closes once that turn
+ * has ended and every call in it has its result — before that, a fast
+ * child's end says nothing about the group. A closed group whose members
+ * have all ended is delivered ONCE: every member's line, then excerpts of
+ * the answers (result.md, which the child wrote) within 4 KiB each and
+ * 16 KiB together; members already delivered are named as reported, and
+ * only the rest are receipted. A failure goes into a live run at once and
+ * never wakes on its own; idle, it waits for its group.
+ */
+import { type Event, type UserInputVia } from "@vincemakes/kiso-core";
+import { type Run } from "../run.js";
+import { type TaskInfo, type TaskManager } from "./manager.js";
+export interface TaskDeliveryOptions {
+    readonly manager: TaskManager;
+    /** The session's durable events: receipts and lineage are read here. */
+    readonly events: () => readonly Event[];
+    /** The session's live run, when one is running. */
+    readonly liveRun: () => Run | undefined;
+    /** False turns every wake into a notify (the switch, ADR-0058 §8.4). */
+    readonly wake?: boolean;
+    /** Start ONE continuation run whose first input is this notice. */
+    readonly onWake?: (input: {
+        readonly content: string;
+        readonly via: UserInputVia;
+    }) => void;
+    /** Transitions within this window merge into one notice. Default 1 s. */
+    readonly windowMs?: number;
+    /** How much of a failed task's output rides its notice. Default 2 KB. */
+    readonly tailBytes?: number;
+    /** Read a task's output tail (injectable for tests). */
+    readonly readTail?: (task: TaskInfo, bytes: number) => string;
+}
+export declare class TaskDelivery {
+    #private;
+    constructor(options: TaskDeliveryOptions);
+    close(): void;
+    /** A run a person started: pending notices ride its first admission. */
+    takeForRun(run: Run): void;
+    /** The run has fully settled (its terminal durable, the slot free):
+     *  notices it never admitted come back, and a wake may start. */
+    onRunSettled(run: Run): void;
+    /** The conversation's view of its tasks for a summary: a task the model
+     *  was told started, at the last transition it was TOLD about. Empty
+     *  when the model knows of no task. Told started = a durable, successful
+     *  tool_result for the execution that started it — a started execution
+     *  with no result (the crash window), or one resolved as not applied,
+     *  never told the model a task exists. Told a transition = a notice
+     *  naming it, or (Amendment 7) a durable, successful tool_result of the
+     *  execution that claimed it — in log order, the last one wins. */
+    snapshot(events: readonly Event[]): string;
+}