@inhuman.tools/turn 0.2.0 → 0.3.0

package/src/runtime/round-boundary.ts

@@ -0,0 +1,248 @@
+/** Detect positive continuation requests from settled facts; never infer completion from silence. */
+import {
+  RE_ACT_LOOP_INTENT_DETECTED_TRIGGER_STREAK_MAX,
+  THOUGHT_WITHOUT_ANSWER_STREAK_MAX,
+} from "@inhuman.tools/continuation";
+import { asSystemPrompt, prompt } from "@inhuman.tools/harness-commons";
+import {
+  callbackRequiredNote,
+  decideRound,
+  ReACTChunk,
+  SessionTurn,
+  TurnSteerChunk,
+  jobTriggersReactLoop,
+  jobContinuationOf,
+  type CompletionJob,
+  type ContinuationCandidate,
+  type ContinuationKind,
+  type IntentAssessment,
+  type RoundDecision,
+  type RoundGate,
+  type SessionRoot,
+} from "@inhuman.tools/harness-model/session";
+import { splitThink } from "@inhuman.tools/tool-call-normalize";
+
+import {
+  LENGTH_CONTINUE_NOTE,
+  RE_ACT_LOOP_INTENT_DETECTED_TRIGGER_NOTE,
+  THOUGHT_CONTINUE_NOTE,
+  thoughtWithoutAnswer,
+} from "./re-act-loop-intent-detected-trigger.js";
+import { CONTENT_FILTER_STOP, maxRoundsMessage, roundCapReached } from "./round-stop.js";
+import type { TurnIteratorHost } from "./turn-iterator.js";
+import { joinSystemNotes } from "../session/side-channel-reminder.js";
+
+const REPAIR_ATTEMPTS = 4;
+const THOUGHT_ATTEMPTS = THOUGHT_WITHOUT_ANSWER_STREAK_MAX;
+const INTENT_ATTEMPTS = RE_ACT_LOOP_INTENT_DETECTED_TRIGGER_STREAK_MAX;
+
+/** Only an actual successful work receipt resets repair budgets. Rejected calls are not progress. */
+function madeProgress(job: CompletionJob): boolean {
+  return job.responseWork.some((work) => jobTriggersReactLoop(work) && work.outcomeSnap?.ok === true);
+}
+
+function attempts(turn: SessionTurn, boundary: ReACTChunk, kind: ContinuationKind): number {
+  if (boundary.source != null && madeProgress(boundary.source)) return 0;
+  let count = 0;
+  for (let i = turn.doneWork.length - 1; i >= 0; i -= 1) {
+    const cell = turn.doneWork[i];
+    if (cell === boundary) continue;
+    if (cell instanceof TurnSteerChunk) break;
+    if (!(cell instanceof ReACTChunk)) continue;
+    const decision = cell.decision;
+    if (
+      decision?.kind === "advance" &&
+      decision.assessments.some(
+        (item) => item.cause.kind === kind && item.disposition === "eligible" && item.budget != null,
+      )
+    )
+      count += 1;
+    if (cell.source != null && madeProgress(cell.source)) break;
+  }
+  return count;
+}
+
+export function openCallbackRowsForTurn(session: SessionRoot, turn: SessionTurn) {
+  const future = new Set<string>();
+  const seen = new Set<SessionTurn>();
+  let unit = session.head;
+  while (unit != null && unit !== turn && !seen.has(unit)) {
+    seen.add(unit);
+    if (unit.agentRequestId.trim() !== "") future.add(unit.agentRequestId.trim());
+    if (!(unit.turnTail instanceof SessionTurn)) break;
+    unit = unit.turnTail;
+  }
+  return session.openCallbackRows().filter((row) => !future.has(row.requestId));
+}
+
+function liveCandidates(turn: SessionTurn, host: TurnIteratorHost): ContinuationCandidate[] {
+  const out: ContinuationCandidate[] = [];
+  const session = host.session;
+  const input = [
+    ...(session.steerTurn === turn ? session.steerQueue.map((row) => row.uuid) : []),
+    ...session.pendingNotices.map((note) => note.uuid),
+  ];
+  if (input.length > 0) out.push({ cause: { kind: "input", sources: input } });
+  const activating = host.notes
+    .peek(session.sessionId)
+    .filter((note) => note.mode === "activating" && note.text.trim() !== "");
+  if (activating.length > 0) out.push({ cause: { kind: "plugin", sources: activating.map((note) => note.id) } });
+  return out;
+}
+
+/** No effects except the bounded intent assessment. The caller commits the returned decision. */
+export async function assessBoundary(
+  turn: SessionTurn,
+  boundary: ReACTChunk,
+  host: TurnIteratorHost,
+  signal: AbortSignal,
+): Promise<RoundDecision> {
+  const source = boundary.source;
+  const pew = source?.expectation;
+  const candidates: ContinuationCandidate[] = [];
+  let gate: RoundGate | null = null;
+  const add = (kind: ContinuationKind, sources: readonly string[], limit?: number): void => {
+    candidates.push({
+      cause: { kind, sources },
+      ...(limit == null ? {} : { budget: { used: attempts(turn, boundary, kind), limit } }),
+    });
+  };
+  if (source == null) {
+    // Old documents had executable tokens with no recorded cause. Interpret only at this compatibility boundary.
+    if (!boundary.openPage)
+      add(boundary.truncated ? "length-repair" : boundary.intentContinue ? "intent" : "user", [boundary.uuid]);
+  } else if (pew != null && pew.outcome !== "successful") {
+    gate = {
+      reason: "provider-failed",
+      detail: `model round failed: ${pew.failReason?.trim() || pew.endDetail?.trim() || "no reason given"}`,
+    };
+  } else if (pew != null) {
+    const rejected = new Set(pew.responseCalls.filter((call) => call.dropReason !== "").map((call) => call.toolCallId));
+    const admitted = source.responseWork.filter((job) => !rejected.has(job.toolCallId));
+    const work = admitted.filter((job) => jobContinuationOf(job).kind === "observation");
+    const auxiliary = admitted.filter((job) => jobContinuationOf(job).kind === "auxiliary");
+    const speech = splitThink(pew.responseText).content.trim();
+    if (pew.finishReason === CONTENT_FILTER_STOP) {
+      gate = {
+        reason: "content-filter",
+        detail: "The provider's content filter stopped this response. Send another message to try again.",
+      };
+    } else {
+      if (work.length > 0)
+        add(
+          "observation",
+          work.map((job) => job.uuid),
+          madeProgress(source) ? undefined : REPAIR_ATTEMPTS,
+        );
+      if (rejected.size > 0) add("call-repair", [...rejected], REPAIR_ATTEMPTS);
+      if (pew.finishReason === "length" && work.length === 0 && rejected.size === 0) {
+        if (speech === "")
+          gate = {
+            reason: "length-no-answer",
+            detail:
+              "The model used up its output budget while reasoning and gave no answer. Raise the output limit or ask again more narrowly.",
+          };
+        else add("length-repair", [source.uuid], turn.lengthContinuations ?? 3);
+      } else if (work.length === 0 && rejected.size === 0) {
+        if (thoughtWithoutAnswer(pew)) add("thought-repair", [source.uuid], THOUGHT_ATTEMPTS);
+        else if (speech === "" && auxiliary.length > 0) {
+          add(
+            "auxiliary-repair",
+            auxiliary.map((job) => job.uuid),
+            REPAIR_ATTEMPTS,
+          );
+        }
+      }
+      const callbacks = openCallbackRowsForTurn(host.session, turn);
+      if (callbacks.length > 0)
+        add(
+          "callback",
+          callbacks.map((row) => row.requestId),
+          REPAIR_ATTEMPTS,
+        );
+    }
+  }
+  candidates.push(...liveCandidates(turn, host));
+  // A judge is needed only when no cheaper trigger already authorizes the next invocation.
+  const preliminary = decideRound(candidates, gate);
+  if (
+    pew != null &&
+    gate == null &&
+    preliminary.kind !== "advance" &&
+    splitThink(pew.responseText).content.trim() !== ""
+  ) {
+    if (boundary.intentAssessment == null) {
+      let assessment: IntentAssessment;
+      try {
+        assessment = await host.classifyIntent(pew, signal);
+      } catch (error) {
+        assessment = {
+          verdict: null,
+          status: "failed",
+          detail: error instanceof Error ? error.message : String(error),
+        };
+      }
+      if (!signal.aborted) boundary.intentAssessment = assessment;
+    }
+    if (boundary.intentAssessment?.verdict === "continue") add("intent", [source!.uuid], INTENT_ATTEMPTS);
+  }
+  // Input may arrive while the judge runs. Refresh event facts before the synchronous commit.
+  const stable = candidates.filter(
+    (candidate) => candidate.cause.kind !== "input" && candidate.cause.kind !== "plugin",
+  );
+  const finalCandidates = [...stable, ...liveCandidates(turn, host)];
+  if (gate == null && roundCapReached(turn) && decideRound(finalCandidates).kind === "advance") {
+    gate = { reason: "round-limit", detail: maxRoundsMessage(turn.maxRounds ?? 0) };
+  }
+  return decideRound(finalCandidates, gate, boundary.intentAssessment);
+}
+
+/** Every admitted cause contributes context. Ambient notes enrich a round but cannot authorize one. */
+export function boundaryNote(turn: SessionTurn, boundary: ReACTChunk | null, host: TurnIteratorHost) {
+  const kinds = new Set(boundary?.decision?.causes.map((cause) => cause.kind));
+  const notes = [];
+  if (kinds.has("length-repair")) notes.push(LENGTH_CONTINUE_NOTE);
+  if (kinds.has("thought-repair")) notes.push(THOUGHT_CONTINUE_NOTE);
+  if (kinds.has("intent")) notes.push(RE_ACT_LOOP_INTENT_DETECTED_TRIGGER_NOTE);
+  if (kinds.has("auxiliary-repair") && boundary?.source != null) {
+    const sources = new Set(
+      boundary.decision?.causes.filter((cause) => cause.kind === "auxiliary-repair").flatMap((cause) => cause.sources),
+    );
+    // Older committed decisions named the completion, rather than its auxiliary jobs.
+    const legacy = sources.has(boundary.source.uuid);
+    const auxiliaryNotes = new Set<string>();
+    for (const job of boundary.source.responseWork) {
+      if (!legacy && !sources.has(job.uuid)) continue;
+      const policy = jobContinuationOf(job);
+      if (policy.kind === "auxiliary" && policy.note != null) auxiliaryNotes.add(policy.note);
+    }
+    for (const note of auxiliaryNotes) notes.push(asSystemPrompt(note));
+  }
+  const callbacks = openCallbackRowsForTurn(host.session, turn);
+  if (callbacks.length > 0) notes.push(callbackRequiredNote(host.session.agent.spec.voidLegal, callbacks));
+  const pending = host.notes.peek(host.session.sessionId).filter((note) => note.text.trim() !== "");
+  const recorded = boundary?.contextNotes ?? [];
+  const context = [
+    ...recorded,
+    ...pending.filter((note) => !recorded.some((old) => old.id === note.id && old.text === note.text)),
+  ];
+  if (context.length > 0) notes.push(asSystemPrompt(context.map((note) => note.text).join("\n\n")));
+  return { note: notes.length > 0 ? joinSystemNotes(notes) : prompt.system``, noteIds: pending.map((note) => note.id) };
+}
+
+/** Re-read inbox facts at the commit site: an awaited detector must not seal over new input. */
+export function refreshBoundaryEvents(
+  turn: SessionTurn,
+  host: TurnIteratorHost,
+  decision: RoundDecision,
+): RoundDecision {
+  const candidates = decision.assessments.filter((item) => item.cause.kind !== "input" && item.cause.kind !== "plugin");
+  const live = [...candidates, ...liveCandidates(turn, host)];
+  const gate =
+    decision.kind === "blocked"
+      ? { reason: decision.reason, detail: decision.detail }
+      : roundCapReached(turn) && decideRound(live).kind === "advance"
+        ? { reason: "round-limit" as const, detail: maxRoundsMessage(turn.maxRounds ?? 0) }
+        : null;
+  return decideRound(live, gate, decision.intent);
+}

package/src/runtime/round-stop.ts

@@ -0,0 +1,24 @@
+/** Provider facts and admission limits. Continuation policy lives in round-boundary. */
+import type { SessionTurn } from "@inhuman.tools/harness-model/session";
+
+export const CONTENT_FILTER_STOP = "content_filter";
+export const LENGTH_STOP = "length";
+
+/** The receipt for a call that was not run. */
+export function refusalText(dropReason: string, filtered: boolean): string {
+  if (dropReason === "truncated") {
+    return "Your tool call was truncated (the response hit its output limit mid-call), so it was not run. Re-issue it.";
+  }
+  if (dropReason !== "") {
+    return "Your tool call's arguments could not be parsed, so it was not run. Re-issue it with valid arguments.";
+  }
+  return filtered ? "Not run: the provider's content filter stopped this response." : "Not run.";
+}
+
+export function maxRoundsMessage(limit: number): string {
+  return `Stopped after ${limit} model rounds: the round limit for this turn (maxRounds) is reached. Send another message to continue.`;
+}
+
+export function roundCapReached(turn: SessionTurn): boolean {
+  return turn.maxRounds != null && turn.maxRounds > 0 && turn.rounds >= turn.maxRounds;
+}

package/src/runtime/tool-call.ts

@@ -0,0 +1,10 @@
+import type { ResponseCall } from "@inhuman.tools/harness-model/session";
+import type { ToolCall } from "@inhuman.tools/tool-call-normalize";
+
+export function toolCallFromResponse(call: ResponseCall): ToolCall {
+  return {
+    id: call.toolCallId,
+    type: "function",
+    function: { name: call.name, arguments: JSON.stringify(call.args ?? {}) },
+  };
+}

package/src/runtime/turn-iterator.ts

@@ -0,0 +1,312 @@
+import { prompt } from "@inhuman.tools/harness-commons";
+import {
+  CompactJob,
+  CompletionExpectation,
+  CompletionJob,
+  DEFAULT_LENGTH_CONTINUATIONS,
+  ResponseCallOrder,
+  SystemToolJob,
+  parseCompactTrigger,
+  ProgrammaticJob,
+  ReACTChunk,
+  SessionRoot,
+  SessionTurn,
+  ToolCallJob,
+  TurnPromptChunk,
+  type TurnChunk,
+  type IntentAssessment,
+  type RoundGate,
+} from "@inhuman.tools/harness-model/session";
+import { type ToolCall } from "@inhuman.tools/tool-call-normalize";
+import { runInAction } from "mobx";
+
+import { ambientCutoff, ambientModel, type startAmbientCompact } from "./ambient-compact.js";
+import type { RuntimeDiagnostics, RuntimeNoteLog, TurnSettle } from "./ports.js";
+import { questionLineFromSpeech } from "./re-act-loop-intent-detected-trigger.js";
+import { assessBoundary, boundaryNote, refreshBoundaryEvents } from "./round-boundary.js";
+import { CONTENT_FILTER_STOP, maxRoundsMessage, refusalText, roundCapReached } from "./round-stop.js";
+import { toolCallFromResponse } from "./tool-call.js";
+import type { TurnResolvers } from "./turn-resolvers.js";
+import {
+  compactDecision,
+  historyBehind,
+  stampRetentionClock,
+  keepFloors,
+  stampCompactInputs,
+  sliceCompactZones,
+  tailCompactCandidate,
+  Transcript,
+} from "../context/index.js";
+import { isWorkReachable, turnLoopStopped } from "../session/cancel.js";
+import {
+  joinSystemNotes,
+  sealedActorRounds,
+  SIDE_CHANNEL_REMINDER_EVERY,
+  sideChannelReminderNote,
+} from "../session/side-channel-reminder.js";
+import { catalogOf } from "../tool-catalog/bindings.js";
+import { behaviorEntriesOf } from "../tool-catalog/catalog.js";
+
+/** Sequence rules depend on document data and explicit ports, never a daemon. */
+export interface TurnIteratorHost {
+  readonly session: SessionRoot;
+  readonly resolvers: TurnResolvers;
+  readonly notes: RuntimeNoteLog;
+  readonly diagnostics?: RuntimeDiagnostics;
+  readonly compactKeepTurns: number;
+  readonly hardCompactTrigger: string;
+  admit(call: ToolCall): ToolCallJob | ProgrammaticJob;
+  waitInbound(signal: AbortSignal): Promise<boolean>;
+  openRound(resumed: boolean): Promise<boolean>;
+  closeRound(settle: TurnSettle): Promise<void>;
+  classifyIntent(completion: CompletionExpectation, signal: AbortSignal): Promise<IntentAssessment>;
+  startAmbientCompact(options: Omit<Parameters<typeof startAmbientCompact>[0], "complete" | "inflight">): void;
+  /**
+   * The loop limits to record on this turn when it starts. Absent means unlimited rounds and
+   * the default number of length continuations.
+   */
+  loopLimits?(turn: SessionTurn): { readonly maxRounds: number; readonly lengthContinuations: number };
+  /** True for a third-party MCP server. Absent, or an unknown connection, is local and runs in order. */
+  remoteMcp?(connectionKey: string): boolean;
+}
+
+/**
+ * Append-and-iterate view of the persisted tape. The doneWork/queue
+ * split is the durable cursor; entering a cell is independent of resolving it.
+ * No snapshot iterator: appends are visited in this same pass.
+ */
+function* turnSequence(turn: SessionTurn, signal: AbortSignal): Generator<TurnChunk> {
+  while (!turnLoopStopped(turn, signal)) {
+    const cell = turn.take();
+    if (cell == null) return;
+    yield cell;
+  }
+}
+
+export async function iterateTurn(turn: SessionTurn, host: TurnIteratorHost, signal: AbortSignal): Promise<void> {
+  if (turnLoopStopped(turn, signal)) return;
+  const session = host.session;
+  const connectionId = session.kvs.connection?.trim() ?? "";
+  const model = session.kvs.model?.trim() ?? "";
+  // Recorded once: a live setting change does not move a turn that is already running.
+  turn.stampLoopLimits(host.loopLimits?.(turn) ?? { maxRounds: 0, lengthContinuations: DEFAULT_LENGTH_CONTINUATIONS });
+  for (const chunk of turnSequence(turn, signal)) {
+    if (turnLoopStopped(turn, signal)) return;
+    switch (true) {
+      case chunk instanceof CompactJob: {
+        await host.resolvers.compact(chunk, signal);
+        continue;
+      }
+      case chunk instanceof TurnPromptChunk:
+      case chunk instanceof ReACTChunk: {
+        if (chunk instanceof ReACTChunk) {
+          if (chunk.decision == null) {
+            if (!chunk.roundClosed) {
+              const pew = chunk.source?.expectation;
+              await host.closeRound(
+                pew?.outcome === "failed"
+                  ? { ok: false, error: pew.failReason ?? pew.endDetail ?? "model round failed" }
+                  : { ok: true, value: pew?.responseText || false },
+              );
+              if (turnLoopStopped(turn, signal)) return;
+              chunk.roundClosed = true;
+            }
+            const assessed = await assessBoundary(turn, chunk, host, signal);
+            if (turnLoopStopped(turn, signal)) return;
+            const decision = refreshBoundaryEvents(turn, host, assessed);
+            turn.commitBoundary(
+              chunk,
+              decision,
+              host.notes.peek(session.sessionId),
+              decision.reason === "awaiting-user" && chunk.source != null
+                ? questionLineFromSpeech(chunk.source.expectation.responseText)
+                : "",
+            );
+          }
+          if (chunk.decision?.kind !== "advance") continue;
+          if (chunk.decision.nextRoundId != null) continue;
+        }
+        if (turnLoopStopped(turn, signal)) return;
+        if (connectionId === "") {
+          blockAdmission(turn, chunk, {
+            reason: "no-connection",
+            detail: "no connection is configured for this session",
+          });
+          return;
+        }
+        if (chunk instanceof ReACTChunk && !isWorkReachable(session, turn)) return;
+        if (roundCapReached(turn)) {
+          blockAdmission(turn, chunk, { reason: "round-limit", detail: maxRoundsMessage(turn.maxRounds ?? 0) });
+          return;
+        }
+        if (chunk instanceof ReACTChunk) chunk.waitingFor = "inbound";
+        if (!(await host.waitInbound(signal)) || turnLoopStopped(turn, signal)) return;
+        const resumed = turn.doneWork.some(
+          (done) => done !== chunk && (done instanceof TurnPromptChunk || done instanceof ReACTChunk),
+        );
+        if (chunk instanceof ReACTChunk) chunk.waitingFor = "round-hook";
+        const opened = await host.openRound(resumed);
+        if (turnLoopStopped(turn, signal)) return;
+        if (!opened) {
+          blockAdmission(turn, chunk, { reason: "plugin-refused", detail: "a plugin refused to open the round" });
+          return;
+        }
+        turn.claimApprovalNotes();
+        session.claimSteers(turn);
+        session.claimNotices(turn);
+        const messages = historyBehind(turn, compactRead(host.compactKeepTurns, session.kvs));
+        const completion = new CompletionExpectation({
+          promptText: chunk instanceof TurnPromptChunk ? turn.completionMessage : prompt.user``,
+          connectionId,
+          model,
+          messages,
+          reasoningEffort: session.agent.spec.reasoningEffort,
+        });
+        const enrichment = boundaryNote(turn, chunk instanceof ReACTChunk ? chunk : null, host);
+        completion.systemNote = enrichment.note;
+        const frozenNames = turn.tools.entries.map((entry) => entry.name);
+        completion.systemNote = joinSystemNotes([
+          completion.systemNote,
+          sideChannelReminderNote(
+            sealedActorRounds(turn),
+            SIDE_CHANNEL_REMINDER_EVERY,
+            frozenNames.length > 0 ? frozenNames : null,
+          ),
+        ]);
+        runInAction(() => {
+          const next = new CompletionJob({ expectation: completion, managesResponse: true });
+          turn.admitRound(chunk instanceof ReACTChunk ? chunk : null, next);
+          host.notes.consume(session.sessionId, enrichment.noteIds, turn.uuid);
+        });
+        // R3: read the live inputs once (wall clock, prior warmUntilMs, estimated savings) and record them.
+        stampRetentionClock(completion);
+        host.diagnostics?.step?.(`turn round ${turn.doneWork.length + turn.queue.length} ${turn.prompt}`);
+        host.diagnostics?.trace?.("harness:turn", `round ${turn.uuid} queued=${turn.queue.length}`);
+        break;
+      }
+      case chunk instanceof CompletionJob: {
+        const pew = chunk.expectation;
+        if (pew == null) break;
+        if (!pew.isDone) await host.resolvers.completion(chunk, signal);
+        if (turnLoopStopped(turn, signal)) return;
+        if (chunk.responseExpanded) break;
+        if (pew.outcome !== "successful") {
+          turn.finishResponseExpansion(chunk);
+          break;
+        }
+        const filtered = pew.finishReason === CONTENT_FILTER_STOP;
+        const refusals = pew.responseCalls.filter((call) => filtered || call.dropReason !== "");
+        const calls = pew.responseCalls.filter((call) => !refusals.includes(call)).map(toolCallFromResponse);
+        const order = new ResponseCallOrder({
+          entryClass: (name) => catalogOf(session)?.catalogEntry(name)?.class,
+          remoteMcp: (key) => host.remoteMcp?.(key) ?? false,
+        });
+        let cursor = 0;
+        const record = (make: () => ToolCallJob | ProgrammaticJob) =>
+          runInAction(() => {
+            const existing = chunk.responseWork[cursor++];
+            if (existing != null) {
+              order.place(existing);
+              return existing;
+            }
+            const tool = make();
+            order.place(tool);
+            turn.recordResponseWork(chunk, tool);
+            return tool;
+          });
+        for (const call of refusals) {
+          record(
+            () =>
+              new SystemToolJob({
+                toolCallId: call.toolCallId,
+                name: call.name,
+                argsJson: "{}",
+                humanApprove: false,
+                completed: true,
+                continuationJson: JSON.stringify({ kind: "none" }),
+                triggersReactLoop: false,
+                outcomeJson: JSON.stringify({ ok: false, text: refusalText(call.dropReason, filtered) }),
+              }),
+          );
+        }
+        // Early metadata must settle before other calls become reachable. The durable cursor
+        // makes re-entry safe even when a park happens in this wait.
+        const recorded = new Map(chunk.responseWork.map((job, index) => [job.toolCallId, { job, index }]));
+        const isEarly = (call: ToolCall) => {
+          const prior = recorded.get(call.id)?.job;
+          if (prior != null) return prior.isSideChannel;
+          const entry =
+            catalogOf(session)?.catalogEntry(call.function.name) ??
+            behaviorEntriesOf(session).find((row) => row.wireName === call.function.name);
+          return entry?.isSideChannel === true;
+        };
+        const early = calls
+          .filter(isEarly)
+          .sort((a, b) => (recorded.get(a.id)?.index ?? Infinity) - (recorded.get(b.id)?.index ?? Infinity));
+        const ordinary = calls.filter((candidate) => !isEarly(candidate));
+        for (const call of early) {
+          const tool = record(() => host.admit(call));
+          if (!tool.completed && (await host.resolvers.work(tool, signal)) === "aborted") return;
+          if (turnLoopStopped(turn, signal)) return;
+        }
+        for (const call of ordinary) {
+          record(() => host.admit(call));
+        }
+        const read = compactRead(host.compactKeepTurns, session.kvs);
+        const eat = Transcript.fromCells(historyBehind(turn, read));
+        const zones = sliceCompactZones(eat, keepFloors(turn.contextNeed, session.kvs, false, read.configFloor));
+        const zoneSlice = { prefix: zones.prefix, keep: zones.keep };
+        const forced = tailCompactCandidate(turn, parseCompactTrigger(host.hardCompactTrigger), zoneSlice);
+        let forcedCompact: CompactJob | null = null;
+        if (forced != null) {
+          const job = new CompactJob({ reason: forced });
+          // F8: the cut's inputs are facts of this job from here on, not live settings.
+          stampCompactInputs(job, read.configFloor, session.kvs);
+          forcedCompact = job;
+        }
+        const option = compactDecision(turn, zoneSlice);
+        const cutoff = option == null ? null : ambientCutoff(zones.keep);
+        const summarizer = ambientModel(session.kvs, model);
+        if (option != null && cutoff != null && connectionId !== "" && summarizer !== "") {
+          host.startAmbientCompact({
+            home: turn,
+            cutoff,
+            prefix: zones.prefix,
+            focus: option.focus,
+            connectionId,
+            model: summarizer,
+          });
+        }
+        turn.finishResponseExpansion(chunk, forcedCompact);
+        break;
+      }
+      case chunk instanceof ToolCallJob:
+      case chunk instanceof ProgrammaticJob: {
+        host.diagnostics?.trace?.(
+          "harness:turn",
+          `work ${turn.uuid} ${chunk instanceof ToolCallJob ? chunk.name : "scheme"} ${chunk.toolCallId}`,
+        );
+        if (!chunk.completed && (await host.resolvers.work(chunk, signal)) === "aborted") return;
+        if (turnLoopStopped(turn, signal)) return;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+}
+
+function blockAdmission(turn: SessionTurn, chunk: TurnPromptChunk | ReACTChunk, gate: RoundGate): void {
+  runInAction(() => {
+    if (chunk instanceof ReACTChunk && chunk.decision != null) {
+      turn.commitBoundary(chunk, { ...chunk.decision, kind: "blocked", ...gate }, chunk.contextNotes, "");
+    } else turn.stopLoop(gate.detail);
+  });
+}
+
+function compactRead(
+  configFloor: number,
+  kv: Readonly<Record<string, string>>,
+): { readonly configFloor: number; readonly kv: Readonly<Record<string, string>> } {
+  return { configFloor: Math.max(configFloor, 1), kv };
+}

package/src/runtime/turn-resolvers.ts

@@ -0,0 +1,43 @@
+import type { CompactJob, CompletionJob, ProgrammaticJob, ToolCallJob } from "@inhuman.tools/harness-model/session";
+import type { CompleteRequest, CompleteResult } from "@inhuman.tools/harness-provider-sdk";
+
+import { runCompactJob, type CompactHost } from "../session/compact-actor.js";
+
+/** Resolution changes the work node. The iterator reads that node afterward. */
+export interface TurnResolvers {
+  completion(job: CompletionJob, signal: AbortSignal): Promise<void>;
+  work(job: ToolCallJob | ProgrammaticJob, signal: AbortSignal): Promise<"settled" | "aborted">;
+  compact(job: CompactJob, signal: AbortSignal): Promise<void>;
+}
+
+export interface TurnResolverHost {
+  complete(request: CompleteRequest): Promise<CompleteResult>;
+  join(job: ToolCallJob | ProgrammaticJob, signal: AbortSignal): Promise<"settled" | "aborted">;
+  compactHost(): CompactHost;
+}
+
+/** Production effects; tests substitute this whole strategy without a daemon. */
+export function createTurnResolvers(host: TurnResolverHost): TurnResolvers {
+  return {
+    async completion(job, signal) {
+      const pew = job.expectation;
+      if (pew == null || pew.isDone) return;
+      try {
+        await host.complete({
+          connectionId: pew.connectionId,
+          model: pew.model,
+          promptText: pew.userPrompt,
+          round: pew,
+          signal,
+        });
+      } catch (error) {
+        // A park aborts with the reason "park" and leaves the round open for the next wrap.
+        if (!signal.aborted && pew.outcome == null && error !== "park") {
+          pew.fail("crash", error instanceof Error ? error.message : String(error), "null");
+        }
+      }
+    },
+    work: (job, signal) => host.join(job, signal),
+    compact: (job, signal) => runCompactJob(job, host.compactHost(), signal),
+  };
+}

package/src/session/cancel.ts

@@ -2,12 +2,20 @@
  * Stop predicate and leftover rejection for a turn. Accepted-work Calls stay.
  * In-flight BODY abort is the caller's `abort`.
  */
-import { ApprovableJob, CallJob, SessionTurn } from "@inhuman.tools/harness-model";
-import { walkWork } from "@inhuman.tools/plexus-expectations";
+import { ApprovableJob, CallJob, SessionTurn, type SessionRoot } from "@inhuman.tools/harness-model/session";
+import { walkWork, type WorkContainer } from "@inhuman.tools/plexus-expectations";
 
 import { shouldSkipTurnCancel } from "../agent-calls/acceptance.js";
 import { type CallsCatalog } from "../agent-calls/index.js";
-import { cancelUnstartedTool } from "../tool-runtime/index.js";
+import { cancelUnstartedTool } from "../tool-runtime/approval/approved.js";
+
+/** Canonical work ownership includes nested and retained background turns, not just head ancestry. */
+export function isWorkReachable(session: SessionRoot, work: WorkContainer): boolean {
+  for (const node of walkWork(session)) {
+    if (node === work) return true;
+  }
+  return false;
+}
 
 export function turnLoopStopped(turn: SessionTurn, signal: AbortSignal): boolean {
   return signal.aborted || turn.reducerExited || turn.cancelRequested;