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

package/dist/cjs/EngineLike.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/EngineLike.ts"],
+  "sourcesContent": ["/**\n * Narrow engine port consumed by the built-in harness.\n *\n * Governing contracts: `../docs/concepts.md#durable-cell-loop`,\n * `../docs/concepts.md#child-plans-and-the-splice-boundary`, and\n * `../docs/concepts.md#step-keys-and-the-model-layer`.\n *\n * @since 0.1.0\n */\n\nimport type * as KeyMaterial from \"@smthrs/core/KeyMaterial\"\nimport type * as Model from \"@smthrs/model/Model\"\nimport type * as ModelEvent from \"@smthrs/model/ModelEvent\"\nimport type * as ModelRequest from \"@smthrs/model/ModelRequest\"\nimport { Context, Effect, Layer, Option, Schema, Stream } from \"effect\"\nimport type * as AgentEvent from \"./AgentEvent.ts\"\nimport type * as Cell from \"./Cell.ts\"\nimport { HarnessError } from \"./HarnessError.ts\"\nimport type * as Plan from \"./Plan.ts\"\n\n/**\n * Stable reasons for parking a harness turn at a safe boundary.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport const SuspendReasonCode = Schema.Literals([\n  \"permission-required\",\n  \"waiting-quota\",\n  \"waiting-input\",\n  \"waiting-event\",\n  \"engine\"\n])\n\n/**\n * Stable reasons for parking a harness turn at a safe boundary.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type SuspendReasonCode = typeof SuspendReasonCode.Type\n\n/**\n * A serializable request to park the current engine frame.\n *\n * `details` is a closed JSON value rather than `Schema.Unknown`, for the reason\n * `HarnessError`'s `cause` is a `Schema.Defect`: this value is journaled inside\n * `AgentEvent.Suspended` and served back to whatever resumes the run, so it has\n * to be something the durable exit schema can encode. `Schema.Unknown` accepts\n * a live `Error`, a function, a `BigInt`, a cycle and an accessor, and the\n * controller was in fact attaching a `Permission.PermissionRequired` \u2014 a class\n * that extends `Error` \u2014 to every permission park. What a park carries is now\n * encoded before it is attached, so the journal holds the same value a resumed\n * run decodes.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class SuspendReason extends Schema.Class<SuspendReason>(\"flows/harness/EngineLike/SuspendReason\")({\n  code: SuspendReasonCode,\n  message: Schema.String,\n  details: Schema.optional(Schema.Json)\n}) {}\n\n/**\n * A sealed model request and the complete digest-free material declared by the\n * harness.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface SealedModelStep {\n  readonly request: ModelRequest.ModelRequest\n  readonly keyMaterial: KeyMaterial.KeyMaterial\n  /**\n   * Wall-clock milliseconds one attempt at this step may spend; zero disarms.\n   *\n   * The budget travels on the step rather than on the engine's construction so\n   * the number the controller journals as armed is the number the engine\n   * enforces \u2014 one value, read from the controller's own state, and no way for\n   * a run's record of its discipline to disagree with the discipline it ran\n   * under.\n   *\n   * It is not key material and must never become key material: it says how\n   * long the caller will wait, not what the model was asked, and a step keyed\n   * on it would miss its cache the moment a host retuned the budget.\n   */\n  readonly modelCallMs?: number | undefined\n}\n\n/**\n * The durable identity of one journaled controller boundary.\n *\n * `boundary` is a deterministic label for the boundary within its frame \u2014 a\n * cell digest or a context digest \u2014 so re-executing the frame derives the same\n * identity and replays the recorded value instead of performing the read\n * again.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface BoundaryIdentity {\n  /** The durable session or lineage the boundary belongs to, when the loop has one. */\n  readonly session?: string | undefined\n  readonly frame: number\n  readonly boundary: string\n}\n\n/**\n * A schema that decodes without services \u2014 the only kind a durable store can\n * reconstruct a journaled value with.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type DurableSchema<A> = Schema.Schema<A> & { readonly \"DecodingServices\": never }\n\n/**\n * One nondeterministic read the controller must perform exactly once per run.\n *\n * The canonical example is the turn-boundary steering drain: the host queue is\n * the world, and draining it is an effect. Left unjournaled, a resumed run\n * drains an already-drained queue, rebuilds a different context than the\n * original attempt, re-keys every later sealed step, and re-executes\n * irreversible effects. Recorded through {@link EngineLike.record}, the drain\n * replays its recorded value and the resumed run converges on the original\n * attempt.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface RecordBoundary<A> {\n  readonly name: string\n  readonly identity: BoundaryIdentity\n  readonly success: DurableSchema<A>\n  readonly execute: Effect.Effect<A, HarnessError>\n  /** Exact call whose delivered result this existing cell-call boundary records. */\n  readonly call?: Cell.Call | undefined\n  /**\n   * The model usage the recorded value says this boundary paid for, such as\n   * an evaluator reading taken inside `execute`, one share per model.\n   *\n   * Read off the recorded value, never off the live call, so a replayed frame\n   * reports the same spend the original attempt paid. An implementation that\n   * keeps a run budget accounts it once under this boundary's key, on the\n   * live pass and on replay alike, pricing each share under its model id, so\n   * the next paid call is admitted against it. Declaring it declares the\n   * boundary paid: unless it is {@link advisory}, such an implementation\n   * admits it before `execute` under the budget's evaluator-reading policy,\n   * and a refusal fails or parks the run as a primary call's would.\n   * `undefined` or an empty list from it is a boundary that paid for nothing\n   * this time.\n   */\n  // A method, so a boundary over a narrower value is still a `RecordBoundary<unknown>`.\n  usage?(value: A): ReadonlyArray<Paid> | undefined\n  /**\n   * A paid boundary whose caller drops its failure, such as the supervisor's\n   * reading in its own fiber: it is charged but never admitted, because a\n   * refusal there would register a park that no frame honours. The frame's\n   * next primary call applies the budget instead.\n   */\n  readonly advisory?: boolean | undefined\n}\n\n/**\n * One model's share of what a recorded boundary paid.\n *\n * @category models\n * @since 1.0.0-rc.1\n */\nexport interface Paid {\n  readonly usage: ModelEvent.Usage\n  /** The model that was paid, when the reading named it: what prices the share. */\n  readonly modelId?: string | undefined\n}\n\n/**\n * One measurement of the workspace the run is changing.\n *\n * The controller never interprets `digest`; it only asks whether two\n * measurements are equal. That is deliberate \u2014 the host owns what \"the\n * workspace\" means (which paths it covers, and what it reads off each one),\n * and the only thing the loop is entitled to conclude is \"this is the tree I\n * left\" or \"this is not\". `paths` is carried for the journal, so a reader can\n * tell an observation over 7,000 files from one over an empty root.\n *\n * `complete` is the answer to the one question that makes \"this is the tree I\n * left\" meaningful. A measurement that stopped at a bound covers a prefix of\n * the workspace, and a prefix cannot say that the rest of it held still \u2014 a\n * checkout larger than the host's bound would otherwise report every frame as\n * idle, and the read-only cap would fail a run that had been editing the whole\n * time. A host that does not narrow its own measurement leaves it `true`.\n *\n * @category models\n * @since 0.1.0\n */\nexport class Observation extends Schema.Class<Observation>(\"flows/harness/EngineLike/Observation\")({\n  /** A content address of everything the measurement covered, taken together. */\n  digest: Schema.String,\n  /** How many paths the measurement covered. */\n  paths: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n  /** Whether the measurement covered the whole tree it was asked to measure. */\n  complete: Schema.Boolean.pipe(\n    Schema.withConstructorDefault(Effect.succeed(true)),\n    Schema.withDecodingDefaultKey(Effect.succeed(true))\n  ),\n  /**\n   * How long the measurement took, in milliseconds, so a slow frame can be\n   * attributed. Absent from a measurement recorded before it was kept.\n   */\n  elapsedMs: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))\n}) {}\n\n/**\n * One pinned tree the run can come back to.\n *\n * A checkpoint is a **value**, not a place the run goes: minting one changes\n * nothing about the workspace, and running a call against one leaves the live\n * tree exactly as it stands. That is the whole point. Before this existed, the\n * only way to answer \"did this command fail before my change\" was to undo the\n * change, and `sympy__sympy-13878` shows what that costs \u2014 one byte-identical\n * 4,789-character patch applied five times, four of those applications preceded\n * by `git checkout -- sympy/stats/crv_types.py`, because a clean proof required\n * reverting the very work it was meant to prove.\n *\n * `ref` is the host's own name for what it pinned \u2014 a commit id, a snapshot\n * key, whatever the store speaks. The controller never interprets it, exactly\n * as it never interprets {@link Observation.digest}; it is carried so the\n * journal says which tree a checkpointed call ran against and a grader can\n * reconcile the reading against the store by hand.\n *\n * @category models\n * @since 0.1.0\n */\nexport class Snapshot extends Schema.Class<Snapshot>(\"flows/harness/EngineLike/Snapshot\")({\n  /** The id the cell holds, and the id a later call names in `at`. */\n  id: Schema.String,\n  /** What the host recorded, in the host's own vocabulary. */\n  ref: Schema.String\n}) {}\n\n/**\n * The names of the route one model request resolves to.\n *\n * Names and nothing else. A route is an endpoint, a protocol and the\n * credentials it authorizes with, and only the first two have a name a journal\n * may carry: this is read off the credential-free `Route.PreparedRequest` the\n * sealed step is keyed on, which is built before any secret is signed onto the\n * request. So there is no field here a credential could travel in.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport class Binding extends Schema.Class<Binding>(\"flows/harness/EngineLike/Binding\")({\n  /** The configured route's id, as `Route.PreparedRequest.routeId` names it. */\n  routeId: Schema.String,\n  /** The wire protocol that route speaks, as `Route.PreparedRequest.protocolId` names it. */\n  protocolId: Schema.String\n}) {}\n\n/**\n * What one model request resolves to on its way out of the host.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Resolved {\n  /** The request the provider is sent, after any rewrite the host applies. */\n  readonly request: ModelRequest.ModelRequest\n  /** The route it goes to, or none where the host names none. */\n  readonly binding: Option.Option<Binding>\n}\n\n/**\n * A request to pin the workspace as it stands right now.\n *\n * `identity` travels with it so a store *can* namespace what it writes by the\n * run that wrote it: two runs over one workspace mint `id` values from the same\n * frame-and-ordinal counter, so a store that keys on the id alone hands the\n * second run the first run's tree. `@smthrs/std/Checkpoints`'s git store keys\n * on the id alone and is right to: it also materializes at one path per id, as\n * `TestRun`'s baseline worktree does, so two concurrent runs over one workspace\n * collide on the checkout before they collide on the name. One workspace holds\n * one run \u2014 that is the assumption the whole workspace layer already makes, and\n * this field is what a store that stops making it would namespace by.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface CaptureRequest {\n  readonly id: string\n  readonly identity: BoundaryIdentity\n}\n\n/**\n * The engine operations required by harness translation.\n *\n * @category services\n * @since 0.1.0\n * @slop\n */\nexport interface EngineLike {\n  /**\n   * Runs one sealed model step.\n   *\n   * The harness contributes the assembled-context input, resolved layer set,\n   * capability envelope, effect tier, placement, and provider-neutral\n   * `ModelRequest` as core key material. The step-key contract\n   * (`../docs/concepts.md#step-keys-and-the-model-layer`) requires the exact\n   * wire request in the key, so route resolution happens before the key is\n   * sealed. An implementation MUST therefore resolve the route, run\n   * `Route.prepare` (`/model/Route`), and digest the credential-free\n   * `PreparedRequest` \u2014 canonical body bytes included \u2014 together with\n   * declared material into the sealed-step key before executing. A provider\n   * wire change must produce a new key; credentials are signed on after the\n   * digest and never enter it.\n   */\n  readonly sealStep: (\n    step: SealedModelStep\n  ) => Stream.Stream<ModelEvent.ModelEvent, Model.ModelFailure | HarnessError>\n  /** Optionally emits capacity transitions while sealing the same frame. */\n  readonly sealStepWithEvents?: (\n    step: SealedModelStep,\n    emit: (event: AgentEvent.AgentEvent) => Effect.Effect<void>\n  ) => Stream.Stream<ModelEvent.ModelEvent, Model.ModelFailure | HarnessError>\n  readonly splice: (\n    batch: Plan.Batch\n  ) => Stream.Stream<Plan.SpliceEvent, HarnessError>\n  /**\n   * Runs one flow call issued from inside a running cell.\n   *\n   * This is the cell path's whole effectful surface, and it is deliberately\n   * one call at a time: a cell derives the second call's input from the first\n   * call's result, so there is no batch to hand over. The implementation owns\n   * durability \u2014 the call is a keyed, journaled activity at the tier the flow\n   * declares, keyed by `call.identity` so a settled boundary replays instead of\n   * re-running when the cell is re-executed after a crash or a permission park.\n   *\n   * A flow that fails settles as a `failure` {@link Cell.CallResult}, which the\n   * cell observes as a resolved `{ ok: false, error }` envelope, not a throw.\n   * It branches on `.ok === false` and `.error.code` to recover; success\n   * resolves with the flow's own value, unwrapped. A permission requirement, an\n   * abort, or an engine failure travels in the error channel instead, so the\n   * cell never sees \u2014 and can never swallow \u2014 a park.\n   */\n  readonly call: (call: Cell.Call) => Effect.Effect<Cell.CallResult, HarnessError>\n  /**\n   * Decides a call's authority before the per-call clock starts.\n   *\n   * A person answering an approval is not the flow running slowly, so the\n   * controller asks here first and times only {@link call}. `undefined`\n   * admits the call; a result is the refusal the cell reads instead, and the\n   * call is never issued. A park or an engine failure travels in the error\n   * channel, exactly as it does from `call`. An implementation that admits a\n   * call does not ask again when that call is issued.\n   */\n  readonly admit?: (call: Cell.Call) => Effect.Effect<Cell.CallResult | undefined, HarnessError>\n  /**\n   * The host's runaway guard for timeouts, when it has one.\n   *\n   * A tool call or a cell that ran past its time limit is otherwise the cell's\n   * to read. A host that guards timeouts parks the run on it instead, for an\n   * operator's Continue or Stop, and the controller records nothing for the\n   * timed-out operation, so Continue runs it again.\n   */\n  readonly guard?: Guard\n  /**\n   * Journals one nondeterministic controller read as a durable boundary.\n   *\n   * The controller's state is rebuilt by re-execution, so every read of the\n   * world it makes between sealed steps must be recorded: the implementation\n   * runs `execute` once, journals the outcome under a run-scoped key derived\n   * from `name` and `identity` TOGETHER, and serves the recorded value to any\n   * later re-execution of the same frame. A read that bypasses this boundary is\n   * a replay divergence \u2014 and, downstream of one, duplicate irreversible\n   * effects.\n   *\n   * `(name, identity)` is the key, and both halves are load-bearing: one frame\n   * issues several records that share a session, a frame number and a boundary\n   * and differ only in what they are for. An implementation that keys on\n   * `identity` alone serves one frame's opening workspace measurement as its\n   * closing one. The controller also folds each boundary's purpose into\n   * `identity.boundary`, so it stays correct under an implementation that reads\n   * the contract the other way, but an implementation must key on both.\n   */\n  readonly record: <A>(boundary: RecordBoundary<A>) => Effect.Effect<A, HarnessError>\n  /**\n   * Measures the workspace as it stands right now.\n   *\n   * This is what makes the loop's mutation accounting honest. Every other\n   * signal the controller has about \"did this frame change anything\" is a\n   * *declaration*: a flow's registry envelope, or the write set an invocation\n   * claimed. A shell command declares neither \u2014 spawning a process is the one\n   * call whose effects do not travel through any boundary the harness can\n   * read \u2014 so a run whose only edits went through `bash` looked, to every\n   * control, exactly like a run that did nothing. Comparing two measurements\n   * around a frame answers the question from the world instead of from the\n   * paperwork.\n   *\n   * `Option.none()` is the honest answer for a host with no workspace to\n   * measure, or none it can measure cheaply. It is not an error and it is not\n   * \"nothing changed\": the controller reads it as \"unobserved\" and falls back\n   * to declared writes, and says in the journal which basis it used.\n   *\n   * The result is nondeterministic, so the controller journals it through\n   * {@link EngineLike.record} rather than calling this on a replayed frame.\n   */\n  readonly observe: Effect.Effect<Option.Option<Observation>, HarnessError>\n  /**\n   * Pins the workspace as it stands right now, under the id the caller gives.\n   *\n   * This is the sibling of {@link EngineLike.observe} and it is deliberately a\n   * different operation: `observe` answers \"is this the tree I left\", which\n   * needs only a digest, while this has to be able to hand the tree back later.\n   * The pin happens where the call happens \u2014 a cell that mints between two\n   * edits gets the tree between those two edits \u2014 which is what makes\n   * `ctx.checkpoint()` mean anything at the line it is written on.\n   *\n   * `Option.none()` is the honest answer for a host with no store to pin into,\n   * exactly as it is for `observe`. It is not an error: the controller answers\n   * the cell with a resolved `checkpoint_unavailable` failure, and the run\n   * carries on taking its readings from the live tree.\n   *\n   * The result is nondeterministic, so the controller journals it through\n   * {@link EngineLike.record} rather than calling this on a replayed frame.\n   */\n  readonly capture: (request: CaptureRequest) => Effect.Effect<Option.Option<Snapshot>, HarnessError>\n  /**\n   * Says what one request will actually be asked as, for the record of it.\n   *\n   * Two things stand between the request the controller builds and the call a\n   * provider receives, and both belong to the host: a composition may rewrite\n   * the request on its way out, and a route decides where it goes. The record\n   * of a model call has to be of the call that was made, so the controller\n   * asks here before it seals and journals the answer.\n   *\n   * Optional, and total where it exists. A host that rewrites nothing and\n   * names no route omits it, and the controller records the request it built.\n   *\n   * `Option.none()` is the honest answer for a request the host cannot say\n   * anything true about: its own rewrite failed, or no route accepts what the\n   * rewrite produced. The controller then journals no request for that call,\n   * because the only request it holds is one no provider would be sent, and a\n   * record that presented it as sent would prefill a call that never\n   * happened. It is not an error. The resolution that matters is the one\n   * {@link EngineLike.sealStep} performs, and that is where the same request\n   * fails with its typed error. A host that answers none here MUST fail that\n   * sealed step, and with the failure it already met rather than a second run\n   * of whatever produced it: a rewrite asked twice may answer twice.\n   *\n   * Pure in the request and the composition, so it is asked again on a\n   * replayed frame rather than journaled: the same request under the same\n   * composition resolves the same way, and a composition that has since\n   * changed has changed the sealed key too, so the call it describes is a new\n   * one.\n   */\n  readonly resolve?: (request: ModelRequest.ModelRequest) => Effect.Effect<Option.Option<Resolved>>\n  readonly suspend: (reason: SuspendReason) => Effect.Effect<never, HarnessError>\n}\n\n/**\n * Context service for the harness engine boundary.\n *\n * @category services\n * @since 0.1.0\n * @slop\n */\nexport const EngineLike: Context.Service<EngineLike, EngineLike> = Context.Service(\n  \"@smthrs/harness/EngineLike\"\n)\n\n/**\n * Constructs an engine port from an implementation.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const make = (implementation: EngineLike): EngineLike => EngineLike.of(implementation)\n\n/**\n * The {@link Guard} subject of one cell call: its session, frame and settled\n * boundary. A host keys what the guard decided for a call (how many times the\n * operator chose Continue) by the subject the controller admits it under.\n *\n * @category constructors\n * @since 1.0.0-rc.1\n */\nexport const callSubject = (identity: Pick<Cell.CallIdentity, \"session\" | \"frame\" | \"cell\" | \"ordinal\">): string =>\n  JSON.stringify({\n    session: identity.session,\n    frame: identity.frame,\n    boundary: `cell-call:${identity.cell}:${identity.ordinal}`\n  })\n\n/**\n * One operation that ran past its time limit, as the controller reports it to\n * {@link Guard.trip}.\n *\n * `subject` is the operation's replay-stable identity. `limitMillis` is\n * absent when the operation reported its own timeout without its limit.\n *\n * @category models\n * @since 1.0.0-rc.1\n */\nexport interface TimedOut {\n  readonly source: \"tool-call\" | \"cell\"\n  readonly subject: string\n  readonly limitMillis?: number | undefined\n  readonly message: string\n}\n\n/**\n * A host's runaway guard for tool-call and cell timeouts; see\n * {@link EngineLike.guard}.\n *\n * @category models\n * @since 1.0.0-rc.1\n */\nexport interface Guard {\n  /**\n   * Admits an operation before it runs. A park whose question is still open,\n   * or the failure a Stop settles the run with, travels in the error channel.\n   * A host re-issues a cell call the operator continued under a key of its\n   * own, since the timed-out attempt may have settled durably under the old\n   * one (a command's own timeout does).\n   */\n  readonly admit: (subject: string) => Effect.Effect<void, HarnessError>\n  /**\n   * Reports a timeout. Succeeds when this run's timeouts are not guarded, so\n   * the caller keeps its timeout; otherwise fails with the park.\n   */\n  readonly trip: (timeout: TimedOut) => Effect.Effect<void, HarnessError>\n}\n\n/**\n * Provides an engine port implementation.\n *\n * @category layers\n * @since 0.1.0\n * @slop\n */\nexport const layer = (implementation: EngineLike): Layer.Layer<EngineLike> =>\n  Layer.succeed(EngineLike)(make(implementation))\n\n/**\n * What one request resolves to on this engine.\n *\n * The answer of {@link EngineLike.resolve} where the host gives one, and\n * otherwise the honest default: the request as it was built, going to no route\n * anybody named. Written once, here, because a port that wraps another port\n * needs the same default the controller does. None is the host's own answer\n * and never the default: a port with no `resolve` sends what it was handed.\n *\n * @category conversions\n * @since 1.0.0-rc.0\n */\nexport const resolve = (\n  engine: EngineLike,\n  request: ModelRequest.ModelRequest\n): Effect.Effect<Option.Option<Resolved>> =>\n  engine.resolve === undefined\n    ? Effect.succeed(Option.some({ request, binding: Option.none() }))\n    : engine.resolve(request)\n\nconst unavailable = (operation: string, code: \"engine_failed\" | \"suspended\" = \"engine_failed\"): HarnessError =>\n  new HarnessError({\n    code,\n    message: `${operation} is unavailable`\n  })\n\n/**\n * Constructs an unavailable engine stub, optionally overriding operations.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const makeNoop = (overrides: Partial<EngineLike> = {}): EngineLike =>\n  EngineLike.of({\n    sealStep: () =>\n      Stream.unwrap(Effect.fn(\"EngineLike.sealStep\")(() => Effect.succeed(Stream.fail(unavailable(\"sealStep\"))))()),\n    splice: () => Stream.fail(unavailable(\"splice\")),\n    call: Effect.fn(\"EngineLike.call\")(() => Effect.fail(unavailable(\"call\"))),\n    record: Effect.fn(\"EngineLike.record\")(() => Effect.fail(unavailable(\"record\"))),\n    // Unobservable rather than unavailable. A stub engine has no workspace, and\n    // the honest report of that is \"I measured nothing\" \u2014 which the controller\n    // already knows how to read. Failing here instead would turn a host that\n    // simply has no tree into a failed run.\n    observe: Effect.succeed(Option.none()),\n    // Unpinnable for the same reason, and reported the same way: a stub engine\n    // has no store to pin a tree into, and the controller reads the absence as\n    // a resolved refusal the cell can route around.\n    capture: () => Effect.succeed(Option.none()),\n    suspend: Effect.fn(\"EngineLike.suspend\")(() => Effect.fail(unavailable(\"suspend\", \"suspended\"))),\n    ...overrides\n  })\n\n/**\n * Provides an unavailable engine stub.\n *\n * @category layers\n * @since 0.1.0\n * @slop\n */\nexport const layerNoop = (overrides: Partial<EngineLike> = {}): Layer.Layer<EngineLike> =>\n  Layer.succeed(EngineLike)(makeNoop(overrides))\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/ExternalTranscript.d.ts

@@ -0,0 +1,349 @@
+/**
+ * The conversations of agents a person runs beside Smithers, decoded from the agent's own transcript file
+ * into ordered, read-only entries (mvp.md M-38, ui-components.md T-UI-07 S2).
+ *
+ * Every entry carries its origin, agent kind, format version, session, source record identity and
+ * `read_only: true`; who the owner and the agent participant are is the caller's to say, never the
+ * transcript's. Decoding is pure: the caller supplies bytes in any chunking and keeps the returned state,
+ * so a growing file is tailed by decoding only what was appended. An incomplete last line waits for more
+ * bytes. A complete line that is not a record, a transcript without a version, a version this module does
+ * not support, and a record, event, item or content block this module does not name are tagged errors,
+ * never a guess: every skipped kind is listed below by name.
+ *
+ * Codex: `rollout-*.jsonl` files under `$CODEX_HOME/sessions`, profile `codex-rollout/<major.minor>` from
+ * the CLI release in `session_meta`. Items come from `event_msg` `item_completed` rows. `response_item` rows
+ * repeat them for the model and are skipped, except three the items leave out: a message between agents
+ * (`agent_message`), whose encrypted body is one placeholder; a code-mode script that failed
+ * (`custom_tool_call_output`), with the request that started it; and nothing else.
+ *
+ * Claude Code: `<session>.jsonl` files under `~/.claude/projects/<project>`, profile `claude-code/<major.minor>`
+ * from the `version` every conversation record carries. A tool call becomes one entry when its result arrives;
+ * the named bookkeeping rows outside the conversation chain (no `uuid`) are skipped.
+ *
+ * @since 1.0.0-rc.1
+ */
+import { Result, Schema } from "effect";
+/**
+ * The agents whose transcripts decode here.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export declare const AgentKind: Schema.Literals<readonly ["codex", "claude-code"]>;
+/**
+ * The value decoded by {@link AgentKind}.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export type AgentKind = typeof AgentKind.Type;
+/**
+ * One edited file as the agent reported it: its path, the kind of change and the unified diff.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export declare const EditedFile: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly change: Schema.Literals<readonly ["added", "modified", "deleted", "renamed"]>;
+    readonly renamed_to: Schema.optional<Schema.String>;
+    readonly diff: Schema.String;
+}>;
+/**
+ * What one entry says. Tool parts keep the agent's correlation id; edits keep the path and the reported
+ * outcome; a body the agent encrypted is a placeholder in its place, never dropped.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export declare const Part: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"prompt">;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"goal">;
+    readonly objective: Schema.String;
+    readonly status: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+    readonly final: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"reasoning">;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"encrypted">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"tool">;
+    readonly call_id: Schema.String;
+    readonly command: Schema.String;
+    /** Set when every part of the command only reads, searches or lists: "Read mvp.md". */
+    readonly reads: Schema.$Array<Schema.String>;
+    readonly status: Schema.Literals<readonly ["ok", "error", "running"]>;
+    readonly exit_code: Schema.optional<Schema.Number>;
+    readonly output: Schema.String;
+    readonly duration_ms: Schema.Number;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"edit">;
+    readonly call_id: Schema.String;
+    readonly files: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly change: Schema.Literals<readonly ["added", "modified", "deleted", "renamed"]>;
+        readonly renamed_to: Schema.optional<Schema.String>;
+        readonly diff: Schema.String;
+    }>>;
+    readonly outcome: Schema.Literals<readonly ["applied", "failed"]>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"search">;
+    readonly call_id: Schema.String;
+    readonly query: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"helper">;
+    readonly call_id: Schema.String;
+    readonly agent: Schema.String;
+    readonly activity: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"compaction">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"error">;
+    readonly message: Schema.String;
+}>]>;
+/**
+ * The value decoded by {@link Part}.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export type Part = typeof Part.Type;
+/**
+ * One read-only entry of an external conversation, in source order.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export declare const Entry: Schema.Struct<{
+    readonly origin: Schema.Literal<"external">;
+    readonly agent_kind: Schema.Literals<readonly ["codex", "claude-code"]>;
+    readonly format_version: Schema.String;
+    readonly session_id: Schema.String;
+    /**
+     * The record this entry came from: `<session>:<line>`. A record that yields several entries numbers the later
+     * ones `<session>:<line>#<n>`.
+     */
+    readonly source_id: Schema.String;
+    readonly read_only: Schema.Literal<true>;
+    readonly seq: Schema.Number;
+    /** Milliseconds since the epoch, from the record. */
+    readonly at: Schema.Number;
+    readonly turn_id: Schema.optional<Schema.String>;
+    /** `user` entries are the owner's; `assistant` entries are the agent's. */
+    readonly role: Schema.Literals<readonly ["user", "assistant"]>;
+    readonly part: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"prompt">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"goal">;
+        readonly objective: Schema.String;
+        readonly status: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly final: Schema.Boolean;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"reasoning">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"encrypted">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly call_id: Schema.String;
+        readonly command: Schema.String;
+        /** Set when every part of the command only reads, searches or lists: "Read mvp.md". */
+        readonly reads: Schema.$Array<Schema.String>;
+        readonly status: Schema.Literals<readonly ["ok", "error", "running"]>;
+        readonly exit_code: Schema.optional<Schema.Number>;
+        readonly output: Schema.String;
+        readonly duration_ms: Schema.Number;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"edit">;
+        readonly call_id: Schema.String;
+        readonly files: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly change: Schema.Literals<readonly ["added", "modified", "deleted", "renamed"]>;
+            readonly renamed_to: Schema.optional<Schema.String>;
+            readonly diff: Schema.String;
+        }>>;
+        readonly outcome: Schema.Literals<readonly ["applied", "failed"]>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"search">;
+        readonly call_id: Schema.String;
+        readonly query: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"helper">;
+        readonly call_id: Schema.String;
+        readonly agent: Schema.String;
+        readonly activity: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"compaction">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"error">;
+        readonly message: Schema.String;
+    }>]>;
+}>;
+/**
+ * The value decoded by {@link Entry}.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export type Entry = typeof Entry.Type;
+/**
+ * Why a transcript did not decode.
+ *
+ * @category errors
+ * @since 1.0.0-rc.1
+ */
+export declare const ExternalTranscriptErrorCode: Schema.Literals<readonly ["missing_version", "unsupported_version", "unsupported_record", "malformed_record"]>;
+/**
+ * The value decoded by {@link ExternalTranscriptErrorCode}.
+ *
+ * @category errors
+ * @since 1.0.0-rc.1
+ */
+export type ExternalTranscriptErrorCode = typeof ExternalTranscriptErrorCode.Type;
+declare const ExternalTranscriptError_base: Schema.Class<ExternalTranscriptError, Schema.TaggedStruct<"harness/ExternalTranscriptError", {
+    readonly code: Schema.Literals<readonly ["missing_version", "unsupported_version", "unsupported_record", "malformed_record"]>;
+    readonly message: Schema.String;
+    readonly line: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A transcript this module refuses to read, with the line it stopped at.
+ *
+ * @category errors
+ * @since 1.0.0-rc.1
+ */
+export declare class ExternalTranscriptError extends ExternalTranscriptError_base {
+}
+/**
+ * The Codex CLI releases whose rollout shape this module reads, by `major.minor`.
+ *
+ * @category constants
+ * @since 1.0.0-rc.1
+ */
+export declare const codexReleases: ReadonlyArray<string>;
+/**
+ * What a Codex decode remembers between chunks.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export interface CodexState {
+    /** Bytes after the last newline: a line the agent is still writing. */
+    readonly pending: string;
+    /** Complete lines read so far. */
+    readonly line: number;
+    /** Entries emitted so far. */
+    readonly seq: number;
+    readonly session?: {
+        readonly id: string;
+        readonly format_version: string;
+        readonly cwd: string;
+    } | undefined;
+    readonly goal?: string | undefined;
+    /** Code-mode scripts whose output has not arrived, by `call_id`: text the decoder keeps and never runs. */
+    readonly calls?: Readonly<Record<string, CodexCall>> | undefined;
+}
+/**
+ * A Codex code-mode request waiting for its output: the tool's name and the script it was given.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export interface CodexCall {
+    readonly name: string;
+    readonly input: string;
+}
+/**
+ * The state before the first byte.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.1
+ */
+export declare const codexStart: CodexState;
+/**
+ * A decoded chunk: the entries it completed and the state to pass with the next chunk.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export interface Decoded<State = CodexState> {
+    readonly state: State;
+    readonly entries: ReadonlyArray<Entry>;
+}
+/**
+ * Decode the next chunk of a Codex rollout. Pass `codexStart` with the first chunk and the returned state
+ * with each following one; any partition of the same bytes yields the same entries.
+ *
+ * @category decoding
+ * @since 1.0.0-rc.1
+ */
+export declare const decodeCodex: (state: CodexState, chunk: string) => Result.Result<Decoded, ExternalTranscriptError>;
+/**
+ * The Claude Code release lines whose transcript shape this module reads, by `major.minor`.
+ *
+ * @category constants
+ * @since 1.0.0-rc.1
+ */
+export declare const claudeReleases: ReadonlyArray<string>;
+/**
+ * A Claude Code tool call waiting for its result: the tool's name, its input and when the agent asked.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export interface ClaudeCall {
+    readonly name: string;
+    readonly input: unknown;
+    /** Milliseconds since the epoch, from the `tool_use` record. */
+    readonly at: number;
+}
+/**
+ * What a Claude Code decode remembers between chunks.
+ *
+ * @category models
+ * @since 1.0.0-rc.1
+ */
+export interface ClaudeState {
+    /** Bytes after the last newline: a line the agent is still writing. */
+    readonly pending: string;
+    /** Complete lines read so far. */
+    readonly line: number;
+    /** Entries emitted so far. */
+    readonly seq: number;
+    /** The session the first conversation record named. */
+    readonly session?: string | undefined;
+    /** The `promptId` of the latest user record: the turn later entries belong to. */
+    readonly turn?: string | undefined;
+    /** Tool calls whose result has not arrived, by `tool_use` id. */
+    readonly calls: Readonly<Record<string, ClaudeCall>>;
+}
+/**
+ * The state before the first byte.
+ *
+ * @category constructors
+ * @since 1.0.0-rc.1
+ */
+export declare const claudeStart: ClaudeState;
+/**
+ * Decode the next chunk of a Claude Code session transcript. Pass `claudeStart` with the first chunk and the
+ * returned state with each following one; any partition of the same bytes yields the same entries.
+ *
+ * Entries follow the order of the records that complete them. A tool call is held in `state.calls` from its
+ * `tool_use` record until the `tool_result` with the same id arrives, and becomes one entry at the result's line;
+ * a call whose result never arrives emits nothing.
+ *
+ * @category decoding
+ * @since 1.0.0-rc.1
+ */
+export declare const decodeClaude: (state: ClaudeState, chunk: string) => Result.Result<Decoded<ClaudeState>, ExternalTranscriptError>;
+export {};
+//# sourceMappingURL=ExternalTranscript.d.ts.map

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

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