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

package/src/internal/compactionMarks.ts

@@ -0,0 +1,454 @@
+/**
+ * What a compaction does with each old frame: keep it, squash it into the
+ * summary, or remove it.
+ *
+ * {@link pins} fixes what must survive whatever Jev says: a summary is always
+ * squashed, so a later summary extends it; steering and the person's messages
+ * are kept, and so is the newest frame that ran each check still failing; a
+ * frame that changed files is never removed; and the two halves of a tool
+ * call and its result share one mark. {@link read} asks Jev two questions
+ * about each segment, and {@link resolve} turns the answers into marks,
+ * demoting the least-needed keeps until the kept frames fit the window.
+ *
+ * Marking is not compacting. The supervisor asks about each settled segment
+ * off the loop's hot path, and the run stores each {@link Answer} in the
+ * segment's {@link Facts}; nothing the model is sent changes. Only when the
+ * budget forces a compaction are the pins taken and the stored answers
+ * resolved, and a segment still unmarked then is asked about in that one
+ * reading.
+ *
+ * Nothing here journals or compacts; the caller records the reading, and
+ * journals `decision-unjudged` and squashes every frame when it fails.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+
+import * as Classifier from "@smthrs/model/Classifier"
+import * as Effect from "effect/Effect"
+import * as Result from "effect/Result"
+import * as Schema from "effect/Schema"
+import { InvalidStep } from "../Compaction.ts"
+import * as ContextWindow from "../ContextWindow.ts"
+import * as Judgement from "../Judgement.ts"
+import * as bytes from "./bytes.ts"
+import { pairBoundaries } from "./compactable.ts"
+import * as elide from "./elide.ts"
+import { NonNegativeSafeInt } from "./nonNegativeSafeInt.ts"
+
+/**
+ * One frame as Jev reads it: its size, the cell it ran, what the model said
+ * beside it, and what it observed.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const Item = Schema.Struct({
+  tokens: NonNegativeSafeInt,
+  cell: Schema.String,
+  prose: Schema.String,
+  observed: Schema.String
+})
+
+/**
+ * The decoded form of {@link Item}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Item = typeof Item.Type
+
+/**
+ * What every reading is told beside its items: the task and the labels of
+ * the checks still failing.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const Context = Schema.Struct({ task: Schema.String, failing: Schema.Array(Schema.String) })
+
+/**
+ * The decoded form of {@link Context}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Context = typeof Context.Type
+
+/**
+ * Jev's answer about one item: the probabilities that it can be removed and
+ * that its exact text must be kept.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const Answer = Schema.Struct({ remove: Schema.Number, keep: Schema.Number })
+
+/**
+ * The decoded form of {@link Answer}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Answer = typeof Answer.Type
+
+/**
+ * Jev's {@link Answer} about one transcript segment, named by the segment's
+ * digest: what a supervisor reading marks and the next boundary stores.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const Marking = Schema.Struct({ digest: Schema.String, ...Answer.fields })
+
+/**
+ * The decoded form of {@link Marking}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Marking = typeof Marking.Type
+
+/**
+ * What the run knows of one transcript segment: the frame that wrote it,
+ * whether it carries the person's messages, whether it changed files, the
+ * labels of the checks it ran, and Jev's answer about it once a reading has
+ * marked it.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const Facts = Schema.Struct({
+  frame: NonNegativeSafeInt,
+  person: Schema.Boolean,
+  mutated: Schema.Boolean,
+  checks: Schema.Array(Schema.String),
+  answer: Schema.optionalKey(Answer)
+})
+
+/**
+ * The decoded form of {@link Facts}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Facts = typeof Facts.Type
+
+/**
+ * Why a mark was not Jev's own.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const Pinned = Schema.Literals(["summary", "steering", "person", "failing", "mutated", "pair", "budget"])
+
+/**
+ * The decoded form of {@link Pinned}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Pinned = typeof Pinned.Type
+
+/**
+ * One segment's resolved mark, and why it was fixed when Jev did not choose
+ * it.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const Marked = Schema.Struct({ mark: ContextWindow.Mark, pinned: Schema.optionalKey(Pinned) })
+
+/**
+ * The decoded form of {@link Marked}.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export type Marked = typeof Marked.Type
+
+/**
+ * What {@link pins} fixes for one segment. `mark` is fixed and not asked;
+ * `floor` is the weakest mark allowed; `pair` is the index of the first
+ * segment of the tool-call span the segment shares a mark with.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export interface Pin {
+  readonly pin: Exclude<Pinned, "budget">
+  readonly mark?: ContextWindow.Mark | undefined
+  readonly floor?: ContextWindow.Mark | undefined
+  readonly pair?: number | undefined
+}
+
+const rank: Readonly<Record<ContextWindow.Mark, number>> = { remove: 0, squash: 1, keep: 2 }
+
+const stronger = (a: ContextWindow.Mark, b: ContextWindow.Mark): ContextWindow.Mark => rank[a] >= rank[b] ? a : b
+
+/** Each prefix index's span: the index of the first segment of its tool-call span. */
+const spans = (prefix: ReadonlyArray<ContextWindow.Segment>): ReadonlyArray<number> => {
+  const unsafe = pairBoundaries(prefix)
+  const starts: Array<number> = []
+  for (let index = 0; index < prefix.length; index++) {
+    starts.push(unsafe.has(index) ? starts[index - 1]! : index)
+  }
+  return starts
+}
+
+const own = (
+  segment: ContextWindow.Segment,
+  facts: Facts | undefined,
+  newest: boolean
+): Pin | undefined => {
+  if (segment.kind === "summary") return { mark: "squash", pin: "summary" }
+  if (segment.kind === "steering") return { mark: "keep", pin: "steering" }
+  if (facts === undefined) return undefined
+  if (facts.person) return { mark: "keep", pin: "person" }
+  if (newest) return { mark: "keep", pin: "failing" }
+  if (facts.mutated) return { floor: "squash", pin: "mutated" }
+  return undefined
+}
+
+/**
+ * What must survive of the first `prefixLength` of `segments`, the window's
+ * compactable segments in order. `facts[i]` describes `segments[i]`, and is
+ * absent for a segment no frame recorded; it is aligned by position, not by
+ * digest, because two frames can be byte-identical.
+ *
+ * Of the segments that ran a check still failing, only the newest is kept: a
+ * check that fails frame after frame would otherwise pin every run of it, and
+ * no compaction could shrink the window. When that newest run is past the
+ * prefix, no prefix segment is kept for it.
+ *
+ * A tool call and its result in different segments share the strongest
+ * retention either holds: kept together when one is pinned keep, and never
+ * below the other's floor.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const pins = (
+  segments: ReadonlyArray<ContextWindow.Segment>,
+  prefixLength: number,
+  facts: ReadonlyArray<Facts | undefined>,
+  failing: ReadonlyArray<string>
+): ReadonlyArray<Pin | undefined> => {
+  const prefix = segments.slice(0, prefixLength)
+  const newest = new Set(
+    failing.map((label) =>
+      facts.reduce((last, entry, index) => entry?.checks.includes(label) === true ? index : last, -1)
+    )
+  )
+  const owned = prefix.map((segment, index) => own(segment, facts[index], newest.has(index)))
+  const starts = spans(prefix)
+  return owned.map((pin, index) => {
+    const start = starts[index]!
+    const members = owned.filter((_, other) => starts[other] === start)
+    if (members.length === 1) return pin
+    if (members.some((member) => member?.mark === "keep")) {
+      return { mark: "keep", pin: pin?.mark === "keep" ? pin.pin : "pair", pair: start }
+    }
+    if (pin?.mark !== undefined) return { ...pin, pair: start }
+    const floors = members.flatMap((member) => member?.floor ?? member?.mark ?? [])
+    if (floors.length === 0) return { pin: "pair", pair: start }
+    const floor = floors.reduce(stronger)
+    return { floor, pin: pin?.floor === floor ? pin.pin : "pair", pair: start }
+  })
+}
+
+/**
+ * The prefix indexes whose mark Jev is asked: those no pin fixes, in order.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const unpinned = (pinned: ReadonlyArray<Pin | undefined>): ReadonlyArray<number> =>
+  pinned.flatMap((pin, index) => pin?.mark === undefined ? [index] : [])
+
+/**
+ * The most of an item's cell and prose a reading carries, head kept, and of
+ * what it observed, tail kept; in UTF-8 bytes.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const fieldBytes = 1024
+
+const recall = "the run record has the whole frame"
+
+const headKept = (text: string): string => {
+  const whole = bytes.size(text)
+  if (whole <= fieldBytes) return text
+  return elide.head(text, fieldBytes - bytes.size(`… [+${whole}b, ${recall}]`), recall)
+}
+
+const tailKept = (text: string): string => {
+  const whole = bytes.size(text)
+  if (whole <= fieldBytes) return text
+  const kept = elide.tailSlice(text, fieldBytes - bytes.size(`[+${whole}b, ${recall}] …`))
+  return `[+${whole - bytes.size(kept)}b, ${recall}] …${kept}`
+}
+
+/**
+ * The reading: `remove_${i}` and `keep_${i}` per item, in as many requests as
+ * the items need, asked together.
+ *
+ * Two booleans rather than one choice: a boolean always carries its
+ * probability, and a choice without a distribution reads one-hot, so a floor
+ * on it would guard nothing.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const reader = Judgement.perItem({
+  id: "compaction/marks",
+  description: "Decide which old frames of an agent run to keep, squash into a summary, or remove",
+  context: Context,
+  item: Item,
+  questions: {
+    remove: (i) =>
+      Classifier.boolean({
+        instructions:
+          `Is items[${i}], an old frame of this run, no longer needed at all now that the context must shrink? The task, the person's messages and the latest frames stay regardless.`,
+        criteria: {
+          true:
+            "it contributed nothing still needed: a superseded read, a repeated command, a dead end later frames abandoned",
+          false: "something it established may still matter"
+        }
+      }),
+    keep: (i) =>
+      Classifier.boolean({
+        instructions: `Will the exact text of items[${i}] be needed again?`,
+        criteria: {
+          true:
+            "a file's current content, an exact error still unresolved, a decision or constraint the run still acts on",
+          false: "a summary sentence is enough"
+        }
+      })
+  }
+})
+
+/**
+ * Asks Jev about `items`, in order. Cell and prose are sent head-kept and what was observed tail-kept,
+ * each to {@link fieldBytes}. A reading is whole or it fails.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const read = (
+  context: Context,
+  items: ReadonlyArray<Item>
+): Effect.Effect<
+  { readonly answers: ReadonlyArray<Answer>; readonly asked: ReadonlyArray<Judgement.Asked> },
+  Judgement.Unjudged
+> =>
+  reader.read(
+    context,
+    items.map((item) => ({
+      tokens: item.tokens,
+      cell: headKept(item.cell),
+      prose: headKept(item.prose),
+      observed: tailKept(item.observed)
+    }))
+  ).pipe(Effect.map((reading) => ({
+    answers: reading.answers.map((answer) => ({
+      remove: answer.remove.probability,
+      keep: answer.keep.probability
+    })),
+    asked: reading.asked
+  })))
+
+/**
+ * The window a compaction must leave room in. Kept prefix tokens, `suffix`
+ * and a summary allowance must fit under
+ * `contextWindow - reserve - keepRecent / 2`. `tokens[i]` is prefix segment
+ * `i`'s size.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export interface Budget {
+  readonly contextWindow: number
+  readonly reserve: number
+  readonly keepRecent: number
+  readonly suffix: number
+  readonly tokens: ReadonlyArray<number>
+}
+
+/** Room left for the summary a squash produces. */
+const summaryAllowance = 4000
+
+/** Jev removes a frame at or above this probability, when it would not keep it. */
+const removeAt = 0.8
+
+/** Jev keeps a frame's exact text at or above this probability. */
+const keepAt = 0.5
+
+/**
+ * The mark of every prefix segment. `answers` are {@link read}'s, for the
+ * indexes {@link unpinned} names.
+ *
+ * A segment is removed only when Jev is sure it is not needed and would not
+ * keep it, kept when Jev would keep it, and squashed otherwise; pins and
+ * floors override Jev, and a tool-call span takes its strongest mark. Then,
+ * while the kept segments do not fit the {@link Budget}, the unpinned keep
+ * Jev was least sure of, the older on a tie, is squashed. Pins alone may
+ * exceed the budget; the next frame's trigger compacts again.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const resolve = (
+  answers: ReadonlyArray<Answer>,
+  pinned: ReadonlyArray<Pin | undefined>,
+  budget: Budget
+): Result.Result<ReadonlyArray<Marked>, InvalidStep> => {
+  const asked = unpinned(pinned)
+  if (answers.length !== asked.length || budget.tokens.length !== pinned.length) {
+    return Result.fail(
+      new InvalidStep({ message: "The compaction answers and budget must describe every unpinned prefix segment" })
+    )
+  }
+  const answered = new Map(asked.map((index, at) => [index, answers[at]!]))
+  const marks: Array<Marked> = pinned.map((pin, index) => {
+    if (pin?.mark !== undefined) return { mark: pin.mark, pinned: pin.pin }
+    const { keep, remove } = answered.get(index)!
+    const mark = keep >= keepAt ? "keep" : remove >= removeAt ? "remove" : "squash"
+    return pin?.floor !== undefined && rank[pin.floor] > rank[mark]
+      ? { mark: pin.floor, pinned: pin.pin }
+      : { mark }
+  })
+  const unit = (index: number): number => pinned[index]?.pair ?? index
+  for (const [index, marked] of marks.entries()) {
+    const strongest = marks.filter((_, other) => unit(other) === unit(index)).map((other) => other.mark).reduce(
+      stronger
+    )
+    if (pinned[index]?.mark === undefined && rank[strongest] > rank[marked.mark]) {
+      marks[index] = { mark: strongest, pinned: "pair" }
+    }
+  }
+  const limit = budget.contextWindow - budget.reserve - budget.keepRecent / 2
+  let kept = marks.reduce((sum, marked, index) => marked.mark === "keep" ? sum + budget.tokens[index]! : sum, 0)
+  const units = [...new Set(marks.map((_, index) => unit(index)))]
+    .map((start) => ({ start, members: marks.flatMap((_, index) => unit(index) === start ? [index] : []) }))
+    .filter(({ members }) =>
+      members.some((index) => marks[index]!.mark === "keep") &&
+      members.every((index) => pinned[index]?.mark === undefined)
+    )
+    .map(({ members, start }) => ({
+      start,
+      members,
+      p: Math.max(...members.map((index) => answered.get(index)!.keep))
+    }))
+    .sort((a, b) => a.p - b.p || a.start - b.start)
+  for (const { members } of units) {
+    if (kept + budget.suffix + summaryAllowance <= limit) break
+    // A span takes its strongest mark, so every member of a demotable one is kept.
+    for (const index of members) {
+      marks[index] = { mark: "squash", pinned: "budget" }
+      kept -= budget.tokens[index]!
+    }
+  }
+  return Result.succeed(marks)
+}

package/src/internal/demandText.ts

@@ -0,0 +1,145 @@
+/**
+ * Canonical renderings of controller interventions recorded in the journal.
+ *
+ * `CellTurn` uses these strings when it builds the live model window and
+ * `Transcript` uses the same functions when it rebuilds that window. Keeping
+ * the rendering here makes an intervention event sufficient to reproduce the
+ * exact user message it represented.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+
+/**
+ * Renders the read-only-discipline intervention.
+ *
+ * It asks for a decision rather than a token write. An answerable request can
+ * complete without inventing work. An unfinished workspace change still needs
+ * evidence or a justification for more observation, and destructive
+ * writes made only to satisfy the notice are explicitly refused. A
+ * justification must name how later frames differ from the quiet ones so the
+ * run cannot buy a repeat by restating its plan.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const readOnly = (cap: number, frames: number): string =>
+  `Read-only discipline — ${frames} consecutive frames have made no call that declares a write, and this run's read-only budget is ${cap}. If the current request is already answered, call ctx.done(answer) now. A conversational or read-only answer needs no invented edit or command. If a workspace change is still required, land an edit you can already name the evidence for — the file, the change, and the check you have watched fail that will now pass. If more evidence is needed, call ctx.justify("<the evidence you are still missing, the exact call that will get it, and what that makes the next frames do differently from these ${frames}>"). Do not write something merely to answer this notice. A restore, a revert, an overwrite from captured output, or any edit whose evidence you cannot name is worse than another read-only frame, because it destroys work this run has already done. A justification is recorded and buys ${cap} quiet frames; it does not reset this counter, and one that names the same next step the last quiet frame named has bought a repeat of that frame. At ${
+    cap * 2
+  } consecutive read-only frames the run stops as a failure, so ${
+    cap * 2 - frames
+  } frames remain to answer the request or make the required change.`
+
+/**
+ * Renders the repeated-observation intervention.
+ *
+ * This is separate from the read-only demand because a repeating run has
+ * often already edited. It redirects the run from re-reading that edit toward
+ * mechanism evidence: the failing check, symbol history, or another caller.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const repeat = (frames: number, cap: number): string =>
+  `Repeated observation — the last ${frames} frames issued only calls this run had already issued, byte for byte, and none of them changed the workspace. You are re-confirming what you already know: a call repeated over an unchanged tree returns what it returned the first time. If you have already made a change, it is real and it is recorded, and looking at it again cannot tell you whether it is the right change — what is left to establish is the mechanism, not the presence.
+
+Spend the next frame on evidence you do not have. Three places hold some, and none of them is the diff:
+- the failing check itself — what it asserts, the values it asserts about, and the setup that produces them;
+- the history of the symbol you changed — \`git log -L <start>,<end>:<file>\` over its line range, or \`git blame\` on the line — which says why it is written the way it is and what it was written to handle;
+- a different site — the callers of the symbol rather than its definition, which is where a wrong mechanism shows first.
+
+If no call you can name would tell you something you do not already know, say which mechanism you now believe is wrong and change that instead. This notice returns after another ${cap} repeated frames.`
+
+/**
+ * Renders the unchanged-workspace completion intervention.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const unmoved = (opened: string, closed: string): string =>
+  `Unmoved workspace — the tree you are completing on is the tree this run was handed.
+
+- digest the run opened on: ${opened}
+- digest this frame closed on: ${closed}
+
+Nothing in this workspace differs from the tree this run opened on, so there is no change behind the completion you wrote. Make the change, or complete again stating that no change is needed and naming what you ran to conclude it — the calls you made, what they printed, and why that shows the behaviour asked for is already the behaviour this tree has. Both answers are accepted exactly as you write them and nothing re-checks either one; "no change is needed" with its working shown is a finished answer, and the same words with nothing behind them are the completion you just had handed back. Nothing makes the change for you, and what you return next is the answer that stands.`
+
+/**
+ * Renders the unresolved-failure completion intervention.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const unresolved = (flow: string, failed: string, instead: string): string =>
+  `Unanswered failure — a check you ran over this exact tree reported a failing exit status, and you went back to what it covered with a different command instead of running it again.
+
+- the check that failed, over the tree you are completing on: ${flow} ${failed}
+- the reading you took instead: ${flow} ${instead}
+
+The second names the same subject as the first, so the run itself treated that subject as still open; the first was never run again, and its result is the one this completion is standing on. Fix what it reported and run it again, byte for byte, and complete once you have seen what it prints; or complete and state in your output why the failures it reported are expected and not yours. Nothing re-runs it for you, and what you return next is the answer that stands.`
+
+/**
+ * Renders the narrowed-check completion intervention.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const narrowed = (flow: string, broader: string, narrower: string): string =>
+  `Narrowed verification — your last verification is narrower than a check this run has already run in full, and the workspace has changed since that broader check last ran.
+
+- the broader check, last run before your latest change: ${flow} ${broader}
+- the check this frame ran instead: ${flow} ${narrower}
+
+The second repeats every term of the first and adds conditions to it, so it reports on a part of what the first covered and says nothing about the rest — and the rest is exactly where a change breaks something that was passing. Re-run ${flow} with that earlier input, byte for byte, and complete once you have seen what it prints; or complete and state in your output why that check no longer applies to the change you made. Nothing re-runs it for you, and what you return next is the answer that stands.`
+
+/**
+ * Renders the only-reading completion intervention.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const narrowOnly = (flow: string, check: string, targets: ReadonlyArray<string>): string =>
+  `Only reading — the check you are completing on is the only reading this run has of what it names.
+
+- the check: ${flow} ${check}
+- what it names: ${targets.join(", ")}
+
+Every one of those this run has looked at somewhere else, but no other call it made covers them all, so nothing in this run says what they report on their own. Any term this check carries beyond them — a filter, a selector, a subset of cases, a flag that stops early — is a condition you have never taken off, and what a condition hides is exactly where a change breaks something that was passing. Run ${flow} over the same subjects with those conditions removed and complete once you have seen what it prints; or complete and state in your output that it carries no condition and the reading is already whole. Nothing re-runs it for you, and what you return next is the answer that stands.`
+
+/**
+ * Renders the completion-review intervention.
+ *
+ * Any of the three completion questions can ask for another frame. A low
+ * completeness reading does not establish that the run invented work, so the
+ * notice asks for a direct answer and makes evidence conditional on the
+ * actions or results that answer actually claims. A conversational answer
+ * needs no work report and must retain the person's requested format.
+ *
+ * The task is not quoted back. It is in the run's prefix on every frame, so a
+ * quote would buy nothing and cost the window the run has to answer in, and
+ * leaving it out is also what lets this text be rebuilt from the event alone.
+ * No probability is quoted either: a number is journal material for a grader,
+ * and in front of a model it is a score to negotiate.
+ *
+ * The text still warns about the narrower refusal: repeated claims of work
+ * the record does not carry can end the run. Honest reports of work left
+ * undone remain valid answers when that is what the run can report.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export const claim = (): string =>
+  `Completion review — reconsider whether your completion answers the current request and whether any claimed actions or results are supported by this run's record.
+
+Answer the current request directly, keeping its requested format. A purely conversational answer needs no file edit, command, or verification. Do not add a work report when the person asked only for an answer.
+
+If you claim a command or result, use recorded evidence: make an allowed call needed to obtain it, or remove the unsupported claim and say plainly what remains unchecked when relevant. A completion that reports work honestly left undone is not refused for that alone.
+
+The next completion is judged again. A repeated claim of work this run never recorded can end the run with no answer.`