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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Cell.d.ts","sourceRoot":"","sources":["../../src/Cell.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,KAAK,UAAU,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAS,MAAM,EAAU,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGhD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,wDAAgD,CAAA;AAErE;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;;;;;;AAE3C;;;;;;;;;GASG;AACH,qBAAa,MAAO,SAAQ,WAI1B;CAAG;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,UAAU,QAAQ,EAAE,MAAM,MAAM,KAAG,MACmC,CAAA;AAE/F;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,MAAM,MAAM,EAAE,WAAU,QAAuB,KAAG,MACP,CAAA;;IAchE;;;;;;;;;;;OAWG;;;AAvBL;;;;;;;;;;GAUG;AACH,qBAAa,QAAS,SAAQ,aAc5B;CAAG;;;;;AAEL;;;;;;;;;;;GAWG;AACH,qBAAa,QAAS,SAAQ,aAG5B;CAAG;;;;;AAEL;;;;;;GAMG;AACH,qBAAa,IAAK,SAAQ,SAGxB;CAAG;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,wFAA8E,CAAA;AAErG;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAE/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,CAAC,IAAI,KAAG,MACoB,CAAA;AAEpE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,6KASxB,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;;;;AAErD;;;;;;GAMG;AACH,qBAAa,OAAQ,SAAQ,YAE3B;CAAG;;;;;AAEL;;;;;;;GAOG;AACH,qBAAa,MAAO,SAAQ,WAG1B;CAAG;;;;IAYH,0DAA0D;;;AAV5D;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,aAK5B;CAAG;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,yFAA+E,CAAA;AAEnG;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;;;;;;;IAkBvC;;;;;;;;OAQG;;;AAxBL;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,mBAmBlC;CAAG;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,YAAY,UAAU,CAAC,cAAc,KAAG,cAQ5D,CAAA;AAEJ;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,6SAe1B,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAA+B,CAAA;AAEpE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAoBpE,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS;IACpB,6DAA6D;;IAE7D,kEAAkE;;IAElE,sFAAsF;;IAEtF,gEAAgE;;IAEhE,4FAA4F;;IAE5F,sFAAsF;;EAEtF,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;;IAgBrG,wDAAwD;;IAExD,mDAAmD;;IAEnD,oDAAoD;;IAEpD,qEAAqE;;IAErE,iEAAiE;;IAEjE,wDAAwD;;;AAxB1D;;;;;;;;;;;;GAYG;AACH,qBAAa,YAAa,SAAQ,iBAahC;CAAG;AAEL;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,cAAc,KAAK,MAAqC,CAAA;;;;;;;;;;;;;;IAgB9G;;;;;;;;;OASG;;IAEH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;QAxHH,6DAA6D;;QAE7D,kEAAkE;;QAElE,sFAAsF;;QAEtF,gEAAgE;;QAEhE,4FAA4F;;QAE5F,sFAAsF;;;IAgHtF;;;;;;;OAOG;;IAEH;;;;;;;OAOG;;;;;;;;;;;AAlEL;;;;;;GAMG;AACH,qBAAa,IAAK,SAAQ,SA6DxB;CAAG;AAEL;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,GACjB,YAAY,UAAU,CAAC,cAAc,EACrC,SAAS;IACP,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAA;IAC/B,wDAAwD;IACxD,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC,yEAAyE;IACzE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,CAAA;CACvC,KACA,IAYC,CAAA;AAEJ;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,IAAI,KAAG,MAAM,CAAC,IAAI,GAAG,SAW1D,CAAA;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,SAAS,CAAA;AAWpC;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,IAAI,MAAM,KAAG,MAAM,CAAC,IAA4B,CAAA;AAE3E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,CAAC,IAAI,KAAG,MAAM,GAAG,SAG1D,CAAA;;;;;IAmBG;;;;;;;;;OASG;;;AA1BP;;;;;;;;;;;GAWG;AACH,qBAAa,UAAW,SAAQ,eAiB/B;gBACa,KAAK,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,WAAW;CAMnE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW;;;;;EAKtB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;;;EAKtB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;IAA2C,CAAA;AAEzE;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAoB7D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,UAxB4D,OAAO;;;;;;;;;;uBAwBhB,CAAA;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,UAhC+D,OAAO,oEAgCjC,CAAA;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,UAxC4D,OAAO,mEAwCxB,CAAA;AAExE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,UAAU,KAAG,MAAM,CAAC,IAUvD,CAAA;AAWD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,QAAQ,CAqCvE,CAAA"}

package/dist/cjs/Cell.js

@@ -0,0 +1,431 @@
+"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 Cell_exports = {};
+__export(Cell_exports, {
+  Call: () => Call,
+  CallFailure: () => CallFailure,
+  CallFailureCode: () => CallFailureCode,
+  CallIdentity: () => CallIdentity,
+  CallResult: () => CallResult,
+  CallResultVariant: () => CallResultVariant,
+  CallSuccess: () => CallSuccess,
+  Complete: () => Complete,
+  Continue: () => Continue,
+  FlowProjection: () => FlowProjection,
+  Language: () => Language,
+  Outcome: () => Outcome,
+  Park: () => Park,
+  Raised: () => Raised,
+  Rejected: () => Rejected,
+  RejectionCode: () => RejectionCode,
+  Settled: () => Settled,
+  Source: () => Source,
+  Transition: () => Transition,
+  TreeEpoch: () => TreeEpoch,
+  baseCheckpoint: () => baseCheckpoint,
+  callFailure: () => callFailure,
+  callFailureHint: () => callFailureHint,
+  callOf: () => callOf,
+  checkpoint: () => checkpoint,
+  checkpointOf: () => checkpointOf,
+  declarationDigest: () => declarationDigest,
+  decodeCallResult: () => decodeCallResult,
+  decodeOutcome: () => decodeOutcome,
+  decodeTransition: () => decodeTransition,
+  defaultCallFailureCode: () => defaultCallFailureCode,
+  digestOf: () => digestOf,
+  displayDescriptor: () => displayDescriptor,
+  extract: () => extract,
+  project: () => project,
+  renderText: () => renderText,
+  source: () => source
+});
+module.exports = __toCommonJS(Cell_exports);
+var Digest = __toESM(require("@smthrs/core/Digest"), 1);
+var CanonicalJson = __toESM(require("@smthrs/model/CanonicalJson"), 1);
+var Descriptor = __toESM(require("@smthrs/registry/Descriptor"), 1);
+var import_effect = require("effect");
+var import_HarnessError = require("./HarnessError.js");
+var import_nonNegativeSafeInt = require("./internal/nonNegativeSafeInt.js");
+const Language = import_effect.Schema.Literals(["javascript", "typescript"]);
+class Source extends import_effect.Schema.Class("flows/harness/Cell/Source")({
+  language: Language,
+  text: import_effect.Schema.String,
+  digest: import_effect.Schema.String
+}) {
+}
+const digestOf = (language, text) => Digest.digest(CanonicalJson.stringify({ kind: "flows/harness/Cell/Source", language, text }));
+const source = (text, language = "javascript") => new Source({ language, text, digest: digestOf(language, text) });
+class Continue extends import_effect.Schema.TaggedClass("flows/harness/Cell/Continue")("continue", {
+  /**
+   * Why this frame changed nothing, when the controller demanded that it
+   * either mutate or say why not.
+   *
+   * The field exists because prose in the prompt did not stop a run from
+   * reading for its whole budget: a benchmark instance spent 100 frames and
+   * 132 calls without one edit attempt and then claimed the fix was
+   * implemented. A justification is the typed way out of the read-only cap —
+   * it is recorded, it buys a bounded grace, and it does not reset the
+   * counter that eventually stops the run. A cell writes one by calling
+   * `ctx.justify`.
+   */
+  justification: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
+}
+class Complete extends import_effect.Schema.TaggedClass("flows/harness/Cell/Complete")("complete", {
+  output: import_effect.Schema.String,
+  value: import_effect.Schema.optional(import_effect.Schema.Json)
+}) {
+}
+class Park extends import_effect.Schema.TaggedClass("flows/harness/Cell/Park")("park", {
+  reason: import_effect.Schema.Literals(["waiting-input", "waiting-event", "waiting-quota"]),
+  message: import_effect.Schema.String
+}) {
+}
+const Transition = import_effect.Schema.Union([Continue, Complete, Park]).pipe(import_effect.Schema.toTaggedUnion("_tag"));
+const renderText = (value) => typeof value === "string" ? value : CanonicalJson.stringify(value);
+const RejectionCode = import_effect.Schema.Literals([
+  "no_cell",
+  "output_truncated",
+  "imports_forbidden",
+  "compile_failed",
+  "invalid_transition",
+  "unsupported_language",
+  "limit_exceeded",
+  "stalled"
+]);
+class Settled extends import_effect.Schema.TaggedClass("flows/harness/Cell/Settled")("settled", {
+  transition: Transition
+}) {
+}
+class Raised extends import_effect.Schema.TaggedClass("flows/harness/Cell/Raised")("raised", {
+  name: import_effect.Schema.String,
+  message: import_effect.Schema.String
+}) {
+}
+class Rejected extends import_effect.Schema.TaggedClass("flows/harness/Cell/Rejected")("rejected", {
+  code: RejectionCode,
+  message: import_effect.Schema.String,
+  /** The spent resource when `code` is `limit_exceeded`. */
+  reason: import_effect.Schema.optional(import_effect.Schema.Literals(["heap"]))
+}) {
+}
+const Outcome = import_effect.Schema.Union([Settled, Raised, Rejected]).pipe(import_effect.Schema.toTaggedUnion("_tag"));
+class FlowProjection extends import_effect.Schema.Class("flows/harness/Cell/FlowProjection")({
+  name: import_effect.Schema.String,
+  description: import_effect.Schema.String,
+  capabilities: import_effect.Schema.Array(import_effect.Schema.String),
+  tier: Descriptor.EffectTier,
+  placement: import_effect.Schema.Option(Descriptor.Placement),
+  /**
+   * The call's input schema, as a JSON Schema document, when the descriptor
+   * carries one by value.
+   *
+   * Without it a cell can only guess an input shape from prose, and every
+   * guess costs a whole frame: a rejected call is one model turn, so learning
+   * `bash` takes `{ command, mode, reads, writes }` cost four turns of pure
+   * trial and error before any work began.
+   */
+  input: import_effect.Schema.Option(import_effect.Schema.Json).pipe(
+    import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(import_effect.Option.none())),
+    import_effect.Schema.withDecodingDefaultKey(import_effect.Effect.succeed(import_effect.Option.none()))
+  )
+}) {
+}
+const project = (descriptor) => new FlowProjection({
+  name: descriptor.name,
+  description: descriptor.description,
+  capabilities: descriptor.capabilities,
+  tier: descriptor.effects.tier,
+  placement: descriptor.placement,
+  input: descriptor.input._tag === "Inline" ? import_effect.Option.some(descriptor.input.document) : import_effect.Option.none()
+});
+const CallFailureCode = import_effect.Schema.Literals([
+  "unknown_flow",
+  "capability_refused",
+  "truncated_write",
+  "declaration_changed",
+  "invalid_input",
+  "unimplemented",
+  "timeout",
+  "run_completed",
+  "checkpoint_unavailable",
+  "checkpoint_exhausted",
+  "checkpoint_readonly",
+  "checkpoint_unsupported",
+  "flow_failed",
+  "flow_withheld"
+]);
+const defaultCallFailureCode = "flow_failed";
+const callFailureHint = Object.freeze({
+  unknown_flow: "Read ctx.flows and call one of the names it lists.",
+  capability_refused: "This run cannot reach that flow. Do the work with a flow ctx.flows lists.",
+  truncated_write: "The bytes you passed were a fragment. Restore from source control instead of writing captured output.",
+  declaration_changed: "Read ctx.flows again and reissue the call with the shape it now declares.",
+  invalid_input: "Fix the input against the flow's declared schema in ctx.flows and call it again in this cell.",
+  unimplemented: "This host cannot run that flow. Choose another one from ctx.flows.",
+  timeout: "Narrow the call \u2014 a smaller root, a tighter pattern, a shorter command \u2014 and issue it again in this cell.",
+  checkpoint_unavailable: "This host pins no checkpoint you can run against. Drop at; for a baseline, run the check before your edit, then again after it.",
+  checkpoint_exhausted: "Reuse a checkpoint you already hold, or ctx.base, instead of minting another one.",
+  checkpoint_readonly: "A checkpoint is a read-only view of a tree that has already been. Drop at and make the change on the live tree.",
+  checkpoint_unsupported: "This flow names what it touches rather than where it runs, so it cannot be pointed at a checkpoint. Drop at, or run the same work through a shell flow, which takes a working directory.",
+  run_completed: "The run is over, so nothing after this line runs. If that was early, guard the ctx.done or ctx.park on the check that decides it.",
+  flow_failed: "Read error.message: the flow itself says what went wrong, and it is usually fixable in this same cell.",
+  flow_withheld: "End this cell and reissue the call in the next one; ctx.flows lists the flow there."
+});
+const TreeEpoch = import_effect.Schema.Struct({
+  /** Earlier frames of this run that changed the workspace. */
+  frames: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  /** Calls of this frame that may write, issued before this one. */
+  calls: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  /** Digest of those calls, chained in issue order: which writes, not only how many. */
+  writes: import_effect.Schema.optional(import_effect.Schema.String),
+  /** Digest of the whole-tree measurement the frame opened on. */
+  tree: import_effect.Schema.optional(import_effect.Schema.String),
+  /** The run, when no whole-tree measurement exists: the reading is reused only inside it. */
+  session: import_effect.Schema.optional(import_effect.Schema.String),
+  /** The frame, beside `session`: an unmeasured tree may change during a model wait. */
+  frame: import_effect.Schema.optional(import_nonNegativeSafeInt.NonNegativeSafeInt)
+});
+class CallIdentity extends import_effect.Schema.Class("flows/harness/Cell/CallIdentity")({
+  /** The durable session/lineage the frame belongs to. */
+  session: import_effect.Schema.String,
+  /** The controller frame that produced the cell. */
+  frame: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  /** The digest of the cell source being executed. */
+  cell: import_effect.Schema.String,
+  /** The zero-based execution ordinal of this call within the cell. */
+  ordinal: import_nonNegativeSafeInt.NonNegativeSafeInt,
+  /** The digest of the resolved flow declaration being invoked. */
+  declaration: import_effect.Schema.String,
+  /** The resolved layer set in effect at the boundary. */
+  layers: import_effect.Schema.Array(import_effect.Schema.String)
+}) {
+}
+const declarationDigest = Descriptor.declarationDigest;
+class Call extends import_effect.Schema.Class("flows/harness/Cell/Call")({
+  flowName: import_effect.Schema.String,
+  input: import_effect.Schema.Json,
+  capabilities: import_effect.Schema.Array(import_effect.Schema.String),
+  effects: Descriptor.EffectDeclaration,
+  placement: import_effect.Schema.Option(Descriptor.Placement),
+  identity: CallIdentity,
+  /**
+   * The checkpoint this call runs against, when the cell named one.
+   *
+   * Absent is the ordinary case and means the live workspace. Present names a
+   * tree the run already pinned, and the host materializes that tree somewhere
+   * of its own choosing and runs the call there. It is journaled on the call
+   * because it is the difference between a reading of the tree as it is and a
+   * reading of the tree as it was, and a grader that cannot tell those apart
+   * cannot grade a fails-before proof at all.
+   */
+  at: import_effect.Schema.optional(import_effect.Schema.String),
+  /**
+   * Which version of the live tree a sealed reading is taken against.
+   *
+   * A sealed call is content-addressed on what it asked, and "the same path
+   * against the tree as it stands" is the same question only until something
+   * has written to the tree. Without this, the second of two identical reads
+   * around a write replays the first's answer and a run reports the pre-edit
+   * text after its own edit. `frames` is the run's frame clock — the count of
+   * earlier frames that changed the workspace, measured where the host can
+   * measure — and `calls` is how many calls of this frame that may write
+   * were issued before this one, with `writes` chaining what they asked, so
+   * two runs that wrote differently read different questions. All are derived
+   * from the journaled call
+   * sequence, so a replayed frame derives the same epoch and replays.
+   *
+   * The counters restart with every run, so they cannot tell a later run's
+   * read from an earlier run's across an edit made between them. `tree` is
+   * the digest of a journaled measurement taken after the model wait, which
+   * can; without a whole measurement, `session` and `frame` keep the reading
+   * to the frame that took it.
+   *
+   * Absent on every call that is not a sealed reading of the live tree: a
+   * checkpoint is immutable, and a non-sealed call already keys on its ordinal.
+   */
+  epoch: import_effect.Schema.optional(TreeEpoch),
+  /**
+   * What the resolved declaration says a call to this flow does.
+   *
+   * Carried on the call rather than looked up later, because the reader of a
+   * run is not the host that resolved it: a card reading a journal months
+   * afterwards holds the record and nothing else, and a flow name is not a
+   * meaning. Absent is unknown, and unknown stays unknown.
+   */
+  activity: import_effect.Schema.optional(Descriptor.FlowActivity),
+  /**
+   * How the resolved declaration says one recorded call to this flow reads.
+   *
+   * Display authority only. Neither this field nor `activity` enters a key:
+   * {@link callMaterial} and the durable call key name the fields they hash,
+   * and both digests in `@smthrs/registry` exclude these two, so enriching a
+   * declaration with them can neither replay nor re-approve anything.
+   */
+  presentation: import_effect.Schema.optional(Descriptor.CallPresentation)
+}) {
+}
+const callOf = (descriptor, options) => new Call({
+  flowName: descriptor.name,
+  input: options.input,
+  capabilities: descriptor.capabilities,
+  effects: descriptor.effects,
+  placement: descriptor.placement,
+  identity: options.identity,
+  ...options.at === void 0 ? {} : { at: options.at },
+  ...options.epoch === void 0 ? {} : { epoch: options.epoch },
+  ...descriptor.activity === void 0 ? {} : { activity: descriptor.activity },
+  ...descriptor.presentation === void 0 ? {} : { presentation: descriptor.presentation }
+});
+const displayDescriptor = (call) => call.activity === void 0 && call.presentation === void 0 ? void 0 : {
+  name: call.flowName,
+  ...call.activity === void 0 ? {} : { activity: call.activity },
+  ...call.presentation === void 0 ? {} : {
+    presentation: {
+      verb: { ...call.presentation.verb },
+      subject: call.presentation.subject,
+      result: call.presentation.result
+    }
+  }
+};
+const baseCheckpoint = "base";
+const Handle = import_effect.Schema.Struct({ checkpoint: import_effect.Schema.NonEmptyString });
+const checkpoint = (id) => ({ checkpoint: id });
+const checkpointOf = (value) => {
+  const decoded = import_effect.Schema.decodeUnknownResult(Handle)(value);
+  return decoded._tag === "Success" ? decoded.success.checkpoint : void 0;
+};
+class CallResult extends import_effect.Schema.Class("flows/harness/Cell/CallResult")(
+  import_effect.Schema.Struct({
+    outcome: import_effect.Schema.Literals(["success", "failure"]),
+    value: import_effect.Schema.Json,
+    message: import_effect.Schema.optional(import_effect.Schema.String),
+    /**
+     * Why a failed call failed, from the closed set the cell may branch on.
+     *
+     * Prose is what a boundary says; a code is what a program reads. Without one
+     * the only way for a cell to tell "that flow does not exist" from "that
+     * command timed out" was to match the message, so cells did not tell them
+     * apart at all. Absent means {@link defaultCallFailureCode}, which is what a
+     * flow's own failure gets: the flow said why in `message` and the harness
+     * does not classify it.
+     */
+    code: import_effect.Schema.optional(CallFailureCode)
+  })
+) {
+  constructor(props, options) {
+    super(CallResultVariant.make(props), options);
+  }
+}
+const CallSuccess = import_effect.Schema.Struct({
+  outcome: import_effect.Schema.Literal("success"),
+  value: import_effect.Schema.Json,
+  message: import_effect.Schema.optional(import_effect.Schema.String),
+  code: import_effect.Schema.optionalKey(import_effect.Schema.Never)
+});
+const CallFailure = import_effect.Schema.Struct({
+  outcome: import_effect.Schema.Literal("failure"),
+  value: import_effect.Schema.Json,
+  message: import_effect.Schema.optional(import_effect.Schema.String),
+  code: import_effect.Schema.optional(CallFailureCode)
+});
+const CallResultVariant = import_effect.Schema.Union([CallSuccess, CallFailure]);
+const decodeBoundary = (schema, name) => (value) => import_effect.Effect.suspend(
+  () => import_effect.Effect.gen(function* () {
+    const encoded = yield* import_effect.Schema.decodeUnknownEffect(import_effect.Schema.toEncoded(schema), { onExcessProperty: "error" })(value);
+    return yield* import_effect.Schema.decodeUnknownEffect(schema, { onExcessProperty: "error" })(encoded);
+  })
+).pipe(
+  import_effect.Effect.catchCause(
+    (cause) => import_effect.Effect.fail(
+      new import_HarnessError.HarnessError({
+        code: "engine_failed",
+        message: `Invalid recorded cell ${name}`,
+        cause: import_effect.Cause.squash(cause)
+      })
+    )
+  )
+);
+const decodeCallResult = decodeBoundary(CallResultVariant, "call result");
+const decodeOutcome = decodeBoundary(Outcome, "outcome");
+const decodeTransition = decodeBoundary(Transition, "transition");
+const callFailure = (result) => {
+  const code = result.code ?? defaultCallFailureCode;
+  return {
+    ok: false,
+    error: {
+      code,
+      message: result.message ?? "The flow call failed",
+      hint: callFailureHint[code]
+    }
+  };
+};
+const fenced = /^```(?<info>[^\n`]*)\r?\n(?<body>[\s\S]*?)(?:\n?(?<close>^```[ \t]*(?=\r?$))|(?![\s\S]))/gm;
+const languageOf = (info) => {
+  const tokens = new Set(info.trim().toLowerCase().split(/\s+/).filter((token) => token.length > 0));
+  if (tokens.has("ts") || tokens.has("typescript")) return "typescript";
+  if (tokens.has("cell") || tokens.has("js") || tokens.has("javascript")) return "javascript";
+  return void 0;
+};
+const extract = (text) => {
+  const bodies = [];
+  const distinct = /* @__PURE__ */ new Set();
+  let typed = false;
+  fenced.lastIndex = 0;
+  for (const match of text.matchAll(fenced)) {
+    const candidate = languageOf(match.groups?.info ?? "");
+    if (candidate === void 0) continue;
+    if (match.groups?.close === void 0) {
+      return import_effect.Result.fail(
+        new Rejected({
+          code: "output_truncated",
+          message: "The response contains an unterminated cell fence. No blocks ran. Emit the complete program with every fence closed."
+        })
+      );
+    }
+    if (candidate === "typescript") typed = true;
+    const body = match.groups?.body ?? "";
+    bodies.push(body);
+    distinct.add(body);
+  }
+  if (bodies.length === 0) {
+    return import_effect.Result.fail(
+      new Rejected({
+        code: "no_cell",
+        message: "No cell was found in the response. Emit a fenced ```cell block containing the JavaScript for this transition."
+      })
+    );
+  }
+  return import_effect.Result.succeed({
+    source: source([...distinct].join("\n"), typed ? "typescript" : "javascript"),
+    blocks: bodies.length
+  });
+};
+//# sourceMappingURL=Cell.js.map

package/dist/cjs/Cell.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Cell.ts"],
+  "sourcesContent": ["/**\n * The cell contract.\n *\n * A Smithers frame is `model -> generated cell -> realm evaluation ->\n * individually durable flow calls -> next transition`. This module owns the\n * serializable half of that sentence: the cell source the model emits, the\n * transition the cell settled, the typed outcomes a cell may settle with, and\n * the identity carried by every flow call made inside one.\n *\n * Nothing here executes anything. Execution is `Sandbox`; durability is\n * `EngineLike.call`; the loop is `CellTurn`.\n *\n * A cell does not *return* its transition. The realm is a REPL that outlives\n * the cell, so a cell states its intent by calling `ctx.done` or `ctx.park` and\n * `Sandbox.replTransition` builds the value; there is no returned object to\n * decode.\n *\n * Governing design: `../docs/concepts.md#durable-cell-loop`,\n * `../docs/concepts.md#repl-realm` and\n * `../docs/concepts.md#agent-cell-context`.\n *\n * @since 0.1.0\n */\n\nimport * as Digest from \"@smthrs/core/Digest\"\nimport * as CanonicalJson from \"@smthrs/model/CanonicalJson\"\nimport * as Descriptor from \"@smthrs/registry/Descriptor\"\nimport { Cause, Effect, Option, Result, Schema } from \"effect\"\nimport { HarnessError } from \"./HarnessError.ts\"\nimport { NonNegativeSafeInt } from \"./internal/nonNegativeSafeInt.ts\"\n\n/**\n * The source language a cell is written in.\n *\n * Both shipped bindings run a `typescript` cell by erasing its type-only\n * syntax \u2014 never by emitting new runtime behaviour, so a construct that needs\n * JavaScript emit is a `compile_failed` rejection rather than a silent\n * transform. A binding that cannot compile at all rejects with\n * `unsupported_language`; neither shipped binding needs to.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport const Language = Schema.Literals([\"javascript\", \"typescript\"])\n\n/**\n * The source language a cell is written in.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Language = typeof Language.Type\n\n/**\n * One unit of agent-authored source and its stable content digest.\n *\n * The digest is part of every call identity produced inside the cell, so\n * editing one character of the source re-keys every boundary within it.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Source extends Schema.Class<Source>(\"flows/harness/Cell/Source\")({\n  language: Language,\n  text: Schema.String,\n  digest: Schema.String\n}) {}\n\n/**\n * Computes the stable digest of cell source.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const digestOf = (language: Language, text: string): string =>\n  Digest.digest(CanonicalJson.stringify({ kind: \"flows/harness/Cell/Source\", language, text }))\n\n/**\n * Constructs cell source with its computed digest.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const source = (text: string, language: Language = \"javascript\"): Source =>\n  new Source({ language, text, digest: digestOf(language, text) })\n\n/**\n * The cell's turn ended without settling the run.\n *\n * A REPL cell that calls neither `ctx.done` nor `ctx.park` gets another frame,\n * and this is what that frame is journaled as. The only thing it carries is a\n * justification; all other bookkeeping belongs to the realm.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Continue extends Schema.TaggedClass<Continue>(\"flows/harness/Cell/Continue\")(\"continue\", {\n  /**\n   * Why this frame changed nothing, when the controller demanded that it\n   * either mutate or say why not.\n   *\n   * The field exists because prose in the prompt did not stop a run from\n   * reading for its whole budget: a benchmark instance spent 100 frames and\n   * 132 calls without one edit attempt and then claimed the fix was\n   * implemented. A justification is the typed way out of the read-only cap \u2014\n   * it is recorded, it buys a bounded grace, and it does not reset the\n   * counter that eventually stops the run. A cell writes one by calling\n   * `ctx.justify`.\n   */\n  justification: Schema.optional(Schema.String)\n}) {}\n\n/**\n * The cell declares the task finished and supplies its final output.\n *\n * A completion carries no self-reported proof. The run's evidence is the calls\n * it actually made \u2014 every one journaled as `cell-call-settled` with its real\n * input and result \u2014 and a field in which the model restates which of them\n * proved the work would be a claim about a check rather than the check.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Complete extends Schema.TaggedClass<Complete>(\"flows/harness/Cell/Complete\")(\"complete\", {\n  output: Schema.String,\n  value: Schema.optional(Schema.Json)\n}) {}\n\n/**\n * The cell asks the controller to park the run durably.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Park extends Schema.TaggedClass<Park>(\"flows/harness/Cell/Park\")(\"park\", {\n  reason: Schema.Literals([\"waiting-input\", \"waiting-event\", \"waiting-quota\"]),\n  message: Schema.String\n}) {}\n\n/**\n * The serializable decision one cell returns.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport const Transition = Schema.Union([Continue, Complete, Park]).pipe(Schema.toTaggedUnion(\"_tag\"))\n\n/**\n * The serializable decision one cell returns.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Transition = typeof Transition.Type\n\n/**\n * Renders a projected value as the text one context entry carries.\n *\n * A string is itself. Everything else is canonical JSON, which is the whole of\n * the \"render structs as JSON, always\" rule: a structured value reaches the\n * next model turn as the value it is.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const renderText = (value: Schema.Json): string =>\n  typeof value === \"string\" ? value : CanonicalJson.stringify(value)\n\n/**\n * Stable reasons a cell failed to produce a transition.\n *\n * Every one of these is a durable observation the model may correct on a later\n * frame; none of them is a harness crash.\n *\n * `imports_forbidden` names module syntax the cell itself uses, which\n * `Sandbox.compile` finds by parsing. A quoted mention of an import is data:\n * cells routinely carry a `bash` command whose heredoc imports a Python module,\n * and those cells run.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport const RejectionCode = Schema.Literals([\n  \"no_cell\",\n  \"output_truncated\",\n  \"imports_forbidden\",\n  \"compile_failed\",\n  \"invalid_transition\",\n  \"unsupported_language\",\n  \"limit_exceeded\",\n  \"stalled\"\n])\n\n/**\n * Stable reasons a cell failed to produce a transition.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type RejectionCode = typeof RejectionCode.Type\n\n/**\n * The cell ran and returned a well-formed transition.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Settled extends Schema.TaggedClass<Settled>(\"flows/harness/Cell/Settled\")(\"settled\", {\n  transition: Transition\n}) {}\n\n/**\n * The cell ran and threw. The thrown value is projected into stable text so it\n * survives the journal and the next frame's context.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Raised extends Schema.TaggedClass<Raised>(\"flows/harness/Cell/Raised\")(\"raised\", {\n  name: Schema.String,\n  message: Schema.String\n}) {}\n\n/**\n * The cell never ran, or ran and returned something that is not a transition.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Rejected extends Schema.TaggedClass<Rejected>(\"flows/harness/Cell/Rejected\")(\"rejected\", {\n  code: RejectionCode,\n  message: Schema.String,\n  /** The spent resource when `code` is `limit_exceeded`. */\n  reason: Schema.optional(Schema.Literals([\"heap\"]))\n}) {}\n\n/**\n * Everything one cell evaluation may settle with.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport const Outcome = Schema.Union([Settled, Raised, Rejected]).pipe(Schema.toTaggedUnion(\"_tag\"))\n\n/**\n * Everything one cell evaluation may settle with.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type Outcome = typeof Outcome.Type\n\n/**\n * The read-only projection of one callable flow handed to a cell.\n *\n * This is exactly what `ctx.flows` exposes: enough for the model to choose a\n * call and for the cell to reason about it, and nothing that carries authority.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class FlowProjection extends Schema.Class<FlowProjection>(\"flows/harness/Cell/FlowProjection\")({\n  name: Schema.String,\n  description: Schema.String,\n  capabilities: Schema.Array(Schema.String),\n  tier: Descriptor.EffectTier,\n  placement: Schema.Option(Descriptor.Placement),\n  /**\n   * The call's input schema, as a JSON Schema document, when the descriptor\n   * carries one by value.\n   *\n   * Without it a cell can only guess an input shape from prose, and every\n   * guess costs a whole frame: a rejected call is one model turn, so learning\n   * `bash` takes `{ command, mode, reads, writes }` cost four turns of pure\n   * trial and error before any work began.\n   */\n  input: Schema.Option(Schema.Json).pipe(\n    Schema.withConstructorDefault(Effect.succeed(Option.none())),\n    Schema.withDecodingDefaultKey(Effect.succeed(Option.none()))\n  )\n}) {}\n\n/**\n * Projects a discovered descriptor into the cell-visible catalog entry.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const project = (descriptor: Descriptor.FlowDescriptor): FlowProjection =>\n  new FlowProjection({\n    name: descriptor.name,\n    description: descriptor.description,\n    capabilities: descriptor.capabilities,\n    tier: descriptor.effects.tier,\n    placement: descriptor.placement,\n    input: descriptor.input._tag === \"Inline\" ? Option.some(descriptor.input.document) : Option.none()\n  })\n\n/**\n * Why one flow call failed, as a closed set a cell may branch on.\n *\n * Every member is a refusal or a budget the harness itself owns, plus one for\n * everything a flow reports about its own work. Add a member; never repurpose\n * one \u2014 a cell reads these, and so does a grader counting failure classes in a\n * journal.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport const CallFailureCode = Schema.Literals([\n  \"unknown_flow\",\n  \"capability_refused\",\n  \"truncated_write\",\n  \"declaration_changed\",\n  \"invalid_input\",\n  \"unimplemented\",\n  \"timeout\",\n  \"run_completed\",\n  \"checkpoint_unavailable\",\n  \"checkpoint_exhausted\",\n  \"checkpoint_readonly\",\n  \"checkpoint_unsupported\",\n  \"flow_failed\",\n  \"flow_withheld\"\n])\n\n/**\n * Why one flow call failed.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport type CallFailureCode = typeof CallFailureCode.Type\n\n/**\n * The code a failure carries when nothing classified it.\n *\n * @category constants\n * @since 0.1.0\n * @slop\n */\nexport const defaultCallFailureCode: CallFailureCode = \"flow_failed\"\n\n/**\n * The one action that recovers each failure class, stated to the cell.\n *\n * A code says what happened; the hint says what to do next, in the same frame.\n * They are here rather than at each raising site so the same class always reads\n * the same way whichever boundary refused.\n *\n * @category constants\n * @since 0.1.0\n * @slop\n */\nexport const callFailureHint: Readonly<Record<CallFailureCode, string>> = Object.freeze({\n  unknown_flow: \"Read ctx.flows and call one of the names it lists.\",\n  capability_refused: \"This run cannot reach that flow. Do the work with a flow ctx.flows lists.\",\n  truncated_write:\n    \"The bytes you passed were a fragment. Restore from source control instead of writing captured output.\",\n  declaration_changed: \"Read ctx.flows again and reissue the call with the shape it now declares.\",\n  invalid_input: \"Fix the input against the flow's declared schema in ctx.flows and call it again in this cell.\",\n  unimplemented: \"This host cannot run that flow. Choose another one from ctx.flows.\",\n  timeout: \"Narrow the call \u2014 a smaller root, a tighter pattern, a shorter command \u2014 and issue it again in this cell.\",\n  checkpoint_unavailable:\n    \"This host pins no checkpoint you can run against. Drop at; for a baseline, run the check before your edit, then again after it.\",\n  checkpoint_exhausted: \"Reuse a checkpoint you already hold, or ctx.base, instead of minting another one.\",\n  checkpoint_readonly:\n    \"A checkpoint is a read-only view of a tree that has already been. Drop at and make the change on the live tree.\",\n  checkpoint_unsupported:\n    \"This flow names what it touches rather than where it runs, so it cannot be pointed at a checkpoint. Drop at, or run the same work through a shell flow, which takes a working directory.\",\n  run_completed:\n    \"The run is over, so nothing after this line runs. If that was early, guard the ctx.done or ctx.park on the check that decides it.\",\n  flow_failed: \"Read error.message: the flow itself says what went wrong, and it is usually fixable in this same cell.\",\n  flow_withheld: \"End this cell and reissue the call in the next one; ctx.flows lists the flow there.\"\n})\n\n/**\n * Which version of the live tree a sealed call reads; see `Call.epoch`.\n *\n * @category models\n * @since 1.0.0-rc.1\n */\nexport const TreeEpoch = Schema.Struct({\n  /** Earlier frames of this run that changed the workspace. */\n  frames: NonNegativeSafeInt,\n  /** Calls of this frame that may write, issued before this one. */\n  calls: NonNegativeSafeInt,\n  /** Digest of those calls, chained in issue order: which writes, not only how many. */\n  writes: Schema.optional(Schema.String),\n  /** Digest of the whole-tree measurement the frame opened on. */\n  tree: Schema.optional(Schema.String),\n  /** The run, when no whole-tree measurement exists: the reading is reused only inside it. */\n  session: Schema.optional(Schema.String),\n  /** The frame, beside `session`: an unmeasured tree may change during a model wait. */\n  frame: Schema.optional(NonNegativeSafeInt)\n})\n\n/**\n * Which version of the live tree a sealed call reads; see `Call.epoch`.\n *\n * @category models\n * @since 1.0.0-rc.1\n */\nexport type TreeEpoch = typeof TreeEpoch.Type\n\n/**\n * The tree a frame's sealed readings stand on: a measured digest, or the run and frame.\n *\n * @category models\n * @since 1.0.0-rc.1\n */\nexport type LiveTree = { readonly tree: string } | { readonly session: string; readonly frame: number }\n\n/**\n * The complete identity of one flow call made inside one cell.\n *\n * Identity is what makes a mid-cell crash replayable. Re-executing the cell\n * source reaches the same lexical call in the same order with the same\n * declaration, so the boundary keys identically and replays; anything that\n * differs \u2014 a new frame, an edited cell, a different resolved layer set \u2014 keys\n * differently and executes.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class CallIdentity extends Schema.Class<CallIdentity>(\"flows/harness/Cell/CallIdentity\")({\n  /** The durable session/lineage the frame belongs to. */\n  session: Schema.String,\n  /** The controller frame that produced the cell. */\n  frame: NonNegativeSafeInt,\n  /** The digest of the cell source being executed. */\n  cell: Schema.String,\n  /** The zero-based execution ordinal of this call within the cell. */\n  ordinal: NonNegativeSafeInt,\n  /** The digest of the resolved flow declaration being invoked. */\n  declaration: Schema.String,\n  /** The resolved layer set in effect at the boundary. */\n  layers: Schema.Array(Schema.String)\n}) {}\n\n/**\n * Computes the declaration digest folded into a call identity.\n *\n * Re-exported from `@smthrs/registry`, which owns `FlowDescriptor` and\n * therefore owns what one declaration hashes to. It is the same number\n * `@smthrs/chain` keys its catalog entries with, so a declaration has one\n * identity across the boundary rather than one per package.\n *\n * @category constructors\n * @since 0.1.0\n * @slop\n */\nexport const declarationDigest: (descriptor: Descriptor.FlowDescriptor) => string = Descriptor.declarationDigest\n\n/**\n * One flow call requested from inside a cell.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class Call extends Schema.Class<Call>(\"flows/harness/Cell/Call\")({\n  flowName: Schema.String,\n  input: Schema.Json,\n  capabilities: Schema.Array(Schema.String),\n  effects: Descriptor.EffectDeclaration,\n  placement: Schema.Option(Descriptor.Placement),\n  identity: CallIdentity,\n  /**\n   * The checkpoint this call runs against, when the cell named one.\n   *\n   * Absent is the ordinary case and means the live workspace. Present names a\n   * tree the run already pinned, and the host materializes that tree somewhere\n   * of its own choosing and runs the call there. It is journaled on the call\n   * because it is the difference between a reading of the tree as it is and a\n   * reading of the tree as it was, and a grader that cannot tell those apart\n   * cannot grade a fails-before proof at all.\n   */\n  at: Schema.optional(Schema.String),\n  /**\n   * Which version of the live tree a sealed reading is taken against.\n   *\n   * A sealed call is content-addressed on what it asked, and \"the same path\n   * against the tree as it stands\" is the same question only until something\n   * has written to the tree. Without this, the second of two identical reads\n   * around a write replays the first's answer and a run reports the pre-edit\n   * text after its own edit. `frames` is the run's frame clock \u2014 the count of\n   * earlier frames that changed the workspace, measured where the host can\n   * measure \u2014 and `calls` is how many calls of this frame that may write\n   * were issued before this one, with `writes` chaining what they asked, so\n   * two runs that wrote differently read different questions. All are derived\n   * from the journaled call\n   * sequence, so a replayed frame derives the same epoch and replays.\n   *\n   * The counters restart with every run, so they cannot tell a later run's\n   * read from an earlier run's across an edit made between them. `tree` is\n   * the digest of a journaled measurement taken after the model wait, which\n   * can; without a whole measurement, `session` and `frame` keep the reading\n   * to the frame that took it.\n   *\n   * Absent on every call that is not a sealed reading of the live tree: a\n   * checkpoint is immutable, and a non-sealed call already keys on its ordinal.\n   */\n  epoch: Schema.optional(TreeEpoch),\n  /**\n   * What the resolved declaration says a call to this flow does.\n   *\n   * Carried on the call rather than looked up later, because the reader of a\n   * run is not the host that resolved it: a card reading a journal months\n   * afterwards holds the record and nothing else, and a flow name is not a\n   * meaning. Absent is unknown, and unknown stays unknown.\n   */\n  activity: Schema.optional(Descriptor.FlowActivity),\n  /**\n   * How the resolved declaration says one recorded call to this flow reads.\n   *\n   * Display authority only. Neither this field nor `activity` enters a key:\n   * {@link callMaterial} and the durable call key name the fields they hash,\n   * and both digests in `@smthrs/registry` exclude these two, so enriching a\n   * declaration with them can neither replay nor re-approve anything.\n   */\n  presentation: Schema.optional(Descriptor.CallPresentation)\n}) {}\n\n/**\n * Builds the call one resolved declaration and one cell invocation make.\n *\n * A constructor rather than an object literal at the boundary: what a call\n * carries about its declaration is a contract two producers project into a\n * journal (`AgentSession.trace` and the native `CallFact`), and a reader can\n * only be as complete as this. A field copied from a descriptor onto a call\n * belongs here, where the copy is stated once.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const callOf = (\n  descriptor: Descriptor.FlowDescriptor,\n  options: {\n    readonly input: Schema.Json\n    readonly identity: CallIdentity\n    /** The checkpoint the cell named, when it named one. */\n    readonly at?: string | undefined\n    /** The live tree's version, for a sealed reading taken after a write. */\n    readonly epoch?: TreeEpoch | undefined\n  }\n): Call =>\n  new Call({\n    flowName: descriptor.name,\n    input: options.input,\n    capabilities: descriptor.capabilities,\n    effects: descriptor.effects,\n    placement: descriptor.placement,\n    identity: options.identity,\n    ...(options.at === undefined ? {} : { at: options.at }),\n    ...(options.epoch === undefined ? {} : { epoch: options.epoch }),\n    ...(descriptor.activity === undefined ? {} : { activity: descriptor.activity }),\n    ...(descriptor.presentation === undefined ? {} : { presentation: descriptor.presentation })\n  })\n\n/**\n * The display projection one recorded call carries for whoever reads it back.\n *\n * `undefined` when the declaration claimed neither field, so the record stays\n * byte-identical to the one an undeclared flow produces and a reader's\n * compatibility table still applies to it. The name travels with the fields so\n * a reader can refuse metadata that belongs to a different flow.\n *\n * @category projections\n * @since 1.0.0-rc.0\n */\nexport const displayDescriptor = (call: Call): Schema.Json | undefined =>\n  call.activity === undefined && call.presentation === undefined ? undefined : {\n    name: call.flowName,\n    ...(call.activity === undefined ? {} : { activity: call.activity }),\n    ...(call.presentation === undefined ? {} : {\n      presentation: {\n        verb: { ...call.presentation.verb },\n        subject: call.presentation.subject,\n        result: call.presentation.result\n      }\n    })\n  }\n\n/**\n * The id naming the tree a run opened on, pinned for free and always present.\n *\n * The dominant use of a checkpoint is a fails-before proof, and the frame that\n * wants one is almost never the frame that could have foreseen it: by the time\n * a run knows which command reproduces the bug it has usually already edited.\n * So this id exists without anybody minting it. A host resolves it to whatever\n * it recorded as the run's opening tree \u2014 for the SWE-bench rig, the\n * `refs/flows/capture-base` commit its own setup wrote \u2014 and a host with no\n * such record answers `checkpoint_unavailable` like any other.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const baseCheckpoint = \"base\"\n\n/**\n * The wire shape of the value `ctx.checkpoint()` resolves with.\n *\n * A handle is an opaque record rather than a bare string so a cell cannot pass\n * an arbitrary string as `at` by accident, and so a future host can carry more\n * beside the id without changing what a cell writes.\n */\nconst Handle = Schema.Struct({ checkpoint: Schema.NonEmptyString })\n\n/**\n * Builds the handle a cell holds for one checkpoint.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const checkpoint = (id: string): Schema.Json => ({ checkpoint: id })\n\n/**\n * Reads the checkpoint id out of whatever a cell passed as `at`.\n *\n * `undefined` means \"that was not a checkpoint\", which the boundary answers as\n * an ordinary `invalid_input` failure rather than by guessing. It is\n * deliberately strict: a handle is the only thing that names a tree, and a\n * string that happens to look like an id would let a cell address a snapshot\n * the run never took.\n *\n * @category conversions\n * @since 0.1.0\n */\nexport const checkpointOf = (value: Schema.Json): string | undefined => {\n  const decoded = Schema.decodeUnknownResult(Handle)(value)\n  return decoded._tag === \"Success\" ? decoded.success.checkpoint : undefined\n}\n\n/**\n * The settled outcome of one flow call.\n *\n * A `failure` resolves in the cell as a `{ ok: false, error }` envelope that\n * it may inspect and recover from; it does not throw and is never a harness\n * failure. Anything the cell cannot see, such as a permission park or an abort,\n * travels in the effect's error channel instead.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport class CallResult extends Schema.Class<CallResult>(\"flows/harness/Cell/CallResult\")(\n  Schema.Struct({\n    outcome: Schema.Literals([\"success\", \"failure\"]),\n    value: Schema.Json,\n    message: Schema.optional(Schema.String),\n    /**\n     * Why a failed call failed, from the closed set the cell may branch on.\n     *\n     * Prose is what a boundary says; a code is what a program reads. Without one\n     * the only way for a cell to tell \"that flow does not exist\" from \"that\n     * command timed out\" was to match the message, so cells did not tell them\n     * apart at all. Absent means {@link defaultCallFailureCode}, which is what a\n     * flow's own failure gets: the flow said why in `message` and the harness\n     * does not classify it.\n     */\n    code: Schema.optional(CallFailureCode)\n  })\n) {\n  constructor(props: CallResultVariant, options?: Schema.MakeOptions) {\n    // The encoded schema is the durable wire contract used in sealed keys.\n    // Refining its AST would re-key valid recorded results. Admission checks\n    // belong here and in decodeCallResult, which also revalidates instances.\n    super(CallResultVariant.make(props), options)\n  }\n}\n\n/**\n * A successful call cannot carry a failure code. The wire field names remain\n * the same as current CallResult records.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const CallSuccess = Schema.Struct({\n  outcome: Schema.Literal(\"success\"),\n  value: Schema.Json,\n  message: Schema.optional(Schema.String),\n  code: Schema.optionalKey(Schema.Never)\n})\n\n/**\n * A failed call, with the existing absent-code meaning of flow_failed.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const CallFailure = Schema.Struct({\n  outcome: Schema.Literal(\"failure\"),\n  value: Schema.Json,\n  message: Schema.optional(Schema.String),\n  code: Schema.optional(CallFailureCode)\n})\n\n/**\n * Discriminated result at a decoded persistence or host boundary.\n *\n * @category schemas\n * @since 1.0.0-rc.0\n */\nexport const CallResultVariant = Schema.Union([CallSuccess, CallFailure])\n\n/**\n * Discriminated result at a decoded persistence or host boundary.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport type CallResultVariant = typeof CallResultVariant.Type\n\nconst decodeBoundary = <S extends Schema.Constraint>(schema: S, name: string) => (value: unknown) =>\n  Effect.suspend(() =>\n    Effect.gen(function*() {\n      const encoded = yield* Schema.decodeUnknownEffect(Schema.toEncoded(schema), { onExcessProperty: \"error\" })(value)\n      return yield* Schema.decodeUnknownEffect(schema, { onExcessProperty: \"error\" })(encoded)\n    })\n  ).pipe(\n    Effect.catchCause((cause) =>\n      Effect.fail(\n        new HarnessError({\n          code: \"engine_failed\",\n          message: `Invalid recorded cell ${name}`,\n          cause: Cause.squash(cause)\n        })\n      )\n    )\n  )\n\n/**\n * Decode a host or persisted result before the cell can observe it.\n *\n * @category decoders\n * @since 1.0.0-rc.0\n */\nexport const decodeCallResult = decodeBoundary(CallResultVariant, \"call result\")\n\n/**\n * Refuse contradictory or incomplete recorded evaluation outcomes.\n *\n * @category decoders\n * @since 1.0.0-rc.0\n */\nexport const decodeOutcome = decodeBoundary(Outcome, \"outcome\")\n\n/**\n * Refuse contradictory or incomplete recorded transitions.\n *\n * @category decoders\n * @since 1.0.0-rc.0\n */\nexport const decodeTransition = decodeBoundary(Transition, \"transition\")\n\n/**\n * The failure envelope a cell observes when a flow call does not succeed.\n *\n * A failed call **resolves** with this value; it does not throw. That is the\n * whole of change 8: an unrecoverable rejection turned every failed call into a\n * lost frame, because the recovery branch the model had already written sat\n * behind the throw and never ran, and every sibling call the cell had already\n * paid for went with it. `psf__requests-2317` lost two settled greps and a\n * probe to one call against a directory that did not exist; `django-14351`\n * spent ~$0.46 on the same class across five frames.\n *\n * The shape is fixed and small \u2014 `{ ok: false, error: { code, message, hint } }`\n * \u2014 because a cell branches on `.ok` and reads `.error.code`. A successful call\n * still resolves with the flow's own value, unwrapped, so the ordinary\n * `result.stdout` shape a cell is trained on is unchanged.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const callFailure = (result: CallResult): Schema.Json => {\n  const code = result.code ?? defaultCallFailureCode\n  return {\n    ok: false,\n    error: {\n      code,\n      message: result.message ?? \"The flow call failed\",\n      hint: callFailureHint[code]\n    }\n  }\n}\n\nconst fenced = /^```(?<info>[^\\n`]*)\\r?\\n(?<body>[\\s\\S]*?)(?:\\n?(?<close>^```[ \\t]*(?=\\r?$))|(?![\\s\\S]))/gm\n\nconst languageOf = (info: string): Language | undefined => {\n  const tokens = new Set(info.trim().toLowerCase().split(/\\s+/).filter((token) => token.length > 0))\n  if (tokens.has(\"ts\") || tokens.has(\"typescript\")) return \"typescript\"\n  if (tokens.has(\"cell\") || tokens.has(\"js\") || tokens.has(\"javascript\")) return \"javascript\"\n  return undefined\n}\n\n/**\n * One reply's cell program, and how many fenced blocks it was written in.\n *\n * `blocks` is journaled rather than derived later because it is the only\n * record of how the model chose to lay its frame out, and a reply written as\n * several blocks is exactly the reply the old extraction discarded.\n *\n * @category models\n * @since 0.1.0\n * @slop\n */\nexport interface Extracted {\n  readonly source: Source\n  /** How many fenced cell blocks the reply carried, repeats included. */\n  readonly blocks: number\n}\n\n/**\n * Extracts the cell program one model settlement emitted.\n *\n * Every fenced block tagged as a cell is kept, in reply order, and the blocks\n * are joined with newlines into one global async script in the persistent\n * realm. Top-level `await` is supported; top-level `return` is invalid. Blocks\n * execute in order. The first `ctx.done` or `ctx.park` that records an intent\n * seals the frame; later `ctx.done` and `ctx.park` calls do nothing. Ordinary\n * JavaScript in later blocks continues running, but later `ctx.call` and\n * `ctx.checkpoint` calls resolve with a `run_completed` failure envelope\n * without dispatching host work.\n *\n * Keeping only the *last* block is what this replaces, and the cost of that\n * rule was measured: on one graded instance the model wrote a near-par program\n * as seven blocks in a single reply \u2014 recon, probe, edit-plus-diagnostics,\n * suite, rehydrate, guarded replay, completion \u2014 and the harness executed block\n * seven, the imagined completion, against a tree where blocks one through six\n * had never run. Empty patch, run over in two frames. Multi-block replies were\n * 2 of 91 replies in that wave: rare, and instance-deciding when they land.\n *\n * A byte-identical repeat of a block is dropped rather than concatenated. Both\n * multi-block replies in that wave are in the journals, and the second one is a\n * model that emitted the same block twice: joining the duplicate would declare\n * its names twice and turn a frame that runs today into a `compile_failed`. A\n * repeat is the model restating one program, never a second step \u2014 a second\n * step that genuinely re-runs the same code would still have to differ\n * somewhere, if only in what it does with the result.\n *\n * Distinct blocks are joined as they were written, so a value bound in one is\n * bound for the ones after it. One program therefore means one set of\n * declarations, and two blocks that both declare the same name are a\n * `SyntaxError` the compiler reports \u2014 a durable observation the next frame can\n * fix, unlike silently running one block of seven, which is not observable at\n * all. The contract states the rule so a model that batches writes blocks that\n * compose, and `CellTurn` names the block count when such a program fails to\n * compile.\n *\n * The program is `typescript` when any block declared a typed fence, because\n * both bindings run TypeScript by erasing type-only syntax and erasure is\n * harmless to a plain-JavaScript block.\n *\n * Extraction reads text and never judges syntax. Whether the source uses module\n * syntax is a question about JavaScript, and it is answered by parsing the cell\n * in `Sandbox.compile`, which is also where an `imports_forbidden` rejection is\n * raised.\n *\n * @category conversions\n * @since 0.1.0\n * @slop\n */\nexport const extract = (text: string): Result.Result<Extracted, Rejected> => {\n  const bodies: Array<string> = []\n  const distinct = new Set<string>()\n  let typed = false\n  fenced.lastIndex = 0\n  for (const match of text.matchAll(fenced)) {\n    /* v8 ignore next -- `info` is a mandatory group of `fenced`, outside any alternation or quantifier, so it participates in every match; the default only discharges the optional type TypeScript gives `RegExpMatchArray.groups` */\n    const candidate = languageOf(match.groups?.info ?? \"\")\n    if (candidate === undefined) continue\n    if (match.groups?.close === undefined) {\n      return Result.fail(\n        new Rejected({\n          code: \"output_truncated\",\n          message:\n            \"The response contains an unterminated cell fence. No blocks ran. Emit the complete program with every fence closed.\"\n        })\n      )\n    }\n    if (candidate === \"typescript\") typed = true\n    /* v8 ignore next -- `body` is likewise mandatory in `fenced`; a match that reached here already produced `info`, so `groups` is present and carries both */\n    const body = match.groups?.body ?? \"\"\n    bodies.push(body)\n    distinct.add(body)\n  }\n  if (bodies.length === 0) {\n    return Result.fail(\n      new Rejected({\n        code: \"no_cell\",\n        message:\n          \"No cell was found in the response. Emit a fenced ```cell block containing the JavaScript for this transition.\"\n      })\n    )\n  }\n  return Result.succeed({\n    source: source([...distinct].join(\"\\n\"), typed ? \"typescript\" : \"javascript\"),\n    blocks: bodies.length\n  })\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/CellCalls.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Registry-backed resolution for the flow calls a cell makes.
+ *
+ * A cell's only authority is `ctx.call(flow, input)`, so every effect an agent
+ * can reach is a registered flow. This module is where a call name becomes a
+ * flow: it resolves the name against `@smthrs/registry` — the same registry
+ * that discovered `flow.ts`, `flow.mdx`, and `SKILL.md` under the documented
+ * precedence — and dispatches to the body the descriptor declares.
+ *
+ * It is deliberately not a second registry. Discovery, precedence, first-found
+ * collision handling, and progressive disclosure all stay in
+ * `@smthrs/registry`; this module only decides which body runs and turns
+ * every resolution problem into a {@link Cell.CallResult} the cell can inspect.
+ *
+ * The split between a failed result and a failed effect is the contract
+ * `EngineLike.call` declares. A refusal the agent could plausibly correct — an
+ * unknown flow, a badly shaped input, a flow this host does not implement — is
+ * a `failure` result, so the cell observes a resolved `{ ok: false, error }`
+ * envelope and may recover by branching on `.ok === false` and `.error.code`.
+ * Ordinary call failures do not throw. Anything the cell must never swallow,
+ * such as a permission park or an abort, stays in the error channel of the
+ * implementation that raised it.
+ *
+ * The resolver's shape is exactly `FlowEngineLike.CallRunner["run"]`, so a
+ * durable host wires it in without this browser-safe package depending on the
+ * engine binding.
+ *
+ * Governing design: `../docs/concepts.md#durable-cell-loop` and
+ * `../docs/concepts.md#flow-registry`.
+ *
+ * @since 0.1.0
+ */
+import type * as Registry from "@smthrs/registry/Registry";
+import { Effect } from "effect";
+import * as Cell from "./Cell.ts";
+import type * as FlowBinding from "./FlowBinding.ts";
+import { HarnessError } from "./HarnessError.ts";
+/**
+ * One module-backed flow, implemented by the host that discovered it.
+ *
+ * Discovery reads a module's metadata without evaluating it, so a descriptor
+ * never carries a callable body. The host binds the implementation it loaded
+ * for the flow, which keeps module evaluation out of both discovery and this
+ * package.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type Implementation = (call: Cell.Call) => Effect.Effect<Cell.CallResult, HarnessError>;
+/**
+ * One discovered markdown flow, rendered against the call's arguments.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Prompt {
+    readonly call: Cell.Call;
+    readonly text: string;
+}
+/**
+ * Runs a rendered markdown flow.
+ *
+ * A markdown flow is a prompt, so running one is a nested agent run rather than
+ * a function call. The host supplies that runner; this module only resolves and
+ * renders. A runner whose child declares the `auto` model routes that child
+ * through `SeatRouter.durable` from `@smthrs/agent`, keyed by the child run.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export type PromptRunner = (prompt: Prompt) => Effect.Effect<Cell.CallResult, HarnessError>;
+/**
+ * The collaborators registry-backed resolution needs.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Options {
+    readonly registry: Registry.Registry;
+    /**
+     * The composed executable bindings this host resolved.
+     *
+     * Standard capabilities, plugin-contributed flows, incoming MCP tools, and
+     * durable children all arrive here, and all of them resolve through the one
+     * snapshot the registry disclosed.
+     */
+    readonly catalog?: FlowBinding.Catalog | undefined;
+    /** Host implementations for module-backed flows, keyed by flow name. */
+    readonly implementations?: ReadonlyMap<string, Implementation> | undefined;
+    /** Runs a rendered markdown flow. A host with none answers with a resolved failure envelope. */
+    readonly prompt?: PromptRunner | undefined;
+}
+/**
+ * Resolves one cell call to the registered flow that answers it.
+ *
+ * @category models
+ * @since 0.1.0
+ * @slop
+ */
+export interface Resolver {
+    readonly run: (call: Cell.Call) => Effect.Effect<Cell.CallResult, HarnessError>;
+}
+/**
+ * Constructs registry-backed call resolution.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export declare const make: (options: Options) => Resolver;
+//# sourceMappingURL=CellCalls.d.ts.map