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

package/dist/cjs/internal/unfinishedWork.js

@@ -0,0 +1,80 @@
+"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 unfinishedWork_exports = {};
+__export(unfinishedWork_exports, {
+  classifier: () => classifier,
+  incomplete: () => incomplete,
+  read: () => read,
+  reportedAt: () => reportedAt
+});
+module.exports = __toCommonJS(unfinishedWork_exports);
+var Classifier = __toESM(require("@smthrs/model/Classifier"), 1);
+var Evaluator = __toESM(require("@smthrs/model/Evaluator"), 1);
+var import_effect = require("effect");
+var CompletionClaim = __toESM(require("../CompletionClaim.js"), 1);
+var import_HarnessError = require("../HarnessError.js");
+var Judgement = __toESM(require("../Judgement.js"), 1);
+var import_paidUsage = require("./paidUsage.js");
+const classifier = Classifier.make("completion/unfinished", {
+  description: "Judge whether one agent's completion message itself reports that the work it was asked to do is unfinished.",
+  state: CompletionClaim.Evidence,
+  questions: {
+    unfinished: Classifier.boolean({
+      instructions: "Does the completion explicitly report that the requested work is unfinished, failed, or blocked? Judge what the completion says about its own outcome, not whether the task is actually done.",
+      criteria: {
+        true: "the completion plainly says it could not finish, could not fix, or was stopped from doing the requested work, instead of reporting success",
+        false: "the completion reports success, supplies the requested answer, or only notes that something it did was not verified"
+      }
+    })
+  }
+});
+const reportedAt = 0.9;
+const read = (evidence, earlier) => Judgement.measured(classifier, evidence).pipe(
+  import_effect.Effect.map(({ answers, asked }) => ({
+    unfinished: answers.unfinished.probability,
+    latencyMs: asked.latencyMs,
+    ...asked.usage === void 0 ? {} : { usage: asked.usage },
+    asked
+  })),
+  import_effect.Effect.mapError(
+    (error) => CompletionClaim.unjudged(
+      error.code,
+      Evaluator.publicMessage(error),
+      evidence.claim,
+      (0, import_paidUsage.failedReading)(error, earlier)
+    )
+  )
+);
+const incomplete = (complete, unfinished, claim) => new import_HarnessError.HarnessError({
+  code: "completion_incomplete",
+  message: `A completion reporting its own work unfinished: unfinished ${unfinished.toFixed(2)} (complete ${complete.toFixed(2)}). The run's report, word for word:
+
+${CompletionClaim.refused(claim)}`
+});
+//# sourceMappingURL=unfinishedWork.js.map

package/dist/cjs/internal/unfinishedWork.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/unfinishedWork.ts"],
+  "sourcesContent": ["/**\n * The completion that says, in its own words, that the work is not done.\n *\n * The claim brake's `complete` question may only ask for another frame: its\n * corpus found honest answers and honest reports of unfinished work reading\n * equally low, so a low reading alone is no verdict. What that left open is\n * the run that has no bounce left and still writes \"I could not finish X\n * because Y\": nothing refused it, so it stood, and a host settled a run that\n * did nothing as a completed one (#3009).\n *\n * So the verdict is asked separately and only there. Where the claim brake\n * read the completion as not done and has no bounce left to spend, one more\n * question asks whether the completion itself reports the work unfinished.\n * A completion that does ends the run as `completion_incomplete`, a typed\n * failure that quotes the run's own report, instead of standing. The question\n * is about the sentence, not the task: an answer, a delivered edit, or a note\n * that something went unverified is not a report of unfinished work, and\n * never reaches this question unless the claim brake had already read it as\n * not done.\n *\n * @since 1.0.0-rc.1\n * @private\n */\n\nimport * as Classifier from \"@smthrs/model/Classifier\"\nimport * as Evaluator from \"@smthrs/model/Evaluator\"\nimport { Effect } from \"effect\"\nimport * as CompletionClaim from \"../CompletionClaim.ts\"\nimport { HarnessError } from \"../HarnessError.ts\"\nimport * as Judgement from \"../Judgement.ts\"\nimport { failedReading } from \"./paidUsage.ts\"\n\n/**\n * The one question, asked of the evidence the claim brake already sent.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const classifier = Classifier.make(\"completion/unfinished\", {\n  description:\n    \"Judge whether one agent's completion message itself reports that the work it was asked to do is unfinished.\",\n  state: CompletionClaim.Evidence,\n  questions: {\n    unfinished: Classifier.boolean({\n      instructions:\n        \"Does the completion explicitly report that the requested work is unfinished, failed, or blocked? Judge what the completion says about its own outcome, not whether the task is actually done.\",\n      criteria: {\n        true:\n          \"the completion plainly says it could not finish, could not fix, or was stopped from doing the requested work, instead of reporting success\",\n        false:\n          \"the completion reports success, supplies the requested answer, or only notes that something it did was not verified\"\n      }\n    })\n  }\n})\n\n/**\n * At or above this probability of \"unfinished\", the completion ends the run\n * as a failure rather than standing.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const reportedAt = 0.9\n\n/**\n * One reading of {@link classifier}, and what asking it cost.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport interface Reading {\n  readonly unfinished: number\n  readonly latencyMs: number\n  readonly usage?: Evaluator.Usage | undefined\n  readonly asked: Judgement.Read<typeof classifier.questions>[\"asked\"]\n}\n\n/**\n * Asks the question over the claim brake's evidence. A reading that cannot\n * be had fails the turn as `completion_unjudged`, as the claim brake's own\n * does, and the cause carries what it paid with what the `earlier` readings\n * of the same completion paid, so a failed verdict does not lose their spend.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const read = (\n  evidence: CompletionClaim.Evidence,\n  earlier: Evaluator.Usage | undefined\n): Effect.Effect<Reading, HarnessError, Evaluator.Evaluator> =>\n  Judgement.measured(classifier, evidence).pipe(\n    Effect.map(({ answers, asked }): Reading => ({\n      unfinished: answers.unfinished.probability,\n      latencyMs: asked.latencyMs,\n      ...(asked.usage === undefined ? {} : { usage: asked.usage }),\n      asked\n    })),\n    Effect.mapError((error) =>\n      CompletionClaim.unjudged(\n        error.code,\n        Evaluator.publicMessage(error),\n        evidence.claim,\n        failedReading(error, earlier)\n      )\n    )\n  )\n\n/**\n * The failure a completion reporting its own work unfinished ends the run\n * with. It quotes the report, so the person keeps the run's explanation of\n * what is left, and carries both readings that decided it.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const incomplete = (complete: number, unfinished: number, claim: string): HarnessError =>\n  new HarnessError({\n    code: \"completion_incomplete\",\n    message: `A completion reporting its own work unfinished: unfinished ${unfinished.toFixed(2)} (complete ${\n      complete.toFixed(2)\n    }). The run's report, word for word:\\n\\n${CompletionClaim.refused(claim)}`\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBA,iBAA4B;AAC5B,gBAA2B;AAC3B,oBAAuB;AACvB,sBAAiC;AACjC,0BAA6B;AAC7B,gBAA2B;AAC3B,uBAA8B;AAQvB,MAAM,aAAa,WAAW,KAAK,yBAAyB;AAAA,EACjE,aACE;AAAA,EACF,OAAO,gBAAgB;AAAA,EACvB,WAAW;AAAA,IACT,YAAY,WAAW,QAAQ;AAAA,MAC7B,cACE;AAAA,MACF,UAAU;AAAA,QACR,MACE;AAAA,QACF,OACE;AAAA,MACJ;AAAA,IACF,CAAC;AAAA,EACH;AACF,CAAC;AASM,MAAM,aAAa;AAwBnB,MAAM,OAAO,CAClB,UACA,YAEA,UAAU,SAAS,YAAY,QAAQ,EAAE;AAAA,EACvC,qBAAO,IAAI,CAAC,EAAE,SAAS,MAAM,OAAgB;AAAA,IAC3C,YAAY,QAAQ,WAAW;AAAA,IAC/B,WAAW,MAAM;AAAA,IACjB,GAAI,MAAM,UAAU,SAAY,CAAC,IAAI,EAAE,OAAO,MAAM,MAAM;AAAA,IAC1D;AAAA,EACF,EAAE;AAAA,EACF,qBAAO;AAAA,IAAS,CAAC,UACf,gBAAgB;AAAA,MACd,MAAM;AAAA,MACN,UAAU,cAAc,KAAK;AAAA,MAC7B,SAAS;AAAA,UACT,gCAAc,OAAO,OAAO;AAAA,IAC9B;AAAA,EACF;AACF;AAUK,MAAM,aAAa,CAAC,UAAkB,YAAoB,UAC/D,IAAI,iCAAa;AAAA,EACf,MAAM;AAAA,EACN,SAAS,8DAA8D,WAAW,QAAQ,CAAC,CAAC,cAC1F,SAAS,QAAQ,CAAC,CACpB;AAAA;AAAA,EAA0C,gBAAgB,QAAQ,KAAK,CAAC;AAC1E,CAAC;",
+  "names": []
+}

package/dist/cjs/internal/unobservedCall.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The completion its own cell wrote before reading the calls it made.
+ *
+ * Several `cell` blocks in one reply run as one program, and the model writes
+ * the whole program before any call in it settles. A reply that probes and
+ * answers — `const seen = await ctx.call("bash", …)`, a `console.log` of `seen`,
+ * then `ctx.done(…)` — therefore completes the run before the model has read
+ * a byte of what it asked to see. Real seats do this about once in three
+ * deliveries even when their prompt says to answer in a later reply, and the
+ * answer is either an unverified claim or "blocked: output not observed".
+ *
+ * ## The rule, and what it spares
+ *
+ * A completion is handed back, once per run, when its own cell made a call,
+ * kept that call's result, and left it for the model alone: printed or
+ * bound, and read by nothing in the program but `console.*` and guards that
+ * only decide what `console.*` prints (`if (r.exitCode)` around a `console.log` of `r.stderr`),
+ * so the completion reads no result either. It is also handed back when the
+ * program acted on some results but a completion that reads none — in its
+ * output or a guard around it — follows a result the program only printed.
+ * The next frame is shown the results and asked to answer after reading them.
+ *
+ * Three shapes are spared because nothing in them was written blind:
+ *
+ * - a completion that reads a call's result — in its output, or in a guard
+ *   around it. `if (after.exitCode === 0) ctx.done(…)` is the shape the cell
+ *   contract teaches: the program, not the model's memory, decides the
+ *   verdict. Reading is transitive through the program's own bindings, so
+ *   `result.summary = seen.stdout; ctx.done(JSON.stringify(result))` reads.
+ * - a cell whose program acts on a result: passes it into another call, or
+ *   branches on it. The contract teaches deriving later inputs from earlier
+ *   results inside one cell, and a cell that asked, saved the answer and
+ *   completed did what it set out to do without the model reading anything.
+ * - a cell whose calls are all effects whose result it discarded, such as
+ *   `await ctx.call("edit", …)` as a statement of its own. The cell never
+ *   asked to see anything, and a failed effect is `FailedCall`'s demand.
+ *
+ * The reading is a parse of the cell's source, so it is a pure function of
+ * the cell and a replay reaches the same decision. It reads names, not
+ * scopes, and what it cannot see through — a result handed to a function of
+ * the program's own, a `.then` callback, a completion reached through an
+ * alias — reads as acted on. A wrong refusal takes a legitimate answer away
+ * from every consumer of the harness, while a wrong pass costs one unread
+ * probe, so the rule fires only where the source leaves no other reading.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+/**
+ * How many completions one run may have handed back for unread calls.
+ *
+ * One, like every measured demand: the frame that answers it has read the
+ * results, and asking again would be the loop grading that answer.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const cap = 1;
+/**
+ * The heading of the demand, so a transcript and a test can find it.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const heading = "Answer written before its calls returned";
+/** The frame accounting's view of one settled call. */
+interface Settled {
+    readonly flow: string;
+    readonly ok: boolean;
+    readonly ordinal: number;
+    readonly summary: string;
+}
+/**
+ * One call a completion was written without reading.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export interface Unobserved {
+    readonly flow: string;
+    readonly ok: boolean;
+    readonly ordinal: number;
+    readonly summary: string;
+}
+/**
+ * Whether a completing cell's source wrote its completion blind: it kept a
+ * call's result for the model alone and completed from code that reads none.
+ * A source that does not parse is never read as blind, because nothing here
+ * can say what it did.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const blind: (source: string) => boolean;
+/**
+ * The calls a completion was written without reading, oldest first: every
+ * call its own frame settled, when the cell wrote the completion blind.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const find: (calls: ReadonlyArray<Settled>, source: string) => ReadonlyArray<Unobserved>;
+/**
+ * The demand a blind completion is handed back with: the results it never
+ * read, then the correction.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const demand: (calls: ReadonlyArray<Unobserved>) => string;
+export {};
+//# sourceMappingURL=unobservedCall.d.ts.map

package/dist/cjs/internal/unobservedCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unobservedCall.d.ts","sourceRoot":"","sources":["../../../src/internal/unobservedCall.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAKH;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG,IAAI,CAAA;AAEpB;;;;;GAKG;AACH,eAAO,MAAM,OAAO,6CAA6C,CAAA;AAEjE,uDAAuD;AACvD,UAAU,OAAO;IACf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAuYD;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK,GAAI,QAAQ,MAAM,KAAG,OAoBtC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,aAAa,CAAC,OAAO,CAAC,EAAE,QAAQ,MAAM,KAAG,aAAa,CAAC,UAAU,CAGc,CAAA;AAE3G;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,aAAa,CAAC,UAAU,CAAC,KAAG,MAIK,CAAA"}

package/dist/cjs/internal/unobservedCall.js

@@ -0,0 +1,345 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unobservedCall_exports = {};
+__export(unobservedCall_exports, {
+  blind: () => blind,
+  cap: () => cap,
+  demand: () => demand,
+  find: () => find,
+  heading: () => heading
+});
+module.exports = __toCommonJS(unobservedCall_exports);
+var import_parser = require("@babel/parser");
+const cap = 1;
+const heading = "Answer written before its calls returned";
+const isNode = (value) => value !== null && typeof value === "object" && typeof value.type === "string";
+const skipped = /* @__PURE__ */ new Set(["loc", "start", "end", "extra", "leadingComments", "trailingComments", "innerComments"]);
+const children = (node) => {
+  const found = [];
+  for (const [key, value] of Object.entries(node)) {
+    if (skipped.has(key)) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) if (isNode(item)) found.push(item);
+    }
+    if (isNode(value)) found.push(value);
+  }
+  return found;
+};
+const ctxMember = (node, name) => (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && !node.computed && node.object.type === "Identifier" && node.object.name === "ctx" && node.property.type === "Identifier" && node.property.name === name;
+const ctxCall = (node, name) => (node.type === "CallExpression" || node.type === "OptionalCallExpression") && ctxMember(node.callee, name);
+const referencing = (node) => {
+  switch (node.type) {
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return node.computed ? [node.object, node.property] : [node.object];
+    case "ObjectProperty":
+      return node.computed ? [node.key, node.value] : [node.value];
+    case "ObjectMethod":
+    case "ClassMethod":
+    case "ClassPrivateMethod":
+      return [...node.params, node.body];
+    default:
+      return children(node);
+  }
+};
+const reads = (node, results) => {
+  if (ctxCall(node, "call")) return true;
+  if (node.type === "Identifier") return results.has(node.name);
+  return referencing(node).some((child) => reads(child, results));
+};
+const targets = (node) => {
+  switch (node.type) {
+    case "Identifier":
+      return [node.name];
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return targets(node.object);
+    case "ObjectPattern":
+      return node.properties.flatMap((property) => targets(property.type === "RestElement" ? property : property.value));
+    case "ArrayPattern":
+      return node.elements.flatMap((element) => element === null ? [] : targets(element));
+    case "RestElement":
+      return targets(node.argument);
+    case "AssignmentPattern":
+      return targets(node.left);
+    default:
+      return [];
+  }
+};
+const realm = /* @__PURE__ */ new Set(["ctx", "console"]);
+const flows = (root) => {
+  const found = [];
+  const visit = (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        if (node.init !== null && node.init !== void 0) found.push([targets(node.id), node.init]);
+        break;
+      case "AssignmentExpression":
+        found.push([targets(node.left), node.right]);
+        break;
+      case "FunctionDeclaration":
+        found.push([[node.id.name], node.body]);
+        break;
+      case "ForOfStatement":
+      case "ForInStatement":
+        found.push([
+          targets(node.left.type === "VariableDeclaration" ? node.left.declarations[0].id : node.left),
+          node.right
+        ]);
+        break;
+      case "CallExpression":
+      case "OptionalCallExpression":
+        if (node.callee.type === "MemberExpression" || node.callee.type === "OptionalMemberExpression") {
+          for (const argument of node.arguments) found.push([targets(node.callee.object), argument]);
+        }
+        break;
+    }
+    for (const child of children(node)) visit(child);
+  };
+  visit(root);
+  return found.map(([names, source]) => [names.filter((name) => !realm.has(name)), source]);
+};
+const resultNames = (root) => {
+  const moves = flows(root);
+  const results = /* @__PURE__ */ new Set();
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const [names, source] of moves) {
+      if (names.every((name) => results.has(name)) || !reads(source, results)) continue;
+      for (const name of names) results.add(name);
+      grew = true;
+    }
+  }
+  return results;
+};
+const mentions = (node, names) => node.type === "Identifier" ? names.has(node.name) : referencing(node).some((child) => mentions(child, names));
+const resultsByCall = (root) => {
+  const moves = flows(root);
+  return moves.filter(([, source]) => reads(source, /* @__PURE__ */ new Set())).flatMap(
+    ([names]) => names.map((name) => {
+      const held = /* @__PURE__ */ new Set([name]);
+      for (let grew = true; grew; ) {
+        grew = false;
+        for (const [targets2, source] of moves) {
+          if (targets2.every((target) => held.has(target)) || !mentions(source, held)) continue;
+          for (const target of targets2) held.add(target);
+          grew = true;
+        }
+      }
+      return held;
+    })
+  );
+};
+const completionReads = (root, results) => {
+  const visit = (node, guarded) => {
+    if (ctxCall(node, "done")) {
+      return guarded || node.arguments.some((argument) => reads(argument, results));
+    }
+    const parts = functionParts(node);
+    if (parts !== void 0) return parts.some((child) => visit(child, true));
+    let tests = [];
+    switch (node.type) {
+      case "IfStatement":
+      case "ConditionalExpression":
+      case "WhileStatement":
+      case "DoWhileStatement":
+        tests = [node.test];
+        break;
+      case "LogicalExpression":
+        tests = [node.left];
+        break;
+      case "SwitchStatement":
+        tests = [node.discriminant, ...node.cases.map((entry) => entry.test)];
+        break;
+      case "ForOfStatement":
+      case "ForInStatement":
+        tests = [node.right];
+        break;
+      case "CatchClause":
+        return visit(node.body, true);
+    }
+    const inner = guarded || tests.some((test) => test != null && reads(test, results));
+    return children(node).some((child) => visit(child, inner));
+  };
+  return visit(root, false);
+};
+const pure = /* @__PURE__ */ new Map([
+  ["Promise", /* @__PURE__ */ new Set(["all", "allSettled", "any", "race", "resolve"])],
+  ["JSON", /* @__PURE__ */ new Set(["parse", "stringify"])],
+  ["Object", /* @__PURE__ */ new Set(["assign", "entries", "fromEntries", "keys", "values"])],
+  ["Array", /* @__PURE__ */ new Set(["from", "of"])]
+]);
+const pureFunctions = /* @__PURE__ */ new Set(["String", "Number", "Boolean"]);
+const keeping = /* @__PURE__ */ new Set(["push", "unshift", "add", "set", "append"]);
+const functionParts = (node) => {
+  switch (node.type) {
+    case "FunctionExpression":
+    case "ArrowFunctionExpression":
+    case "FunctionDeclaration":
+    case "ObjectMethod":
+    case "ClassMethod":
+    case "ClassPrivateMethod":
+      return [...node.params, node.body];
+    default:
+      return void 0;
+  }
+};
+const functionLike = (node) => functionParts(node) !== void 0;
+const consoleCall = (node) => {
+  if (node.type !== "CallExpression" && node.type !== "OptionalCallExpression") return false;
+  const member = memberName(node.callee);
+  return member !== void 0 && member[0].type === "Identifier" && member[0].name === "console" && !node.arguments.some(functionLike);
+};
+const logging = (node) => consoleCall(node) || node.type === "NullLiteral" || node.type === "Identifier" && node.name === "undefined" || node.type === "UnaryExpression" && node.operator === "void" && node.argument.type === "NumericLiteral" || node.type === "ConditionalExpression" && logging(node.consequent) && logging(node.alternate) || node.type === "LogicalExpression" && logging(node.right);
+const loggingOnly = (node) => {
+  if (node === null || node === void 0) return true;
+  switch (node.type) {
+    case "EmptyStatement":
+      return true;
+    case "BlockStatement":
+      return node.body.every(loggingOnly);
+    case "ExpressionStatement":
+      return logging(node.expression);
+    case "IfStatement":
+      return loggingOnly(node.consequent) && loggingOnly(node.alternate);
+    case "SwitchStatement":
+      return node.cases.every(
+        (entry) => entry.consequent.every(
+          (statement) => statement.type === "BreakStatement" && statement.label === null || loggingOnly(statement)
+        )
+      );
+    default:
+      return false;
+  }
+};
+const memberName = (callee) => (callee.type === "MemberExpression" || callee.type === "OptionalMemberExpression") && !callee.computed && callee.property.type === "Identifier" ? [callee.object, callee.property.name] : void 0;
+const actsOn = (root, results, calls = true) => {
+  const reading = (node) => calls ? reads(node, results) : mentions(node, results);
+  const visit = (node, acting) => {
+    if (node.type === "Identifier") return acting && results.has(node.name);
+    const parts = functionParts(node);
+    if (parts !== void 0) return parts.some((child) => visit(child, true));
+    if (node.type === "ExpressionStatement" || node.type === "UnaryExpression" && node.operator === "void") {
+      const discarded = node.type === "ExpressionStatement" ? node.expression : node.argument;
+      const inner = discarded.type === "AwaitExpression" ? discarded.argument : discarded;
+      if (ctxCall(inner, "call")) {
+        return inner.arguments.some((argument) => visit(argument, true));
+      }
+    }
+    if (node.type === "CallExpression" || node.type === "OptionalCallExpression" || node.type === "NewExpression") {
+      const callee = node.callee;
+      const member = memberName(callee);
+      if (member !== void 0 && member[0].type === "Identifier" && member[0].name === "console") return false;
+      if (ctxCall(node, "call")) {
+        return calls && acting || node.arguments.some((argument) => visit(argument, true));
+      }
+      if (ctxCall(node, "done")) return node.arguments.some((argument) => visit(argument, true));
+      const readsCallee = reading(callee);
+      if (callee.type === "Identifier" && pureFunctions.has(callee.name) || member !== void 0 && member[0].type === "Identifier" && pure.get(member[0].name)?.has(member[1]) === true) return node.arguments.some((argument) => visit(argument, acting));
+      if (member !== void 0 && keeping.has(member[1])) {
+        return node.arguments.some((argument) => visit(argument, false));
+      }
+      if (member !== void 0 && readsCallee && !node.arguments.some(functionLike)) {
+        return visit(callee, acting) || node.arguments.some((argument) => visit(argument, acting));
+      }
+      return readsCallee || node.arguments.some((argument) => reading(argument));
+    }
+    if (node.type === "IfStatement" && loggingOnly(node)) {
+      return quietly(node.test) || visit(node.consequent, false) || node.alternate != null && visit(node.alternate, false);
+    }
+    if (node.type === "SwitchStatement" && loggingOnly(node)) {
+      return quietly(node.discriminant) || node.cases.some(
+        (entry) => entry.test != null && quietly(entry.test) || entry.consequent.some((statement) => visit(statement, false))
+      );
+    }
+    if (node.type === "ExpressionStatement" && loggingOnly(node)) return quietly(node.expression);
+    switch (node.type) {
+      case "VariableDeclarator":
+        return node.init != null && visit(node.init, false);
+      case "AssignmentExpression":
+        return visit(node.left, false) || visit(node.right, false);
+      case "ForOfStatement":
+      case "ForInStatement":
+        return visit(node.right, false) || visit(node.body, acting);
+      case "IfStatement":
+      case "ConditionalExpression":
+      case "WhileStatement":
+      case "DoWhileStatement":
+        if (visit(node.test, true)) return true;
+        break;
+      case "LogicalExpression":
+        if (visit(node.left, true)) return true;
+        break;
+      case "SwitchStatement":
+        if (visit(node.discriminant, true)) return true;
+        break;
+      case "SwitchCase":
+        if (node.test != null && visit(node.test, true)) return true;
+        break;
+    }
+    return referencing(node).some((child) => visit(child, acting));
+  };
+  const quietly = (node) => {
+    if (node.type === "ConditionalExpression") {
+      return quietly(node.test) || quietly(node.consequent) || quietly(node.alternate);
+    }
+    if (node.type === "LogicalExpression") return quietly(node.left) || quietly(node.right);
+    return visit(node, false);
+  };
+  return visit(root, true);
+};
+const keepsResult = (root) => {
+  const calls = [];
+  const discarded = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (ctxCall(node, "call")) calls.push(node);
+    if (node.type === "ExpressionStatement" || node.type === "UnaryExpression" && node.operator === "void") {
+      const inner = node.type === "ExpressionStatement" ? node.expression : node.argument;
+      discarded.add(inner.type === "AwaitExpression" ? inner.argument : inner);
+    }
+    for (const child of children(node)) visit(child);
+  };
+  visit(root);
+  return calls.some((call) => !discarded.has(call));
+};
+const blind = (source) => {
+  let program;
+  try {
+    program = (0, import_parser.parse)(source, {
+      sourceType: "script",
+      plugins: ["typescript"],
+      allowAwaitOutsideFunction: true,
+      allowReturnOutsideFunction: true,
+      errorRecovery: true
+    });
+  } catch {
+    return false;
+  }
+  if (!keepsResult(program.program)) return false;
+  const results = resultNames(program.program);
+  if (!actsOn(program.program, results)) return true;
+  if (completionReads(program.program, results)) return false;
+  return resultsByCall(program.program).some((held) => !actsOn(program.program, held, false));
+};
+const find = (calls, source) => calls.length === 0 || !blind(source) ? [] : calls.map((call) => ({ flow: call.flow, ok: call.ok, ordinal: call.ordinal, summary: call.summary }));
+const demand = (calls) => `${heading}:
+${calls.map((call) => `- ${call.ordinal}. ${call.flow} -> ${call.ok ? "ok" : "FAILED"}: ${call.summary}`).join("\n")}
+
+Answer after reading the calls' output, in a reply of its own.`;
+//# sourceMappingURL=unobservedCall.js.map

package/dist/cjs/internal/unobservedCall.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/unobservedCall.ts"],
+  "sourcesContent": ["/**\n * The completion its own cell wrote before reading the calls it made.\n *\n * Several `cell` blocks in one reply run as one program, and the model writes\n * the whole program before any call in it settles. A reply that probes and\n * answers \u2014 `const seen = await ctx.call(\"bash\", \u2026)`, a `console.log` of `seen`,\n * then `ctx.done(\u2026)` \u2014 therefore completes the run before the model has read\n * a byte of what it asked to see. Real seats do this about once in three\n * deliveries even when their prompt says to answer in a later reply, and the\n * answer is either an unverified claim or \"blocked: output not observed\".\n *\n * ## The rule, and what it spares\n *\n * A completion is handed back, once per run, when its own cell made a call,\n * kept that call's result, and left it for the model alone: printed or\n * bound, and read by nothing in the program but `console.*` and guards that\n * only decide what `console.*` prints (`if (r.exitCode)` around a `console.log` of `r.stderr`),\n * so the completion reads no result either. It is also handed back when the\n * program acted on some results but a completion that reads none \u2014 in its\n * output or a guard around it \u2014 follows a result the program only printed.\n * The next frame is shown the results and asked to answer after reading them.\n *\n * Three shapes are spared because nothing in them was written blind:\n *\n * - a completion that reads a call's result \u2014 in its output, or in a guard\n *   around it. `if (after.exitCode === 0) ctx.done(\u2026)` is the shape the cell\n *   contract teaches: the program, not the model's memory, decides the\n *   verdict. Reading is transitive through the program's own bindings, so\n *   `result.summary = seen.stdout; ctx.done(JSON.stringify(result))` reads.\n * - a cell whose program acts on a result: passes it into another call, or\n *   branches on it. The contract teaches deriving later inputs from earlier\n *   results inside one cell, and a cell that asked, saved the answer and\n *   completed did what it set out to do without the model reading anything.\n * - a cell whose calls are all effects whose result it discarded, such as\n *   `await ctx.call(\"edit\", \u2026)` as a statement of its own. The cell never\n *   asked to see anything, and a failed effect is `FailedCall`'s demand.\n *\n * The reading is a parse of the cell's source, so it is a pure function of\n * the cell and a replay reaches the same decision. It reads names, not\n * scopes, and what it cannot see through \u2014 a result handed to a function of\n * the program's own, a `.then` callback, a completion reached through an\n * alias \u2014 reads as acted on. A wrong refusal takes a legitimate answer away\n * from every consumer of the harness, while a wrong pass costs one unread\n * probe, so the rule fires only where the source leaves no other reading.\n *\n * @since 1.0.0-rc.1\n * @private\n */\n\nimport { parse } from \"@babel/parser\"\nimport type * as Syntax from \"@babel/types\"\n\n/**\n * How many completions one run may have handed back for unread calls.\n *\n * One, like every measured demand: the frame that answers it has read the\n * results, and asking again would be the loop grading that answer.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const cap = 1\n\n/**\n * The heading of the demand, so a transcript and a test can find it.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const heading = \"Answer written before its calls returned\"\n\n/** The frame accounting's view of one settled call. */\ninterface Settled {\n  readonly flow: string\n  readonly ok: boolean\n  readonly ordinal: number\n  readonly summary: string\n}\n\n/**\n * One call a completion was written without reading.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport interface Unobserved {\n  readonly flow: string\n  readonly ok: boolean\n  readonly ordinal: number\n  readonly summary: string\n}\n\ntype Node = Syntax.Node\n\nconst isNode = (value: unknown): value is Node =>\n  value !== null && typeof value === \"object\" && typeof (value as { type?: unknown }).type === \"string\"\n\n/** Keys that hold positions, comments and parser detail rather than children. */\nconst skipped = new Set([\"loc\", \"start\", \"end\", \"extra\", \"leadingComments\", \"trailingComments\", \"innerComments\"])\n\nconst children = (node: Node): ReadonlyArray<Node> => {\n  const found: Array<Node> = []\n  for (const [key, value] of Object.entries(node)) {\n    if (skipped.has(key)) continue\n    if (Array.isArray(value)) { for (const item of value) if (isNode(item)) found.push(item) }\n    if (isNode(value)) found.push(value)\n  }\n  return found\n}\n\nconst ctxMember = (node: Node, name: string): boolean =>\n  (node.type === \"MemberExpression\" || node.type === \"OptionalMemberExpression\") && !node.computed &&\n  node.object.type === \"Identifier\" && node.object.name === \"ctx\" &&\n  node.property.type === \"Identifier\" && node.property.name === name\n\nconst ctxCall = (node: Node, name: string): boolean =>\n  (node.type === \"CallExpression\" || node.type === \"OptionalCallExpression\") && ctxMember(node.callee, name)\n\n/**\n * The nodes a reference can hide in: a non-computed property or key names\n * nothing, so `x.seen` does not read `seen`.\n */\nconst referencing = (node: Node): ReadonlyArray<Node> => {\n  switch (node.type) {\n    case \"MemberExpression\":\n    case \"OptionalMemberExpression\":\n      return node.computed ? [node.object, node.property] : [node.object]\n    case \"ObjectProperty\":\n      return node.computed ? [node.key, node.value] : [node.value]\n    case \"ObjectMethod\":\n    case \"ClassMethod\":\n    case \"ClassPrivateMethod\":\n      return [...node.params, node.body]\n    default:\n      return children(node)\n  }\n}\n\n/** Whether an expression makes a call or reads a name that holds a result. */\nconst reads = (node: Node, results: ReadonlySet<string>): boolean => {\n  if (ctxCall(node, \"call\")) return true\n  if (node.type === \"Identifier\") return results.has(node.name)\n  return referencing(node).some((child) => reads(child, results))\n}\n\n/** The names a binding or assignment target writes; a member target writes its root. */\nconst targets = (node: Node): ReadonlyArray<string> => {\n  switch (node.type) {\n    case \"Identifier\":\n      return [node.name]\n    case \"MemberExpression\":\n    case \"OptionalMemberExpression\":\n      return targets(node.object)\n    case \"ObjectPattern\":\n      return node.properties.flatMap((property) => targets(property.type === \"RestElement\" ? property : property.value))\n    case \"ArrayPattern\":\n      return node.elements.flatMap((element) => element === null ? [] : targets(element))\n    case \"RestElement\":\n      return targets(node.argument)\n    case \"AssignmentPattern\":\n      return targets(node.left)\n    default:\n      return []\n  }\n}\n\n/** The names `ctx` and `console` are the realm's, never a result's. */\nconst realm = new Set([\"ctx\", \"console\"])\n\n/** Every way the program moves a value into a name: `[targets, source]`. */\nconst flows = (root: Node): ReadonlyArray<readonly [ReadonlyArray<string>, Node]> => {\n  const found: Array<readonly [ReadonlyArray<string>, Node]> = []\n  const visit = (node: Node): void => {\n    switch (node.type) {\n      case \"VariableDeclarator\":\n        if (node.init !== null && node.init !== undefined) found.push([targets(node.id), node.init])\n        break\n      case \"AssignmentExpression\":\n        found.push([targets(node.left), node.right])\n        break\n      case \"FunctionDeclaration\":\n        // A script's function declaration always has a name; only a module's\n        // default export may omit it, and a cell is never a module.\n        found.push([[node.id!.name], node.body])\n        break\n      case \"ForOfStatement\":\n      case \"ForInStatement\":\n        found.push([\n          targets(node.left.type === \"VariableDeclaration\" ? node.left.declarations[0]!.id : node.left),\n          node.right\n        ])\n        break\n      case \"CallExpression\":\n      case \"OptionalCallExpression\":\n        // `results.push(seen)` keeps a result in `results`.\n        if (node.callee.type === \"MemberExpression\" || node.callee.type === \"OptionalMemberExpression\") {\n          for (const argument of node.arguments) found.push([targets(node.callee.object), argument])\n        }\n        break\n    }\n    for (const child of children(node)) visit(child)\n  }\n  visit(root)\n  return found.map(([names, source]) => [names.filter((name) => !realm.has(name)), source] as const)\n}\n\n/** Every name that holds, directly or through the program's own bindings, a call's result. */\nconst resultNames = (root: Node): ReadonlySet<string> => {\n  const moves = flows(root)\n  const results = new Set<string>()\n  for (let grew = true; grew;) {\n    grew = false\n    for (const [names, source] of moves) {\n      if (names.every((name) => results.has(name)) || !reads(source, results)) continue\n      for (const name of names) results.add(name)\n      grew = true\n    }\n  }\n  return results\n}\n\n/** Whether an expression reads a name in `names`, calls aside. */\nconst mentions = (node: Node, names: ReadonlySet<string>): boolean =>\n  node.type === \"Identifier\" ? names.has(node.name) : referencing(node).some((child) => mentions(child, names))\n\n/**\n * Each name a call's result is bound to directly, with every name the\n * program's own bindings copy it into.\n */\nconst resultsByCall = (root: Node): ReadonlyArray<ReadonlySet<string>> => {\n  const moves = flows(root)\n  return moves.filter(([, source]) => reads(source, new Set())).flatMap(([names]) =>\n    names.map((name) => {\n      const held = new Set([name])\n      for (let grew = true; grew;) {\n        grew = false\n        for (const [targets, source] of moves) {\n          if (targets.every((target) => held.has(target)) || !mentions(source, held)) continue\n          for (const target of targets) held.add(target)\n          grew = true\n        }\n      }\n      return held\n    })\n  )\n}\n\n/**\n * Whether a completion depends on a result: its output reads one, or a guard\n * around it (a condition, a loop over a result, a `catch`) does. A completion\n * inside a function of the program's own is out of sight and counts as\n * depending.\n */\nconst completionReads = (root: Node, results: ReadonlySet<string>): boolean => {\n  const visit = (node: Node, guarded: boolean): boolean => {\n    if (ctxCall(node, \"done\")) {\n      return guarded || (node as Syntax.CallExpression).arguments.some((argument) => reads(argument, results))\n    }\n    const parts = functionParts(node)\n    if (parts !== undefined) return parts.some((child) => visit(child, true))\n    let tests: ReadonlyArray<Node | null | undefined> = []\n    switch (node.type) {\n      case \"IfStatement\":\n      case \"ConditionalExpression\":\n      case \"WhileStatement\":\n      case \"DoWhileStatement\":\n        tests = [node.test]\n        break\n      case \"LogicalExpression\":\n        tests = [node.left]\n        break\n      case \"SwitchStatement\":\n        tests = [node.discriminant, ...node.cases.map((entry) => entry.test)]\n        break\n      case \"ForOfStatement\":\n      case \"ForInStatement\":\n        tests = [node.right]\n        break\n      case \"CatchClause\":\n        return visit(node.body, true)\n    }\n    const inner = guarded || tests.some((test) => test != null && reads(test, results))\n    return children(node).some((child) => visit(child, inner))\n  }\n  return visit(root, false)\n}\n\n/** The realm's calls that only move a value: their arguments are read where their result is. */\nconst pure = new Map<string, ReadonlySet<string>>([\n  [\"Promise\", new Set([\"all\", \"allSettled\", \"any\", \"race\", \"resolve\"])],\n  [\"JSON\", new Set([\"parse\", \"stringify\"])],\n  [\"Object\", new Set([\"assign\", \"entries\", \"fromEntries\", \"keys\", \"values\"])],\n  [\"Array\", new Set([\"from\", \"of\"])]\n])\nconst pureFunctions = new Set([\"String\", \"Number\", \"Boolean\"])\n/** Methods that keep their argument in the receiver; `flows` follows it there. */\nconst keeping = new Set([\"push\", \"unshift\", \"add\", \"set\", \"append\"])\n\n/** A function's parameters and body, or nothing when the node is not a function. */\nconst functionParts = (node: Node): ReadonlyArray<Node> | undefined => {\n  switch (node.type) {\n    case \"FunctionExpression\":\n    case \"ArrowFunctionExpression\":\n    case \"FunctionDeclaration\":\n    case \"ObjectMethod\":\n    case \"ClassMethod\":\n    case \"ClassPrivateMethod\":\n      return [...node.params, node.body]\n    default:\n      return undefined\n  }\n}\n\nconst functionLike = (node: Node): boolean => functionParts(node) !== undefined\n\nconst consoleCall = (node: Node): boolean => {\n  if (node.type !== \"CallExpression\" && node.type !== \"OptionalCallExpression\") return false\n  const member = memberName(node.callee)\n  return member !== undefined && member[0].type === \"Identifier\" && member[0].name === \"console\" &&\n    !node.arguments.some(functionLike)\n}\n\n/** An expression that only prints, or yields nothing: a `console.log` of `r`, `null`, `void 0`. */\nconst logging = (node: Node): boolean =>\n  consoleCall(node) || node.type === \"NullLiteral\" || (node.type === \"Identifier\" && node.name === \"undefined\") ||\n  (node.type === \"UnaryExpression\" && node.operator === \"void\" && node.argument.type === \"NumericLiteral\") ||\n  (node.type === \"ConditionalExpression\" && logging(node.consequent) && logging(node.alternate)) ||\n  (node.type === \"LogicalExpression\" && logging(node.right))\n\n/**\n * A statement that only prints, whatever it prints under: a guard such as\n * `if (r.exitCode)` around a `console.log` of `r.stderr` shows a result to the model and\n * decides nothing, so the result it tests stays unread by the program. A\n * `return`, `throw`, `break` out of a loop, or any other statement is control\n * flow or an effect and is not logging.\n */\nconst loggingOnly = (node: Node | null | undefined): boolean => {\n  if (node === null || node === undefined) return true\n  switch (node.type) {\n    case \"EmptyStatement\":\n      return true\n    case \"BlockStatement\":\n      return node.body.every(loggingOnly)\n    case \"ExpressionStatement\":\n      return logging(node.expression)\n    case \"IfStatement\":\n      return loggingOnly(node.consequent) && loggingOnly(node.alternate)\n    case \"SwitchStatement\":\n      return node.cases.every((entry) =>\n        entry.consequent.every((statement) =>\n          (statement.type === \"BreakStatement\" && statement.label === null) || loggingOnly(statement)\n        )\n      )\n    default:\n      return false\n  }\n}\n\nconst memberName = (callee: Node): readonly [Node, string] | undefined =>\n  (callee.type === \"MemberExpression\" || callee.type === \"OptionalMemberExpression\") && !callee.computed &&\n    callee.property.type === \"Identifier\"\n    ? [callee.object, callee.property.name]\n    : undefined\n\n/**\n * Whether the program acts on a result: reads a call or a name holding a\n * result anywhere but inside `console.*`, and other than by copying it into\n * another name, which is followed through that name.\n *\n * Copying is narrow on purpose: the source of a binding or assignment, the\n * argument of `push` and its kin, and the realm's value-moving functions\n * (`JSON.parse`, `Promise.all`, a method of the result itself). Anything the\n * parse cannot see through \u2014 a function of the program's own, a callback, a\n * `.then`, an alias \u2014 is an act, because the program may complete from there.\n */\nconst actsOn = (root: Node, results: ReadonlySet<string>, calls = true): boolean => {\n  // Without `calls`, only the names count: a call read inline is some other result.\n  const reading = (node: Node) => calls ? reads(node, results) : mentions(node, results)\n  const visit = (node: Node, acting: boolean): boolean => {\n    if (node.type === \"Identifier\") return acting && results.has(node.name)\n    const parts = functionParts(node)\n    // A function's body runs whenever the program calls it, so it acts.\n    if (parts !== undefined) return parts.some((child) => visit(child, true))\n    if (node.type === \"ExpressionStatement\" || (node.type === \"UnaryExpression\" && node.operator === \"void\")) {\n      // An effect's result discarded as a statement of its own is not read.\n      const discarded = node.type === \"ExpressionStatement\" ? node.expression : node.argument\n      const inner = discarded.type === \"AwaitExpression\" ? discarded.argument : discarded\n      if (ctxCall(inner, \"call\")) {\n        return (inner as Syntax.CallExpression).arguments.some((argument) => visit(argument, true))\n      }\n    }\n    if (node.type === \"CallExpression\" || node.type === \"OptionalCallExpression\" || node.type === \"NewExpression\") {\n      const callee = node.callee\n      const member = memberName(callee)\n      if (member !== undefined && member[0].type === \"Identifier\" && member[0].name === \"console\") return false\n      if (ctxCall(node, \"call\")) {\n        return (calls && acting) || node.arguments.some((argument) => visit(argument, true))\n      }\n      if (ctxCall(node, \"done\")) return node.arguments.some((argument) => visit(argument, true))\n      const readsCallee = reading(callee)\n      if (\n        (callee.type === \"Identifier\" && pureFunctions.has(callee.name)) ||\n        (member !== undefined && member[0].type === \"Identifier\" && pure.get(member[0].name)?.has(member[1]) === true)\n      ) return node.arguments.some((argument) => visit(argument, acting))\n      if (member !== undefined && keeping.has(member[1])) {\n        // `all.push(seen)` writes `all`; `flows` follows `seen` into it.\n        return node.arguments.some((argument) => visit(argument, false))\n      }\n      if (member !== undefined && readsCallee && !node.arguments.some(functionLike)) {\n        // A method of the result itself, such as `seen.stdout.trim()`.\n        return visit(callee, acting) || node.arguments.some((argument) => visit(argument, acting))\n      }\n      return readsCallee || node.arguments.some((argument) => reading(argument))\n    }\n    // A guard around printing alone reads its test for the model, not the\n    // program; only as a statement of its own, since `ctx.done(r.ok || null)`\n    // reads `r`.\n    if (node.type === \"IfStatement\" && loggingOnly(node)) {\n      return quietly(node.test) || visit(node.consequent, false) ||\n        (node.alternate != null && visit(node.alternate, false))\n    }\n    if (node.type === \"SwitchStatement\" && loggingOnly(node)) {\n      return quietly(node.discriminant) ||\n        node.cases.some((entry) =>\n          (entry.test != null && quietly(entry.test)) || entry.consequent.some((statement) => visit(statement, false))\n        )\n    }\n    if (node.type === \"ExpressionStatement\" && loggingOnly(node)) return quietly(node.expression)\n    switch (node.type) {\n      case \"VariableDeclarator\":\n        return node.init != null && visit(node.init, false)\n      case \"AssignmentExpression\":\n        return visit(node.left, false) || visit(node.right, false)\n      case \"ForOfStatement\":\n      case \"ForInStatement\":\n        return visit(node.right, false) || visit(node.body, acting)\n      case \"IfStatement\":\n      case \"ConditionalExpression\":\n      case \"WhileStatement\":\n      case \"DoWhileStatement\":\n        if (visit(node.test, true)) return true\n        break\n      case \"LogicalExpression\":\n        if (visit(node.left, true)) return true\n        break\n      case \"SwitchStatement\":\n        if (visit(node.discriminant, true)) return true\n        break\n      case \"SwitchCase\":\n        if (node.test != null && visit(node.test, true)) return true\n        break\n    }\n    return referencing(node).some((child) => visit(child, acting))\n  }\n  /** An expression whose value only decides what is printed. */\n  const quietly = (node: Node): boolean => {\n    if (node.type === \"ConditionalExpression\") {\n      return quietly(node.test) || quietly(node.consequent) || quietly(node.alternate)\n    }\n    if (node.type === \"LogicalExpression\") return quietly(node.left) || quietly(node.right)\n    return visit(node, false)\n  }\n  return visit(root, true)\n}\n\n/** Whether a call's result is used at all, rather than discarded as a statement of its own. */\nconst keepsResult = (root: Node): boolean => {\n  const calls: Array<Node> = []\n  const discarded = new Set<Node>()\n  const visit = (node: Node): void => {\n    if (ctxCall(node, \"call\")) calls.push(node)\n    if (node.type === \"ExpressionStatement\" || (node.type === \"UnaryExpression\" && node.operator === \"void\")) {\n      const inner = node.type === \"ExpressionStatement\" ? node.expression : node.argument\n      discarded.add(inner.type === \"AwaitExpression\" ? inner.argument : inner)\n    }\n    for (const child of children(node)) visit(child)\n  }\n  visit(root)\n  return calls.some((call) => !discarded.has(call))\n}\n\n/**\n * Whether a completing cell's source wrote its completion blind: it kept a\n * call's result for the model alone and completed from code that reads none.\n * A source that does not parse is never read as blind, because nothing here\n * can say what it did.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const blind = (source: string): boolean => {\n  let program: Syntax.File\n  try {\n    program = parse(source, {\n      sourceType: \"script\",\n      plugins: [\"typescript\"],\n      allowAwaitOutsideFunction: true,\n      allowReturnOutsideFunction: true,\n      errorRecovery: true\n    })\n  } catch {\n    return false\n  }\n  if (!keepsResult(program.program)) return false\n  const results = resultNames(program.program)\n  if (!actsOn(program.program, results)) return true\n  // A program that acted on some results but completes from none of them\n  // wrote its answer blind to any result it only printed.\n  if (completionReads(program.program, results)) return false\n  return resultsByCall(program.program).some((held) => !actsOn(program.program, held, false))\n}\n\n/**\n * The calls a completion was written without reading, oldest first: every\n * call its own frame settled, when the cell wrote the completion blind.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const find = (calls: ReadonlyArray<Settled>, source: string): ReadonlyArray<Unobserved> =>\n  calls.length === 0 || !blind(source)\n    ? []\n    : calls.map((call) => ({ flow: call.flow, ok: call.ok, ordinal: call.ordinal, summary: call.summary }))\n\n/**\n * The demand a blind completion is handed back with: the results it never\n * read, then the correction.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const demand = (calls: ReadonlyArray<Unobserved>): string =>\n  `${heading}:\n${calls.map((call) => `- ${call.ordinal}. ${call.flow} -> ${call.ok ? \"ok\" : \"FAILED\"}: ${call.summary}`).join(\"\\n\")}\n\nAnswer after reading the calls' output, in a reply of its own.`\n"],
+  "mappings": "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",
+  "names": ["targets"]
+}