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

package/dist/cjs/internal/frame.js

@@ -0,0 +1,514 @@
+"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 frame_exports = {};
+__export(frame_exports, {
+  account: () => account,
+  discipline: () => discipline,
+  handBackRoom: () => handBackRoom,
+  hasNextFrame: () => hasNextFrame,
+  judgeCompletion: () => judgeCompletion,
+  taskText: () => taskText
+});
+module.exports = __toCommonJS(frame_exports);
+var import_model = require("@smthrs/model");
+var import_effect = require("effect");
+var AgentEvent = __toESM(require("../AgentEvent.js"), 1);
+var CallLedger = __toESM(require("../CallLedger.js"), 1);
+var CompletionClaim = __toESM(require("../CompletionClaim.js"), 1);
+var FailedCall = __toESM(require("../FailedCall.js"), 1);
+var NarrowedCheck = __toESM(require("../NarrowedCheck.js"), 1);
+var Sufficiency = __toESM(require("../Sufficiency.js"), 1);
+var TruncatedOutput = __toESM(require("../TruncatedOutput.js"), 1);
+var UnmovedTree = __toESM(require("../UnmovedTree.js"), 1);
+var UnresolvedFailure = __toESM(require("../UnresolvedFailure.js"), 1);
+var VariablesPanel = __toESM(require("../VariablesPanel.js"), 1);
+var bytes = __toESM(require("./bytes.js"), 1);
+var DemandText = __toESM(require("./demandText.js"), 1);
+var elide = __toESM(require("./elide.js"), 1);
+var import_paidUsage = require("./paidUsage.js");
+var UnfinishedWork = __toESM(require("./unfinishedWork.js"), 1);
+var UnobservedCall = __toESM(require("./unobservedCall.js"), 1);
+const eventType = AgentEvent.eventType;
+const hasNextFrame = (state) => state.maxFrames === 0 || state.frame + 1 < state.maxFrames;
+const handBackRoom = (state, readOnlyFrames) => hasNextFrame(state) && (state.readOnlyCap === 0 || readOnlyFrames + 1 < state.readOnlyCap * 2);
+const invalidProbeNotice = (calls) => {
+  const lines = calls.flatMap(
+    (call) => call.invalidProbe === void 0 ? [] : [`- ${call.flow} (${call.invalidProbe.reason}): ${call.invalidProbe.message}`]
+  );
+  if (lines.length === 0) return void 0;
+  return `Invalid probe \u2014 ${lines.length} call${lines.length === 1 ? "" : "s"} this frame failed about the command, not about the code:
+${lines.join("\n")}
+That result is not a reproduction and is not a regression: it reads identically on a broken tree and on a fixed one, so it can neither prove the bug nor prove the repair. Repair the command before editing anything \u2014 find the real names first \u2014 and do not store it as \`state.verification\` or name it when you complete.`;
+};
+const retainedSignatures = 64;
+const remember = (known, made) => {
+  const newest = new Set(known);
+  for (const digest of made) {
+    newest.delete(digest);
+    newest.add(digest);
+  }
+  const distinct = [...newest];
+  return distinct.slice(Math.max(0, distinct.length - retainedSignatures));
+};
+const account = (options) => {
+  const { calls, closed, opened, state } = options;
+  const declaredWrites = calls.filter((call) => call.mutates).length;
+  const measured = import_effect.Option.isSome(opened) && import_effect.Option.isSome(closed);
+  const covered = measured && opened.value.complete && closed.value.complete;
+  const standingWrites = calls.filter((call) => call.mutates && (call.ok || !covered)).length;
+  const mutated = standingWrites > 0 || covered && opened.value.digest !== closed.value.digest;
+  const remoteWrites = calls.filter((call) => call.ok && call.mutates && call.remote).length;
+  const closingDigest = import_effect.Option.match(closed, { onNone: () => "", onSome: (value) => value.digest });
+  const signatures = calls.map((call) => call.signature);
+  const asked = new Set(state.callSignatures);
+  const novel = signatures.some((signature) => !asked.has(signature));
+  const repeatFrames = signatures.length === 0 ? state.repeatFrames : novel || mutated ? 0 : state.repeatFrames + 1;
+  const workspaceDigest = covered ? closingDigest : "";
+  const standingAt = calls.map((call) => call.mutates && (call.ok || !covered));
+  const lastStandingWrite = standingAt.lastIndexOf(true);
+  const unattributedMutation = mutated && lastStandingWrite === -1;
+  const readings = (checkpointed) => calls.flatMap((call, index) => {
+    if (!call.ok || call.mutates || call.at !== void 0 !== checkpointed) return [];
+    const recorded = NarrowedCheck.check({
+      flow: call.flow,
+      signature: call.subject,
+      input: call.input,
+      // A reading taken against a checkpoint is a reading of a tree that is
+      // not this workspace, so it carries no workspace digest: every ledger
+      // that reads one asks a question about the tree the run is standing
+      // on, and an entry stamped with this frame's digest would answer that
+      // question with somebody else's tree. Empty makes it inert there.
+      digest: checkpointed ? "" : workspaceDigest,
+      failing: call.failing,
+      passing: call.passing,
+      // Whether the tree stamped above is the tree this call read. Every
+      // write the frame declared is a call with a position among these ones,
+      // so the answer is positional: a check with no standing write after it
+      // read the closing tree, and one with a write after it read a tree
+      // that is gone. That is what lets the loop a real agent runs — edit,
+      // then run the check that was red, in one frame — hold its own
+      // evidence, while `check, then edit` still stamps nothing.
+      //
+      // A checkpointed reading is stable for a different reason: the tree it
+      // read was pinned and cannot move, so the ordering is established by
+      // the pin rather than by position — which is exactly what that surface
+      // exists to buy, and what the run used to buy by reverting its work.
+      stable: checkpointed || !unattributedMutation && index > lastStandingWrite
+    });
+    return recorded === void 0 ? [] : [recorded];
+  });
+  const frameChecks = readings(false);
+  return {
+    mutated,
+    calls,
+    source: options.source ?? "",
+    observed: new AgentEvent.MutationObserved({
+      eventType: eventType.mutationObserved,
+      basis: covered ? "observed" : measured ? "partial" : "declared",
+      mutated,
+      digest: closingDigest,
+      paths: import_effect.Option.match(closed, { onNone: () => 0, onSome: (value) => value.paths }),
+      declaredWrites
+    }),
+    workspaceDigest,
+    frameChecks,
+    probeNotice: invalidProbeNotice(calls),
+    facts: {
+      // Seeded from what earlier frames were handed and appended to as this
+      // frame's calls settled.
+      truncatedOutputs: TruncatedOutput.retain(options.captures),
+      workspace: closed,
+      // A frame is read-only when it changed nothing; see
+      // `State.readOnlyFrames` for why that is measured and not declared.
+      // Once the run has written something, a read-only frame that settled a
+      // call this run had not issued before holds the streak where it was: it
+      // asked a new question about work that exists, which is debugging, not a
+      // stall. Before the first write every read-only frame counts, because a
+      // run that only ever reads new things is the failure the cap was built
+      // for. Zero-call and repeat-only frames always advance it.
+      readOnlyFrames: mutated ? 0 : novel && state.mutations > 0 ? state.readOnlyFrames : state.readOnlyFrames + 1,
+      repeatFrames,
+      callSignatures: remember(state.callSignatures, signatures),
+      // Ids this frame pinned: a checkpoint a frame minted before it raised is
+      // still a tree the run holds, and forgetting it would leak a stored tree
+      // nothing can name.
+      checkpointIds: options.minted.length === 0 ? state.checkpointIds : [...state.checkpointIds, ...options.minted],
+      // Live readings only. Every consumer of this ledger — the narrowing
+      // demand, the unresolved-failure demand, the vacuous-verification notice
+      // — asks whether the tree the run is completing on was checked, and a
+      // checkpointed reading is not a reading of that tree.
+      checks: NarrowedCheck.remember(state.checks, frameChecks),
+      // What this frame asked, folded into what the run had already asked. A
+      // raise carries it too: a call that settled before the throw is work
+      // the run paid for, and the ledger is the only place the next model turn
+      // can read it.
+      callLedger: CallLedger.remember(state.callLedger, calls),
+      // Every call that reported an exit status, writes included, for the
+      // claim brake. See `CompletionClaim.record`.
+      reported: CompletionClaim.record(state.reported, calls),
+      // Which of this frame's checks failed before any change did, and how
+      // many frames have changed the workspace. Both, because this is the one
+      // ledger a checkpointed reading belongs in: its whole question is an
+      // ordering — this failed, then something changed, then that passed — and
+      // a pinned tree answers the first half honestly from a frame that also
+      // did the changing.
+      failures: Sufficiency.remember(state.failures, {
+        frame: [...readings(true), ...frameChecks],
+        epoch: state.mutations
+      }),
+      mutations: state.mutations + (mutated ? 1 : 0),
+      remoteMutations: state.remoteMutations + remoteWrites,
+      // The tree the run was handed, fixed the first time a frame measured one
+      // and never restamped. See `State.openingDigest`.
+      openingDigest: state.openingDigest !== "" ? state.openingDigest : import_effect.Option.match(opened, {
+        onNone: () => "",
+        onSome: (value) => value.complete ? value.digest : ""
+      }),
+      // The panel the next frame opens with, stamped by the frame that ran.
+      panel: VariablesPanel.stamp(state.panel, options.bindings, state.frame),
+      ...mutated ? { readOnlyGrace: 0, pendingReadOnlyDemand: void 0 } : {}
+    }
+  };
+};
+const taughtTerms = (window) => NarrowedCheck.terms(
+  window.segments.filter((segment) => segment.zone === "prefix").flatMap((segment) => segment.content).map((part) => "text" in part && typeof part.text === "string" ? part.text : "").join("\n")
+);
+const stands = {
+  observed: void 0,
+  demand: void 0,
+  unproven: void 0,
+  decision: void 0
+};
+const handBack = (demand, decision) => ({
+  observed: void 0,
+  demand,
+  unproven: void 0,
+  decision
+});
+const taskText = (window) => window.segments.filter((segment) => segment.zone === "prefix" && segment.kind === "instructions").flatMap((segment) => segment.content).map((part) => "text" in part && typeof part.text === "string" ? part.text : "").filter((text) => text !== "").join("\n\n");
+const lastCheck = (calls) => {
+  for (let index = calls.length - 1; index >= 0; index--) {
+    const call = calls[index];
+    if (!call.ok || call.mutates) continue;
+    const status = UnresolvedFailure.exitStatus(call.value);
+    if (status === void 0) continue;
+    return {
+      command: CompletionClaim.quote(call.input),
+      exitCode: status,
+      output: CompletionClaim.newest(CompletionClaim.quote(call.value))
+    };
+  }
+  return void 0;
+};
+const measuredDemand = (state, accounting, contextWindow, nextFrame, claim) => {
+  const { calls, facts, frameChecks, workspaceDigest } = accounting;
+  if (state.failedCallDemands < FailedCall.cap) {
+    const failures = FailedCall.find(calls, claim, accounting.source);
+    if (failures.length > 0) {
+      return {
+        event: new AgentEvent.FailedCallDemanded({
+          eventType: eventType.failedCallDemanded,
+          failures: failures.map((failure) => ({ flow: failure.flow, message: failure.message })),
+          nextFrame
+        }),
+        note: FailedCall.demand(failures),
+        keeps: false,
+        spent: { failedCallDemands: state.failedCallDemands + 1 }
+      };
+    }
+  }
+  if (state.unobservedDemands < UnobservedCall.cap) {
+    const unread = UnobservedCall.find(calls, accounting.source);
+    if (unread.length > 0) {
+      return {
+        event: new AgentEvent.UnobservedDemanded({
+          eventType: eventType.unobservedDemanded,
+          calls: unread,
+          nextFrame
+        }),
+        note: UnobservedCall.demand(unread),
+        keeps: true,
+        spent: { unobservedDemands: state.unobservedDemands + 1 }
+      };
+    }
+  }
+  if (state.unresolvedDemands < state.unresolvedCap) {
+    const unresolved = UnresolvedFailure.find({ ledger: facts.checks, digest: workspaceDigest });
+    if (unresolved !== void 0) {
+      return {
+        event: new AgentEvent.UnresolvedDemanded({
+          eventType: eventType.unresolvedDemanded,
+          flow: unresolved.failed.flow,
+          failed: unresolved.failed.label,
+          instead: unresolved.instead.label,
+          currentDigest: workspaceDigest,
+          nextFrame
+        }),
+        note: UnresolvedFailure.demand(unresolved),
+        keeps: true,
+        spent: { unresolvedDemands: state.unresolvedDemands + 1 }
+      };
+    }
+  }
+  if (state.narrowingDemands >= state.narrowingCap) return void 0;
+  const spent = { narrowingDemands: state.narrowingDemands + 1 };
+  const narrowing = NarrowedCheck.find({ ledger: state.checks, frame: frameChecks, digest: workspaceDigest });
+  if (narrowing !== void 0) {
+    return {
+      event: new AgentEvent.NarrowedDemanded({
+        eventType: eventType.narrowedDemanded,
+        flow: narrowing.earlier.flow,
+        broader: narrowing.earlier.label,
+        narrower: narrowing.later.label,
+        broaderDigest: narrowing.earlier.digest,
+        currentDigest: workspaceDigest,
+        nextFrame
+      }),
+      note: NarrowedCheck.demand(narrowing),
+      keeps: true,
+      spent
+    };
+  }
+  const only = NarrowedCheck.findOnly({
+    ledger: facts.checks,
+    before: state.checks.map((entry) => entry.signature),
+    frame: frameChecks,
+    taught: taughtTerms(contextWindow)
+  });
+  if (only === void 0) return void 0;
+  return {
+    event: new AgentEvent.NarrowOnlyDemanded({
+      eventType: eventType.narrowOnlyDemanded,
+      flow: only.later.flow,
+      check: only.later.label,
+      targets: only.targets,
+      currentDigest: workspaceDigest,
+      nextFrame
+    }),
+    note: NarrowedCheck.demandOnly(only),
+    keeps: true,
+    spent
+  };
+};
+const judgeCompletion = (state, accounting, contextWindow, claim, read = CompletionClaim.read) => import_effect.Effect.gen(function* () {
+  const { calls, facts, workspaceDigest } = accounting;
+  const room = handBackRoom(state, facts.readOnlyFrames) && state.demandedFrame !== state.frame;
+  const nextFrame = state.frame + 1;
+  if (room) {
+    const measured = measuredDemand(state, accounting, contextWindow, nextFrame, claim);
+    if (measured !== void 0) return handBack(measured);
+  }
+  if (state.claimCap === 0) return stands;
+  const originalTask = taskText(contextWindow).trim();
+  const recallTask = "the run record has the whole task";
+  const task = elide.middle(
+    originalTask,
+    CompletionClaim.proseBytes - elide.noticeCost(bytes.size(originalTask), recallTask),
+    recallTask
+  );
+  const check = lastCheck(calls);
+  const unmovedTree = UnmovedTree.find({
+    opened: facts.openingDigest,
+    digest: workspaceDigest,
+    elsewhere: facts.remoteMutations
+  });
+  const evidence = {
+    task,
+    claim: CompletionClaim.prose(claim),
+    // The `UnmovedTree` fact, read the other way round. An unmeasured tree
+    // reads as moved, which is the reading that asks for nothing.
+    treeMoved: unmovedTree === void 0,
+    checksRun: facts.reported,
+    callsRun: facts.callLedger.map((entry) => ({
+      flow: entry.flow,
+      input: entry.subject,
+      ok: entry.ok,
+      resultSummary: entry.digest
+    })),
+    ...check === void 0 ? {} : { lastCheck: check }
+  };
+  const reading = yield* read(evidence);
+  if (reading === void 0) return stands;
+  const found = CompletionClaim.find(reading);
+  const bounced = found !== void 0 && room && state.claimDemands < state.claimCap;
+  const unmoved = found !== void 0 && room && state.unmovedDemands < state.unmovedCap ? unmovedTree : void 0;
+  const refused = found !== void 0 && !bounced && unmoved === void 0 && CompletionClaim.unrecorded(found);
+  const unfinished = found !== void 0 && !bounced && unmoved === void 0 && !refused && reading.complete <= CompletionClaim.disprovenAt ? yield* UnfinishedWork.read(evidence, reading.usage) : void 0;
+  const incomplete = unfinished !== void 0 && unfinished.unfinished >= UnfinishedWork.reportedAt;
+  const usage = (0, import_paidUsage.paidTogether)(reading.usage, unfinished?.usage);
+  const event = new AgentEvent.ClaimDemanded({
+    eventType: eventType.claimDemanded,
+    complete: reading.complete,
+    overclaims: reading.overclaims,
+    invented: reading.invented,
+    latencyMs: reading.latencyMs + (unfinished?.latencyMs ?? 0),
+    ...usage === void 0 ? {} : { usage },
+    demanded: bounced && unmoved === void 0,
+    refused,
+    currentDigest: workspaceDigest,
+    nextFrame
+  });
+  const decision = reading.asked === void 0 ? void 0 : new AgentEvent.DecisionSettled({
+    eventType: eventType.decisionSettled,
+    scope: state.session,
+    frame: state.frame,
+    classifier: CompletionClaim.classifier.id,
+    digest: CompletionClaim.classifier.digest,
+    state: reading.asked.state,
+    questions: CompletionClaim.classifier.questions,
+    answers: reading.asked.answers,
+    latencyMs: reading.latencyMs,
+    acted: bounced || refused || unmoved !== void 0 || incomplete,
+    decidedBy: "jev"
+  });
+  const unfinishedDecision = unfinished === void 0 ? void 0 : new AgentEvent.DecisionSettled({
+    eventType: eventType.decisionSettled,
+    scope: state.session,
+    frame: state.frame,
+    classifier: unfinished.asked.classifier,
+    digest: unfinished.asked.digest,
+    state: unfinished.asked.state,
+    questions: unfinished.asked.questions,
+    answers: unfinished.asked.answers,
+    latencyMs: unfinished.latencyMs,
+    acted: incomplete,
+    decidedBy: "jev"
+  });
+  const sentenceDecision = reading.sentences === void 0 ? void 0 : new AgentEvent.DecisionSettled({
+    eventType: eventType.decisionSettled,
+    scope: state.session,
+    frame: state.frame,
+    classifier: reading.sentences.classifier,
+    digest: reading.sentences.digest,
+    state: reading.sentences.state,
+    questions: reading.sentences.questions,
+    answers: reading.sentences.answers,
+    latencyMs: reading.sentences.latencyMs,
+    acted: bounced || refused || unmoved !== void 0,
+    decidedBy: "jev"
+  });
+  if (found === void 0) {
+    return { observed: event, demand: void 0, unproven: void 0, decision, sentenceDecision };
+  }
+  if (unmoved !== void 0) {
+    return {
+      ...handBack({
+        event: new AgentEvent.UnmovedDemanded({
+          eventType: eventType.unmovedDemanded,
+          openedDigest: unmoved.opened,
+          currentDigest: unmoved.closed,
+          nextFrame
+        }),
+        note: UnmovedTree.demand(unmoved),
+        keeps: !CompletionClaim.unrecorded(found),
+        spent: { unmovedDemands: state.unmovedDemands + 1 }
+      }, decision),
+      observed: event,
+      sentenceDecision
+    };
+  }
+  if (bounced) {
+    return {
+      ...handBack({
+        event,
+        note: CompletionClaim.demand(),
+        // A bounce the brake would not refuse is worth restoring against an
+        // exhausted budget; one it would refuse is not. See `CompletionDemand`.
+        keeps: !CompletionClaim.unrecorded(found),
+        spent: { claimDemands: state.claimDemands + 1 }
+      }, decision),
+      sentenceDecision
+    };
+  }
+  return {
+    observed: event,
+    demand: void 0,
+    // Either bounce handed the claim back: the unmoved demand spends its
+    // own cap in the claim brake's place.
+    unproven: refused ? CompletionClaim.unproven(found, state.claimDemands + state.unmovedDemands > 0, claim) : incomplete ? UnfinishedWork.incomplete(reading.complete, unfinished.unfinished, claim) : void 0,
+    decision,
+    sentenceDecision,
+    ...unfinishedDecision === void 0 ? {} : { unfinishedDecision }
+  };
+});
+const discipline = (state, accounting, justification) => {
+  const { facts } = accounting;
+  const cap = state.readOnlyCap;
+  const readOnly = !accounting.mutated;
+  const graceLeft = readOnly ? state.readOnlyGrace : 0;
+  const justified = readOnly && state.pendingReadOnlyDemand !== void 0 && (justification ?? "").trim().length > 0;
+  const advanced = readOnly && facts.readOnlyFrames > state.readOnlyFrames;
+  const demanded = cap > 0 && advanced && facts.readOnlyFrames >= cap && graceLeft === 0 && !justified;
+  const repeated = state.repeatCap > 0 && facts.repeatFrames >= state.repeatCap;
+  const sufficient = state.sufficiencyStated ? void 0 : Sufficiency.find({ ledger: facts.failures, frame: accounting.frameChecks, epoch: facts.mutations });
+  const nextFrame = state.frame + 1;
+  return {
+    events: [
+      ...demanded ? [
+        new AgentEvent.ReadOnlyDemandIssued({
+          eventType: eventType.readOnlyDemandIssued,
+          streak: facts.readOnlyFrames,
+          cap,
+          nextFrame
+        })
+      ] : [],
+      ...repeated ? [
+        new AgentEvent.RepeatDemanded({
+          eventType: eventType.repeatDemanded,
+          frames: facts.repeatFrames,
+          cap: state.repeatCap,
+          nextFrame
+        })
+      ] : [],
+      ...sufficient === void 0 ? [] : [
+        new AgentEvent.SufficiencyObserved({
+          eventType: eventType.sufficiencyObserved,
+          flow: sufficient.failed.flow,
+          failed: sufficient.failed.label,
+          passed: sufficient.passed.label,
+          epoch: sufficient.failed.epoch,
+          nextFrame
+        })
+      ]
+    ],
+    messages: [
+      ...accounting.probeNotice === void 0 ? [] : [import_model.ModelRequest.Message.user(accounting.probeNotice)],
+      ...demanded ? [import_model.ModelRequest.Message.user(DemandText.readOnly(cap, facts.readOnlyFrames))] : [],
+      ...repeated ? [import_model.ModelRequest.Message.user(DemandText.repeat(facts.repeatFrames, state.repeatCap))] : [],
+      ...sufficient === void 0 ? [] : [import_model.ModelRequest.Message.user(Sufficiency.observation(sufficient))]
+    ],
+    changes: {
+      readOnlyGrace: justified ? cap : Math.max(0, graceLeft - 1),
+      repeatFrames: repeated ? 0 : facts.repeatFrames,
+      ...sufficient === void 0 ? {} : { sufficiencyStated: true },
+      pendingReadOnlyDemand: demanded ? { streak: facts.readOnlyFrames, cap } : void 0
+    }
+  };
+};
+//# sourceMappingURL=frame.js.map