@smthrs/harness 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/Steering.d.ts

@@ -0,0 +1,464 @@
+/**
+ * Turn-boundary steering values and their source contract.
+ *
+ * Governing design: `../docs/concepts.md#notification-queue`.
+ *
+ * @since 0.1.0
+ */
+import * as ModelRequest from "@smthrs/model/ModelRequest";
+import { Context, Effect, Layer, Schema } from "effect";
+import type { HarnessError } from "./HarnessError.ts";
+/**
+ * The boundary at which a transcript insertion may be promoted.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type Delivery = "steer" | "queue";
+/**
+ * A transcript insertion promoted at the next turn boundary.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface SteerInsert {
+    readonly _tag: "Insert";
+    readonly delivery: "steer";
+    readonly admittedAt: number;
+    readonly message: ModelRequest.Message;
+}
+/**
+ * A transcript insertion promoted only when the run would otherwise go idle.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface QueueInsert {
+    readonly _tag: "Insert";
+    readonly delivery: "queue";
+    readonly admittedAt: number;
+    readonly message: ModelRequest.Message;
+}
+/**
+ * A transcript insertion admitted for a future turn.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type Insert = SteerInsert | QueueInsert;
+/**
+ * A model-seat change that applies only after the current turn closes.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface SeatChange {
+    readonly _tag: "SeatChange";
+    readonly delivery: "steer";
+    readonly admittedAt: number;
+    readonly seat: string;
+}
+/**
+ * A thinking-level change that applies only after the current turn closes.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface ThinkingChange {
+    readonly _tag: "ThinkingChange";
+    readonly delivery: "steer";
+    readonly admittedAt: number;
+    readonly thinking: ModelRequest.ReasoningEffort;
+}
+/**
+ * A serializable steering event.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type Item = Insert | SeatChange | ThinkingChange;
+/**
+ * An immutable, FIFO queue of steering events.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Queue {
+    readonly items: ReadonlyArray<Item>;
+}
+/**
+ * The values promoted when a turn reaches its close boundary.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Drain {
+    readonly inserts: ReadonlyArray<ModelRequest.Message>;
+    readonly seatChanges: ReadonlyArray<SeatChange | ThinkingChange>;
+    readonly remaining: Queue;
+    readonly queued: boolean;
+    /**
+     * Whether this boundary had already drained, so the answer is the one it gave
+     * the first time.
+     *
+     * This is what makes a parked run answerable. A park resumes by re-executing
+     * its own frames, so it reaches the same boundary again and must be told the
+     * same thing — and it must also be able to find out that a NEWER boundary is
+     * the one an operator's answer is waiting at. A run walks its park's
+     * boundaries until one reports `false`, which is the first one this run has
+     * not consulted before.
+     *
+     * Host queue bookkeeping, like {@link Drain.remaining}, and deliberately not
+     * part of {@link DrainRecord}: it says which attempt asked, not what the
+     * boundary holds, and freezing it in a journaled value would tell every later
+     * attempt it was the first.
+     */
+    readonly duplicate: boolean;
+}
+/**
+ * The boundary a drain is being attempted at, and whether the run would go
+ * idle if nothing were delivered. Followups are held back until it would.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface BoundaryInput {
+    readonly boundary: string;
+    readonly wouldIdle: boolean;
+    /**
+     * Set only at an honored park's boundary: why the run parked and what it
+     * asked. A source that can reach a person may show them the question and
+     * answer the drain with their reply; one that cannot ignores it.
+     */
+    readonly park?: {
+        readonly reason: "waiting-input" | "waiting-event" | "waiting-quota";
+        readonly message: string;
+    } | undefined;
+}
+/**
+ * The journaled record of one turn-boundary drain.
+ *
+ * A drain consumes host queue state, so it is a nondeterministic read: the
+ * controller journals exactly this projection through `EngineLike.record`,
+ * keyed on the frame and boundary, and a re-executed frame replays the record
+ * instead of draining an already-drained queue. Everything the controller
+ * folds into durable state is here; `remaining` is host queue bookkeeping and
+ * deliberately is not.
+ *
+ * @category schemas
+ * @since 0.1.0
+ * @slop
+ */
+export declare const DrainRecord: Schema.Struct<{
+    readonly inserts: Schema.$Array<Schema.Union<readonly [typeof ModelRequest.UserMessage, typeof ModelRequest.AssistantMessage, typeof ModelRequest.ToolMessage]> & {
+        readonly discriminants: readonly ["user", "assistant", "tool"];
+        readonly cases: {
+            user: typeof ModelRequest.UserMessage;
+            assistant: typeof ModelRequest.AssistantMessage;
+            tool: typeof ModelRequest.ToolMessage;
+        };
+        readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => value is Extract<ModelRequest.UserMessage, {
+            readonly role: Keys;
+        }> | Extract<ModelRequest.AssistantMessage, {
+            readonly role: Keys;
+        }> | Extract<ModelRequest.ToolMessage, {
+            readonly role: Keys;
+        }>;
+        readonly guards: {
+            user: (u: unknown) => u is ModelRequest.UserMessage;
+            assistant: (u: unknown) => u is ModelRequest.AssistantMessage;
+            tool: (u: unknown) => u is ModelRequest.ToolMessage;
+        };
+        readonly match: {
+            <Cases extends {
+                user: (value: ModelRequest.UserMessage) => any;
+                assistant: (value: ModelRequest.AssistantMessage) => any;
+                tool: (value: ModelRequest.ToolMessage) => any;
+            }>(value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+            <Cases extends {
+                user: (value: ModelRequest.UserMessage) => any;
+                assistant: (value: ModelRequest.AssistantMessage) => any;
+                tool: (value: ModelRequest.ToolMessage) => any;
+            }>(cases: Cases): (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+        };
+        readonly matchOrElse: {
+            <Cases extends {
+                user?: (value: ModelRequest.UserMessage) => any;
+                assistant?: (value: ModelRequest.AssistantMessage) => any;
+                tool?: (value: ModelRequest.ToolMessage) => any;
+            } & { [K in Exclude<keyof Cases, "user" | "assistant" | "tool">]: never; }, OrElse extends (value: Exclude<ModelRequest.UserMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.AssistantMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.ToolMessage, {
+                readonly role: keyof Cases;
+            }>) => any>(value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage, cases: Cases, orElse: OrElse): import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
+            <Cases extends {
+                user?: (value: ModelRequest.UserMessage) => any;
+                assistant?: (value: ModelRequest.AssistantMessage) => any;
+                tool?: (value: ModelRequest.ToolMessage) => any;
+            } & { [K in Exclude<keyof Cases, "user" | "assistant" | "tool">]: never; }, OrElse extends (value: Exclude<ModelRequest.UserMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.AssistantMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.ToolMessage, {
+                readonly role: keyof Cases;
+            }>) => any>(cases: Cases, orElse: OrElse): (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
+        };
+    } & {
+        make: (message: ModelRequest.Message) => ModelRequest.Message;
+        user: (content: string | ModelRequest.TextPart | ReadonlyArray<ModelRequest.TextPart>) => ModelRequest.UserMessage;
+        assistant: (content: string | ModelRequest.AssistantContentPart | ReadonlyArray<ModelRequest.AssistantContentPart>, options?: {
+            readonly stopReason?: ModelRequest.StopReason | undefined;
+            readonly responseId?: string | undefined;
+            readonly itemIds?: ReadonlyArray<string> | undefined;
+        }) => ModelRequest.AssistantMessage;
+        tool: (content: ModelRequest.ToolResultPart | ReadonlyArray<ModelRequest.ToolResultPart>) => ModelRequest.ToolMessage;
+    }>;
+    readonly seatChanges: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"SeatChange">;
+        readonly delivery: Schema.Literal<"steer">;
+        readonly admittedAt: Schema.Number;
+        readonly seat: Schema.String;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"ThinkingChange">;
+        readonly delivery: Schema.Literal<"steer">;
+        readonly admittedAt: Schema.Number;
+        readonly thinking: Schema.Literals<readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"]>;
+    }>]>>;
+    readonly queued: Schema.Boolean;
+    /**
+     * Messages the run's supervisor delivers at this boundary, kept apart from
+     * `inserts` because they are not the person's words: the model reads them,
+     * and the completion brake's task never does. Absent from records written
+     * before the supervisor had a field of its own, and from boundaries it
+     * delivered nothing at.
+     */
+    readonly supervisor: Schema.optional<Schema.$Array<Schema.Union<readonly [typeof ModelRequest.UserMessage, typeof ModelRequest.AssistantMessage, typeof ModelRequest.ToolMessage]> & {
+        readonly discriminants: readonly ["user", "assistant", "tool"];
+        readonly cases: {
+            user: typeof ModelRequest.UserMessage;
+            assistant: typeof ModelRequest.AssistantMessage;
+            tool: typeof ModelRequest.ToolMessage;
+        };
+        readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => value is Extract<ModelRequest.UserMessage, {
+            readonly role: Keys;
+        }> | Extract<ModelRequest.AssistantMessage, {
+            readonly role: Keys;
+        }> | Extract<ModelRequest.ToolMessage, {
+            readonly role: Keys;
+        }>;
+        readonly guards: {
+            user: (u: unknown) => u is ModelRequest.UserMessage;
+            assistant: (u: unknown) => u is ModelRequest.AssistantMessage;
+            tool: (u: unknown) => u is ModelRequest.ToolMessage;
+        };
+        readonly match: {
+            <Cases extends {
+                user: (value: ModelRequest.UserMessage) => any;
+                assistant: (value: ModelRequest.AssistantMessage) => any;
+                tool: (value: ModelRequest.ToolMessage) => any;
+            }>(value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+            <Cases extends {
+                user: (value: ModelRequest.UserMessage) => any;
+                assistant: (value: ModelRequest.AssistantMessage) => any;
+                tool: (value: ModelRequest.ToolMessage) => any;
+            }>(cases: Cases): (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
+        };
+        readonly matchOrElse: {
+            <Cases extends {
+                user?: (value: ModelRequest.UserMessage) => any;
+                assistant?: (value: ModelRequest.AssistantMessage) => any;
+                tool?: (value: ModelRequest.ToolMessage) => any;
+            } & { [K in Exclude<keyof Cases, "user" | "assistant" | "tool">]: never; }, OrElse extends (value: Exclude<ModelRequest.UserMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.AssistantMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.ToolMessage, {
+                readonly role: keyof Cases;
+            }>) => any>(value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage, cases: Cases, orElse: OrElse): import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
+            <Cases extends {
+                user?: (value: ModelRequest.UserMessage) => any;
+                assistant?: (value: ModelRequest.AssistantMessage) => any;
+                tool?: (value: ModelRequest.ToolMessage) => any;
+            } & { [K in Exclude<keyof Cases, "user" | "assistant" | "tool">]: never; }, OrElse extends (value: Exclude<ModelRequest.UserMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.AssistantMessage, {
+                readonly role: keyof Cases;
+            }> | Exclude<ModelRequest.ToolMessage, {
+                readonly role: keyof Cases;
+            }>) => any>(cases: Cases, orElse: OrElse): (value: ModelRequest.UserMessage | ModelRequest.AssistantMessage | ModelRequest.ToolMessage) => import("effect/Unify").Unify<{ [K_1 in keyof Cases]-?: NonNullable<Cases[K_1]> extends (...args: Array<any>) => infer R ? R : never; }[keyof Cases] | ReturnType<OrElse>>;
+        };
+    } & {
+        make: (message: ModelRequest.Message) => ModelRequest.Message;
+        user: (content: string | ModelRequest.TextPart | ReadonlyArray<ModelRequest.TextPart>) => ModelRequest.UserMessage;
+        assistant: (content: string | ModelRequest.AssistantContentPart | ReadonlyArray<ModelRequest.AssistantContentPart>, options?: {
+            readonly stopReason?: ModelRequest.StopReason | undefined;
+            readonly responseId?: string | undefined;
+            readonly itemIds?: ReadonlyArray<string> | undefined;
+        }) => ModelRequest.AssistantMessage;
+        tool: (content: ModelRequest.ToolResultPart | ReadonlyArray<ModelRequest.ToolResultPart>) => ModelRequest.ToolMessage;
+    }>>;
+    /**
+     * Keys of the memory rows among `supervisor`, which the run has now been
+     * shown. Absent from boundaries that delivered none.
+     */
+    readonly memory: Schema.optional<Schema.$Array<Schema.String>>;
+    /** The monitor whose message leads `supervisor`, when one was delivered. */
+    readonly monitor: Schema.optional<Schema.String>;
+    /** Crossed monitors this boundary withheld, and why. Absent when none was. */
+    readonly suppressed: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly reason: Schema.Literals<readonly ["streak", "cooldown", "limit", "slot"]>;
+    }>>>;
+    /**
+     * The monitor ledger after this boundary gated a reading, which the run
+     * carries into its next frame. Absent from boundaries that gated none.
+     */
+    readonly monitorLedger: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly streak: Schema.Int;
+        readonly delivered: Schema.Int;
+        readonly lastFrame: Schema.Int;
+    }>>>;
+    /**
+     * Jev's answers about transcript segments, by digest, which the run stores
+     * for its next compaction. The model is not sent them. Absent from
+     * boundaries that took none.
+     */
+    readonly marks: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly remove: Schema.Number;
+        readonly keep: Schema.Number;
+        readonly digest: Schema.String;
+    }>>>;
+    /**
+     * The context triggers the delivered supervisor reading fired, which
+     * compact the run at its next frame. Absent from boundaries that took none.
+     */
+    readonly compact: Schema.optional<Schema.$Array<Schema.Literals<readonly ["budget", "outdated_context", "irrelevant_context"]>>>;
+}>;
+/**
+ * The journaled record of one turn-boundary drain.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type DrainRecord = typeof DrainRecord.Type;
+/**
+ * Projects a {@link Drain} into its journaled record.
+ *
+ * @category conversions
+ * @since 0.1.0
+ * @slop
+ */
+export declare const drainRecord: (drain: Drain) => DrainRecord;
+/**
+ * Creates an empty immutable steering queue.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const empty: () => Queue;
+/**
+ * Appends an item without mutating the prior queue.
+ *
+ * @category operations
+ * @since 0.1.0
+ * @slop
+ */
+export declare const enqueue: (queue: Queue, item: Item) => Queue;
+/**
+ * Drains only items admitted at or before the turn's fixed cutoff.
+ *
+ * @category operations
+ * @since 0.1.0
+ * @slop
+ */
+export declare const drainAtClose: (queue: Queue, cutoff: number) => Drain;
+/**
+ * Source of a serializable steering-queue snapshot. Storage and persistence
+ * promotion are deliberately supplied by the host.
+ *
+ * @category services
+ * @since 0.1.0
+ * @slop
+ */
+export interface Source {
+    readonly read: () => Effect.Effect<Queue, HarnessError>;
+    /**
+     * Promotes what one boundary may deliver.
+     *
+     * A drain is IDEMPOTENT in its boundary string: a second drain at one
+     * boundary promotes nothing and hands back exactly what the first one
+     * promoted, with {@link Drain.duplicate} set. That is not an optimization, it
+     * is the contract a resumed run depends on — a re-executed frame drains the
+     * boundaries it already drained and must be told the same thing, or it
+     * rebuilds a different context and re-keys every later sealed step. A source
+     * that promotes afresh each time cannot answer a parked run and will deliver
+     * one message many times.
+     */
+    readonly drain: (input: BoundaryInput) => Effect.Effect<Drain, HarnessError>;
+}
+/**
+ * The methods {@link make} needs to build a {@link Source}.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface SourceInput {
+    readonly read: () => Effect.Effect<Queue, HarnessError>;
+    readonly drain: (input: BoundaryInput) => Effect.Effect<Drain, HarnessError>;
+}
+/**
+ * Service tag for the external steering queue source.
+ *
+ * @category services
+ * @since 0.1.0
+ * @slop
+ */
+export declare const Source: Context.Service<Source, Source>;
+/**
+ * Constructs a steering source service.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const make: (implementation: SourceInput) => Source;
+/**
+ * Creates a source that always returns an empty queue.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const makeNoop: (overrides?: Partial<Source>) => Source;
+/**
+ * Provides a steering source as a layer.
+ *
+ * @category layers
+ * @since 0.1.0
+ * @slop
+ */
+export declare const layer: (implementation: SourceInput) => Layer.Layer<Source>;
+/**
+ * Provides an empty steering source as a layer.
+ *
+ * @category layers
+ * @since 0.1.0
+ * @slop
+ */
+export declare const layerNoop: (overrides?: Partial<Source>) => Layer.Layer<Source>;
+//# sourceMappingURL=Steering.d.ts.map

package/dist/cjs/Steering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Steering.d.ts","sourceRoot":"","sources":["../../src/Steering.ts"],"names":[],"mappings":"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"}

package/dist/cjs/Steering.js

@@ -0,0 +1,153 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Steering_exports = {};
+__export(Steering_exports, {
+  DrainRecord: () => DrainRecord,
+  Source: () => Source,
+  drainAtClose: () => drainAtClose,
+  drainRecord: () => drainRecord,
+  empty: () => empty,
+  enqueue: () => enqueue,
+  layer: () => layer,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeNoop: () => makeNoop
+});
+module.exports = __toCommonJS(Steering_exports);
+var ModelRequest = __toESM(require("@smthrs/model/ModelRequest"), 1);
+var import_effect = require("effect");
+var AgentEvent = __toESM(require("./AgentEvent.js"), 1);
+var compactionMarks = __toESM(require("./internal/compactionMarks.js"), 1);
+var Monitor = __toESM(require("./Monitor.js"), 1);
+const SeatChangeRecord = import_effect.Schema.Struct({
+  _tag: import_effect.Schema.Literal("SeatChange"),
+  delivery: import_effect.Schema.Literal("steer"),
+  admittedAt: import_effect.Schema.Number,
+  seat: import_effect.Schema.String
+});
+const ThinkingChangeRecord = import_effect.Schema.Struct({
+  _tag: import_effect.Schema.Literal("ThinkingChange"),
+  delivery: import_effect.Schema.Literal("steer"),
+  admittedAt: import_effect.Schema.Number,
+  thinking: ModelRequest.ReasoningEffort
+});
+const DrainRecord = import_effect.Schema.Struct({
+  inserts: import_effect.Schema.Array(ModelRequest.Message),
+  seatChanges: import_effect.Schema.Array(import_effect.Schema.Union([SeatChangeRecord, ThinkingChangeRecord])),
+  queued: import_effect.Schema.Boolean,
+  /**
+   * Messages the run's supervisor delivers at this boundary, kept apart from
+   * `inserts` because they are not the person's words: the model reads them,
+   * and the completion brake's task never does. Absent from records written
+   * before the supervisor had a field of its own, and from boundaries it
+   * delivered nothing at.
+   */
+  supervisor: import_effect.Schema.optional(import_effect.Schema.Array(ModelRequest.Message)),
+  /**
+   * Keys of the memory rows among `supervisor`, which the run has now been
+   * shown. Absent from boundaries that delivered none.
+   */
+  memory: import_effect.Schema.optional(import_effect.Schema.Array(import_effect.Schema.String)),
+  /** The monitor whose message leads `supervisor`, when one was delivered. */
+  monitor: import_effect.Schema.optional(import_effect.Schema.String),
+  /** Crossed monitors this boundary withheld, and why. Absent when none was. */
+  suppressed: import_effect.Schema.optional(import_effect.Schema.Array(import_effect.Schema.Struct({ id: import_effect.Schema.String, reason: AgentEvent.Suppression }))),
+  /**
+   * The monitor ledger after this boundary gated a reading, which the run
+   * carries into its next frame. Absent from boundaries that gated none.
+   */
+  monitorLedger: import_effect.Schema.optional(Monitor.Ledger),
+  /**
+   * Jev's answers about transcript segments, by digest, which the run stores
+   * for its next compaction. The model is not sent them. Absent from
+   * boundaries that took none.
+   */
+  marks: import_effect.Schema.optional(import_effect.Schema.Array(compactionMarks.Marking)),
+  /**
+   * The context triggers the delivered supervisor reading fired, which
+   * compact the run at its next frame. Absent from boundaries that took none.
+   */
+  compact: import_effect.Schema.optional(import_effect.Schema.Array(AgentEvent.CompactionCause))
+});
+const drainRecord = (drain) => ({
+  inserts: drain.inserts,
+  seatChanges: drain.seatChanges,
+  queued: drain.queued
+});
+const immutable = (items) => Object.freeze({ items: Object.freeze([...items]) });
+const immutableItem = (item) => Object.freeze({ ...item });
+const empty = () => immutable([]);
+const enqueue = (queue, item) => immutable([...queue.items, immutableItem(item)]);
+const drainAtClose = (queue, cutoff) => {
+  const inserts = [];
+  const seatChanges = [];
+  const remaining = [];
+  for (const item of queue.items) {
+    if (item.delivery === "queue" || item.admittedAt > cutoff) {
+      remaining.push(item);
+      continue;
+    }
+    switch (item._tag) {
+      case "Insert":
+        inserts.push(item.message);
+        break;
+      case "SeatChange":
+      case "ThinkingChange":
+        seatChanges.push(item);
+        break;
+    }
+  }
+  return {
+    inserts: Object.freeze(inserts),
+    seatChanges: Object.freeze(seatChanges),
+    remaining: immutable(remaining),
+    queued: false,
+    // An in-memory cutoff drain keeps no boundary ledger, so it can never say
+    // it has answered this boundary before.
+    duplicate: false
+  };
+};
+const Source = import_effect.Context.Service("@smthrs/harness/Steering/Source");
+const make = (implementation) => Source.of(implementation);
+const makeNoop = (overrides = {}) => make({
+  read: import_effect.Effect.fn("Steering.Source.read")(() => import_effect.Effect.succeed(empty())),
+  drain: import_effect.Effect.fn("Steering.Source.drain")(
+    () => import_effect.Effect.succeed({
+      inserts: [],
+      seatChanges: [],
+      remaining: empty(),
+      queued: false,
+      duplicate: false
+    })
+  ),
+  ...overrides
+});
+const layer = (implementation) => import_effect.Layer.succeed(Source)(make(implementation));
+const layerNoop = (overrides = {}) => import_effect.Layer.succeed(Source)(makeNoop(overrides));
+//# sourceMappingURL=Steering.js.map

package/dist/cjs/Steering.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Steering.ts"],
+  "sourcesContent": ["/**\n * Turn-boundary steering values and their source contract.\n *\n * Governing design: `../docs/concepts.md#notification-queue`.\n *\n * @since 0.1.0\n */\n\nimport * as ModelRequest from \"@smthrs/model/ModelRequest\"\nimport { Context, Effect, Layer, Schema } from \"effect\"\nimport * as AgentEvent from \"./AgentEvent.ts\"\nimport type { HarnessError } from \"./HarnessError.ts\"\nimport * as compactionMarks from \"./internal/compactionMarks.ts\"\nimport * as Monitor from \"./Monitor.ts\"\n\n/**\n * The boundary at which a transcript insertion may be promoted.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Delivery = \"steer\" | \"queue\"\n\n/**\n * A transcript insertion promoted at the next turn boundary.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface SteerInsert {\n  readonly _tag: \"Insert\"\n  readonly delivery: \"steer\"\n  readonly admittedAt: number\n  readonly message: ModelRequest.Message\n}\n\n/**\n * A transcript insertion promoted only when the run would otherwise go idle.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface QueueInsert {\n  readonly _tag: \"Insert\"\n  readonly delivery: \"queue\"\n  readonly admittedAt: number\n  readonly message: ModelRequest.Message\n}\n\n/**\n * A transcript insertion admitted for a future turn.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Insert = SteerInsert | QueueInsert\n\n/**\n * A model-seat change that applies only after the current turn closes.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface SeatChange {\n  readonly _tag: \"SeatChange\"\n  readonly delivery: \"steer\"\n  readonly admittedAt: number\n  readonly seat: string\n}\n\n/**\n * A thinking-level change that applies only after the current turn closes.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface ThinkingChange {\n  readonly _tag: \"ThinkingChange\"\n  readonly delivery: \"steer\"\n  readonly admittedAt: number\n  readonly thinking: ModelRequest.ReasoningEffort\n}\n\n/**\n * A serializable steering event.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Item = Insert | SeatChange | ThinkingChange\n\n/**\n * An immutable, FIFO queue of steering events.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Queue {\n  readonly items: ReadonlyArray<Item>\n}\n\n/**\n * The values promoted when a turn reaches its close boundary.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Drain {\n  readonly inserts: ReadonlyArray<ModelRequest.Message>\n  readonly seatChanges: ReadonlyArray<SeatChange | ThinkingChange>\n  readonly remaining: Queue\n  readonly queued: boolean\n  /**\n   * Whether this boundary had already drained, so the answer is the one it gave\n   * the first time.\n   *\n   * This is what makes a parked run answerable. A park resumes by re-executing\n   * its own frames, so it reaches the same boundary again and must be told the\n   * same thing \u2014 and it must also be able to find out that a NEWER boundary is\n   * the one an operator's answer is waiting at. A run walks its park's\n   * boundaries until one reports `false`, which is the first one this run has\n   * not consulted before.\n   *\n   * Host queue bookkeeping, like {@link Drain.remaining}, and deliberately not\n   * part of {@link DrainRecord}: it says which attempt asked, not what the\n   * boundary holds, and freezing it in a journaled value would tell every later\n   * attempt it was the first.\n   */\n  readonly duplicate: boolean\n}\n\n/**\n * The boundary a drain is being attempted at, and whether the run would go\n * idle if nothing were delivered. Followups are held back until it would.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface BoundaryInput {\n  readonly boundary: string\n  readonly wouldIdle: boolean\n  /**\n   * Set only at an honored park's boundary: why the run parked and what it\n   * asked. A source that can reach a person may show them the question and\n   * answer the drain with their reply; one that cannot ignores it.\n   */\n  readonly park?: {\n    readonly reason: \"waiting-input\" | \"waiting-event\" | \"waiting-quota\"\n    readonly message: string\n  } | undefined\n}\n\nconst SeatChangeRecord = Schema.Struct({\n  _tag: Schema.Literal(\"SeatChange\"),\n  delivery: Schema.Literal(\"steer\"),\n  admittedAt: Schema.Number,\n  seat: Schema.String\n})\n\nconst ThinkingChangeRecord = Schema.Struct({\n  _tag: Schema.Literal(\"ThinkingChange\"),\n  delivery: Schema.Literal(\"steer\"),\n  admittedAt: Schema.Number,\n  thinking: ModelRequest.ReasoningEffort\n})\n\n/**\n * The journaled record of one turn-boundary drain.\n *\n * A drain consumes host queue state, so it is a nondeterministic read: the\n * controller journals exactly this projection through `EngineLike.record`,\n * keyed on the frame and boundary, and a re-executed frame replays the record\n * instead of draining an already-drained queue. Everything the controller\n * folds into durable state is here; `remaining` is host queue bookkeeping and\n * deliberately is not.\n *\n * @category schemas\n * @since 0.1.0\n * @slop\n */\nexport const DrainRecord = Schema.Struct({\n  inserts: Schema.Array(ModelRequest.Message),\n  seatChanges: Schema.Array(Schema.Union([SeatChangeRecord, ThinkingChangeRecord])),\n  queued: Schema.Boolean,\n  /**\n   * Messages the run's supervisor delivers at this boundary, kept apart from\n   * `inserts` because they are not the person's words: the model reads them,\n   * and the completion brake's task never does. Absent from records written\n   * before the supervisor had a field of its own, and from boundaries it\n   * delivered nothing at.\n   */\n  supervisor: Schema.optional(Schema.Array(ModelRequest.Message)),\n  /**\n   * Keys of the memory rows among `supervisor`, which the run has now been\n   * shown. Absent from boundaries that delivered none.\n   */\n  memory: Schema.optional(Schema.Array(Schema.String)),\n  /** The monitor whose message leads `supervisor`, when one was delivered. */\n  monitor: Schema.optional(Schema.String),\n  /** Crossed monitors this boundary withheld, and why. Absent when none was. */\n  suppressed: Schema.optional(Schema.Array(Schema.Struct({ id: Schema.String, reason: AgentEvent.Suppression }))),\n  /**\n   * The monitor ledger after this boundary gated a reading, which the run\n   * carries into its next frame. Absent from boundaries that gated none.\n   */\n  monitorLedger: Schema.optional(Monitor.Ledger),\n  /**\n   * Jev's answers about transcript segments, by digest, which the run stores\n   * for its next compaction. The model is not sent them. Absent from\n   * boundaries that took none.\n   */\n  marks: Schema.optional(Schema.Array(compactionMarks.Marking)),\n  /**\n   * The context triggers the delivered supervisor reading fired, which\n   * compact the run at its next frame. Absent from boundaries that took none.\n   */\n  compact: Schema.optional(Schema.Array(AgentEvent.CompactionCause))\n})\n\n/**\n * The journaled record of one turn-boundary drain.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type DrainRecord = typeof DrainRecord.Type\n\n/**\n * Projects a {@link Drain} into its journaled record.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const drainRecord = (drain: Drain): DrainRecord => ({\n  inserts: drain.inserts,\n  seatChanges: drain.seatChanges,\n  queued: drain.queued\n})\n\nconst immutable = (items: ReadonlyArray<Item>): Queue => Object.freeze({ items: Object.freeze([...items]) })\n\nconst immutableItem = (item: Item): Item => Object.freeze({ ...item })\n\n/**\n * Creates an empty immutable steering queue.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const empty = (): Queue => immutable([])\n\n/**\n * Appends an item without mutating the prior queue.\n *\n * @category operations\n * @since 0.1.0\n * @slop\n */\nexport const enqueue = (queue: Queue, item: Item): Queue => immutable([...queue.items, immutableItem(item)])\n\n/**\n * Drains only items admitted at or before the turn's fixed cutoff.\n *\n * @category operations\n * @since 0.1.0\n * @slop\n */\nexport const drainAtClose = (queue: Queue, cutoff: number): Drain => {\n  const inserts: Array<ModelRequest.Message> = []\n  const seatChanges: Array<SeatChange | ThinkingChange> = []\n  const remaining: Array<Item> = []\n  for (const item of queue.items) {\n    if (item.delivery === \"queue\" || item.admittedAt > cutoff) {\n      remaining.push(item)\n      continue\n    }\n    switch (item._tag) {\n      case \"Insert\":\n        inserts.push(item.message)\n        break\n      case \"SeatChange\":\n      case \"ThinkingChange\":\n        seatChanges.push(item)\n        break\n    }\n  }\n  return {\n    inserts: Object.freeze(inserts),\n    seatChanges: Object.freeze(seatChanges),\n    remaining: immutable(remaining),\n    queued: false,\n    // An in-memory cutoff drain keeps no boundary ledger, so it can never say\n    // it has answered this boundary before.\n    duplicate: false\n  }\n}\n\n/**\n * Source of a serializable steering-queue snapshot. Storage and persistence\n * promotion are deliberately supplied by the host.\n *\n * @category services\n * @since 0.1.0\n * @slop\n */\nexport interface Source {\n  readonly read: () => Effect.Effect<Queue, HarnessError>\n  /**\n   * Promotes what one boundary may deliver.\n   *\n   * A drain is IDEMPOTENT in its boundary string: a second drain at one\n   * boundary promotes nothing and hands back exactly what the first one\n   * promoted, with {@link Drain.duplicate} set. That is not an optimization, it\n   * is the contract a resumed run depends on \u2014 a re-executed frame drains the\n   * boundaries it already drained and must be told the same thing, or it\n   * rebuilds a different context and re-keys every later sealed step. A source\n   * that promotes afresh each time cannot answer a parked run and will deliver\n   * one message many times.\n   */\n  readonly drain: (input: BoundaryInput) => Effect.Effect<Drain, HarnessError>\n}\n\n/**\n * The methods {@link make} needs to build a {@link Source}.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface SourceInput {\n  readonly read: () => Effect.Effect<Queue, HarnessError>\n  readonly drain: (input: BoundaryInput) => Effect.Effect<Drain, HarnessError>\n}\n\n/**\n * Service tag for the external steering queue source.\n *\n * @category services\n * @since 0.1.0\n * @slop\n */\nexport const Source: Context.Service<Source, Source> = Context.Service(\"@smthrs/harness/Steering/Source\")\n\n/**\n * Constructs a steering source service.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const make = (implementation: SourceInput): Source => Source.of(implementation)\n\n/**\n * Creates a source that always returns an empty queue.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const makeNoop = (overrides: Partial<Source> = {}): Source =>\n  make({\n    read: Effect.fn(\"Steering.Source.read\")(() => Effect.succeed(empty())),\n    drain: Effect.fn(\"Steering.Source.drain\")(() =>\n      Effect.succeed({\n        inserts: [],\n        seatChanges: [],\n        remaining: empty(),\n        queued: false,\n        duplicate: false\n      })\n    ),\n    ...overrides\n  })\n\n/**\n * Provides a steering source as a layer.\n *\n * @category layers\n * @since 0.1.0\n * @slop\n */\nexport const layer = (implementation: SourceInput): Layer.Layer<Source> => Layer.succeed(Source)(make(implementation))\n\n/**\n * Provides an empty steering source as a layer.\n *\n * @category layers\n * @since 0.1.0\n * @slop\n */\nexport const layerNoop = (overrides: Partial<Source> = {}): Layer.Layer<Source> =>\n  Layer.succeed(Source)(makeNoop(overrides))\n"],
+  "mappings": "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",
+  "names": []
+}