@visual-z/xeno 0.8.4 → 0.9.0

package/src/core/progress.ts

@@ -1,150 +0,0 @@
-/**
- * D9 / research M.4: an anti-stall signal, not a judgment of task completion.
- * Novelty belongs to observed content and executed checks, never note wording,
- * event IDs, or timestamps. The full ledger is rebuilt from the active log path;
- * its carried handoff view may be paged like the other structural state (D20).
- */
-import type { LineRange, LogEvent } from "./events.ts";
-import { isProcessReceipt } from "./process-receipt.ts";
-
-export type ProgressEvidence = (
-  | { kind: "read"; sha256: string; ranges?: readonly LineRange[]; observation_sha256?: string }
-  | { kind: "observation"; sha256: string }
-  | { kind: "check"; command: string; gate?: string; workspace_sha256?: string }
-) & { source: { node: number; event_id: string } };
-
-/** Test coverage without expanding arbitrarily long ranges into line numbers. */
-function hasUnseenLines(requested: readonly LineRange[], observed: readonly LineRange[]): boolean {
-  const sorted = [...observed].sort((a, b) => a[0] - b[0]);
-  return requested.some(([start, end]) => {
-    let next = start;
-    for (const [low, high] of sorted) {
-      if (high < next) continue;
-      if (low > next) return true;
-      if (high >= end) return false;
-      next = high + 1;
-    }
-    return next <= end;
-  });
-}
-
-/**
- * A file version's fingerprint in the observation set. Keyed by digest alone:
- * the same bytes under another path are not new work either.
- */
-const versionKey = (_path: string, sha256: string): string => `version:${sha256}`;
-
-export function deriveProgress(
-  previous: readonly ProgressEvidence[], events: readonly LogEvent[], node: number,
-  eligibleChecks: ReadonlySet<string>,
-): { evidence: ProgressEvidence[]; progressed: boolean } {
-  const evidence = [...previous];
-  const reads = new Map<string, Extract<ProgressEvidence, { kind: "read" }>[]>();
-  const observations = new Set<string>();
-  const checks = new Set<string>();
-  // A named gate has one status per workspace. Changing its arguments does not
-  // make another gate, and cannot keep the loop alive by spelling a pass anew.
-  const checkKey = (command: string, gate?: string, workspace?: string): string =>
-    JSON.stringify([gate === undefined ? "command" : "gate", gate ?? command, workspace ?? null]);
-  for (const item of previous) {
-    if (item.kind === "read") {
-      const seen = reads.get(item.sha256) ?? [];
-      seen.push(item);
-      reads.set(item.sha256, seen);
-      if (item.observation_sha256 !== undefined) observations.add(item.observation_sha256);
-      // A version read before a cut is as known as one read in this segment.
-      observations.add(versionKey("", item.sha256));
-    } else if (item.kind === "observation") observations.add(item.sha256);
-    else checks.add(checkKey(item.command, item.gate, item.workspace_sha256));
-  }
-  let progressed = false;
-  const calls = new Map<string, string>();
-  for (const event of events) {
-    if (event.t === "assistant") {
-      for (const block of event.blocks) if (block.type === "tool_use") calls.set(block.call_id, block.name);
-    }
-    if (event.t !== "tool_result") continue;
-    const name = calls.get(event.call_id);
-    calls.delete(event.call_id);
-    const effect = event.effect;
-    // A failed tool that never ran observed nothing. A command that ran and
-    // exited nonzero did observe something (S.6 item 2): its output counts
-    // like any other, but it is never a check.
-    if (!event.ok && effect?.kind !== "command") continue;
-    const source = { node, event_id: event.id };
-    const observation = event.observation_sha256 ?? event.content_ref?.sha256 ?? event.content_sha256;
-    if (effect?.kind === "read" && effect.sha256 !== "") observations.add(versionKey(effect.path, effect.sha256));
-    if (effect?.kind === "read" && effect.sha256 !== "") {
-      const seen = reads.get(effect.sha256) ?? [];
-      const novel = !seen.some((r) => r.ranges === undefined) &&
-        (effect.ranges === undefined || hasUnseenLines(effect.ranges, seen.flatMap((r) => r.ranges ?? [])));
-      if (novel) {
-        const item: Extract<ProgressEvidence, { kind: "read" }> = {
-          kind: "read", sha256: effect.sha256, source,
-          ...(effect.ranges === undefined ? {} : { ranges: effect.ranges }),
-          ...(observation === undefined ? {} : { observation_sha256: observation }),
-        };
-        evidence.push(item);
-        reads.set(effect.sha256, [...seen, item]);
-        // Whole-file hashes can change outside the returned range. Such a read
-        // extends coverage for that version but unchanged bytes are not novelty.
-        if (observation === undefined || !observations.has(observation)) progressed = true;
-        if (observation !== undefined) observations.add(observation);
-      }
-    } else if (effect?.kind === "command") {
-      // D9 revisions (2026-09-29 and S.6 item 2, user-approved): output never
-      // seen before is a new observation, exactly as for read/grep, whatever
-      // the exit code. A model exploring with `sed -n` or `grep` in the shell
-      // is gathering evidence too, and a grep with no match exits 1 after the
-      // earlier pipeline stages printed what was asked for. The digest
-      // excludes wall time, so an unchanged `git status` or the same failure
-      // repeats and stalls.
-      if (observation !== undefined && !observations.has(observation)) {
-        observations.add(observation);
-        evidence.push({ kind: "observation", sha256: observation, source });
-        progressed = true;
-      }
-      const key = checkKey(effect.cmd, effect.gate, effect.workspace_sha256);
-      if (event.ok && effect.exit === 0 && !checks.has(key)) {
-        checks.add(key);
-        evidence.push({ kind: "check", command: effect.cmd, source,
-          ...(effect.gate === undefined ? {} : { gate: effect.gate }),
-          ...(effect.workspace_sha256 === undefined ? {} : { workspace_sha256: effect.workspace_sha256 }) });
-        // Remember even unclaimed successes. A later model note cannot turn a
-        // rerun of old evidence into a fresh completion by giving it a new name.
-        if (eligibleChecks.has(event.id)) progressed = true;
-      }
-    } else if (effect?.kind === "edit") {
-      // D9 revision (2026-09-29, user-approved): a file version no one has
-      // seen before is new evidence -- it is how implementation work shows up.
-      // Versions already seen anywhere (read, or either side of an edit) do
-      // not count, so an A->B->A rewrite loop still stalls.
-      // Both sides become durable evidence: the ledger is all a later
-      // derivation sees, and a version seen only as "before" must still be
-      // recognised when the file is edited back to it.
-      for (const [sha, isAfter] of [[effect.sha256_before, false], [effect.sha256_after, true]] as const) {
-        if (sha === null) continue;
-        const key = versionKey(effect.path, sha);
-        if (observations.has(key)) continue;
-        observations.add(key);
-        evidence.push({ kind: "observation", sha256: key, source });
-        if (isAfter) progressed = true;
-      }
-    } else if (isProcessReceipt(event.data) && !event.data.replayed && event.data.output !== undefined && event.data.output.bytes > 0 &&
-        !observations.has(event.data.output.sha256)) {
-      // A managed command can produce useful evidence before it exits. Credit
-      // raw captured bytes, never its elapsed header, changing ID or poll count.
-      const sha256 = event.data.output.sha256;
-      observations.add(sha256);
-      evidence.push({ kind: "observation", sha256, source });
-      progressed = true;
-    } else if ((name === "grep" || name === "find" || name === "ls" || name === "query") &&
-        observation !== undefined && (event.content_ref?.bytes ?? event.content.length) > 0 &&
-        !observations.has(observation)) {
-      observations.add(observation);
-      evidence.push({ kind: "observation", sha256: observation, source });
-      progressed = true;
-    }
-  }
-  return { evidence, progressed };
-}

package/src/core/project.ts

@@ -1,431 +0,0 @@
-/**
- * projectContext: log -> what the model sees.
- *
- * Pure. The whole architecture rests on this being a function rather than a
- * mutable array: the log is the truth, the context is one recomputable projection
- * of it, so a bad projection is a bug you fix and re-run rather than information
- * you destroyed.
- *
- * Two properties worth stating because tests pin them:
- *
- *   IDENTITY. With no handoff, the projection is the identity mapping of harness
- *   events onto messages. Segment 0 therefore behaves exactly like a harness with
- *   no context management at all, which is what makes the design adoptable in
- *   stages -- nothing is paid for until a boundary actually fires.
- *
- *   APPEND-ONLY WITHIN A SEGMENT. Appending an event only appends to the
- *   projection; it never rewrites an earlier message. That is what keeps the
- *   prompt prefix byte-stable, so every turn reads the whole accumulated prefix
- *   from cache and writes only the delta. In-place eviction would invalidate the
- *   prefix on every request and never amortise the write cost -- the failure mode
- *   Beyond Compaction (arXiv:2606.11213) documents for incremental eviction.
- *
- * The message shape below is structurally the Anthropic Messages shape, which is
- * the target wire format. It is declared locally rather than imported so the core
- * carries no SDK dependency; mapping to other providers belongs in an adapter,
- * not here.
- */
-
-import type { LogEvent, AssistantBlock } from "./events.ts";
-import { assertNever } from "./exhaustive.ts";
-import type { ImageContent } from "./images.ts";
-import { type Handoff, emitHandoff } from "./handoff.ts";
-import { diagnosticContent } from "./tool-contract.ts";
-
-/** O.8: persist the interpretation used to replay a frozen request. */
-export const PROJECTION_VERSION = 1;
-
-export type ContentBlock =
-  | ImageContent
-  | { type: "text"; text: string; wire?: unknown }
-  /**
-   * The provider's own thinking block, replayed verbatim. It is carried as
-   * opaque rather than reconstructed because the API rejects modified blocks,
-   * and a reconstructed one would lose the signature the next request needs.
-   */
-  | { type: "thinking"; raw: unknown }
-  | { type: "tool_use"; id: string; name: string; input: unknown; wire?: unknown }
-  | { type: "tool_result"; tool_use_id: string; content: string; is_error?: boolean };
-
-export interface Message {
-  role: "user" | "assistant";
-  content: ContentBlock[];
-}
-
-/**
- * System prompt and tool definitions. Must be byte-identical across every segment
- * (decision D6): they render at the front of the prefix, so any change there
- * invalidates the cache for the entire conversation. The non-obvious consequence
- * is that project context files must NOT be re-read into `system` at a boundary --
- * they belong in the handoff instead.
- */
-export interface FrozenPrefix {
-  system: string;
-  tools: readonly unknown[];
-}
-
-export interface ProjectInput {
-  /** Diagnostic only; trace never enters provider messages. */
-  trace?: boolean;
-  frozen: FrozenPrefix;
-  /** Previous segment's handoff, or null for segment 0. */
-  handoff: Handoff | null;
-  events: readonly LogEvent[];
-  /** Source locations and versioned recovery guidance; workspace search does not index the log. */
-  logHint?: { manifestPath: string; segmentPath: string };
-}
-
-export interface ProjectResult {
-  provenance?: { version: number; messages: string[][]; omitted: string[] };
-  system: string;
-  tools: readonly unknown[];
-  messages: Message[];
-  /**
-   * Pairing violations. A tool_use with no matching tool_result is a 400 from the
-   * API, so it is reported here -- at the pure boundary, where it is debuggable --
-   * rather than being discovered as a request failure.
-   */
-  violations: ProjectViolation[];
-}
-
-export interface ProjectViolation {
-  code: "UNPAIRED_TOOL_USE" | "ORPHAN_TOOL_RESULT" | "EMPTY_PROJECTION" | "DUPLICATE_TOOL_USE" | "EMPTY_TOOL_USE_ID";
-  detail: string;
-}
-
-/**
- * D5: a receipt identifies exactly one call in its assistant batch. Validate
- * before either the projection's Set or the runtime's scheduling Map can erase
- * a collision; repairing IDs would invent provider protocol history.
- */
-export function toolCallIdentityViolations(blocks: readonly AssistantBlock[]): ProjectViolation[] {
-  const violations: ProjectViolation[] = [], seen = new Map<string, number>();
-  for (const [index, block] of blocks.entries()) {
-    if (block.type !== "tool_use") continue;
-    if (block.call_id.trim().length === 0) {
-      violations.push({ code: "EMPTY_TOOL_USE_ID", detail: `tool_use block ${index} has an empty call_id` });
-      continue;
-    }
-    const previous = seen.get(block.call_id);
-    if (previous !== undefined) {
-      violations.push({ code: "DUPLICATE_TOOL_USE", detail: `tool_use block ${index} repeats the call_id of block ${previous}` });
-    } else seen.set(block.call_id, index);
-  }
-  return violations;
-}
-
-/**
- * The only event types that replay as messages.
- *
- * Model-annotated events (claim, decision, pitfall, ...) are deliberately absent.
- * They are a sidecar index over tool calls the model already made, so the
- * tool_use/tool_result pair is what replays; including the annotation too would
- * show the model its own notes twice. Within a segment the model sees its raw tool
- * calls; across a boundary it sees them distilled into the handoff.
- *
- * `cut` is absent for a different reason: it is a boundary marker about the log,
- * not a thing that happened in the conversation.
- *
- * `rewind` is here conditionally, and it is the one event whose replayability
- * is a property of the event rather than of its type. After a "both" rewind
- * the context and the disk agree, so saying anything would carry the undone
- * work back in another form. After a partial one they disagree, and a model
- * planning against the wrong picture is the whole failure mode -- so it is
- * told, with paths.
- *
- * `interrupt` is a one-line harness note after the cancelled user message,
- * not a new role: the model has to tell "asked and withdrew" from "asked
- * two things". It is a following message rather than a mutation of the user
- * turn so appending the event only appends to the projection (P7).
- */
-type ReplayEvent = Extract<LogEvent, { t: "acceptance_contract" | "acceptance_decision" | "user" | "user_bash" | "guidance" | "interrupt" | "assistant" | "tool_result" | "rewind" | "extension" }>;
-
-function replayable(e: LogEvent): e is ReplayEvent {
-  if (e.t === "tool_result" && (e.parent_call_id !== undefined || e.origin === "extension")) return false;
-  if (e.t === "acceptance_contract" || e.t === "acceptance_decision") return true;
-  if (e.t === "extension") return e.inContext;
-  if (e.t === "user_bash") return !e.excludeFromContext;
-  if (e.t === "rewind") return e.mode !== "both";
-  return e.t === "user" || e.t === "guidance" || e.t === "interrupt" || e.t === "assistant" || e.t === "tool_result";
-}
-
-/**
- * The one thing a divergence message must produce.
- *
- * Named because it is the contract, not decoration: it is the automated form
- * of the remedy Claude Code leaves to the person to remember after a partial
- * restore, and a test asserting the message happened has to assert something
- * only the message can say.
- */
-export const REREAD_INSTRUCTION =
-  "Re-read any file before editing it. Do not rely on what earlier messages say its contents are.";
-
-/**
- * What an interrupt has to tell the model, as one line.
- *
- * A cancelled generation was never delivered, so the projection must not
- * invent assistant text; the note is the whole of what the harness observed.
- * Same role as the user turn so we do not mint a role the wire format lacks.
- */
-export const INTERRUPT_NOTE =
-  "The user cancelled this turn before a reply was delivered.";
-
-/**
- * What a partial rewind has to tell the model, as plain prose.
- *
- * Prose rather than a structured block because it is addressed to the model,
- * and the one thing it must produce is a re-read before an edit. That
- * instruction is Claude Code's documented remedy for the same desync, left
- * there to the person to remember; the paths make it actionable.
- */
-export function renderRewindMessage(e: Extract<LogEvent, { t: "rewind" }>): Message {
-  const where = e.prompt ? `the point where you were asked: ${e.prompt}` : "an earlier point";
-  let lines: string[];
-  switch (e.mode) {
-    case "files":
-      lines = [
-        `The workspace was moved back to ${where}.`,
-        "",
-        "Your messages above still describe edits that are no longer on disk.",
-        "The conversation was not moved; only the files were.",
-      ];
-      break;
-    case "context":
-      lines = [
-        `This conversation was moved back to ${where}.`,
-        "",
-        "The workspace was NOT moved. Files exist that nothing above accounts",
-        "for, because the turns that made them are no longer in this context.",
-      ];
-      break;
-    case "both":
-      // Unreachable through the projection, which filters "both" out before
-      // getting here. Spelled out rather than folded into the other branch:
-      // falling through would have produced a message telling the model the
-      // two had diverged when the entire point of "both" is that they did
-      // not, and nothing would have failed.
-      throw new Error("a \"both\" rewind has nothing to tell the model: context and disk agree");
-    default:
-      return assertNever(e.mode, "renderRewindMessage");
-  }
-
-  if (e.divergence.length > 0) {
-    lines.push("", "Where they disagree:");
-    for (const path of e.divergence) lines.push(`  ${path}`);
-  }
-  lines.push("", REREAD_INSTRUCTION);
-
-  return { role: "user", content: [{ type: "text", text: lines.join("\n") }] };
-}
-
-/**
- * Render the handoff as the opening user message of a new segment.
- *
- * It is a user message rather than part of `system` for two reasons: `system` has
- * to stay byte-stable (D6), and a handoff is untrusted-ish derived content, not an
- * operator instruction -- it does not belong in the operator channel.
- */
-export function renderHandoffMessage(
-  handoff: Handoff,
-  logHint?: { manifestPath: string; segmentPath: string },
-): Message {
-  const yaml = emitHandoff(handoff);
-
-  const parts = [
-    "You are continuing earlier work in a new context window.",
-    "",
-    "The state below was derived mechanically from the session log -- it is not a",
-    "summary and nothing was paraphrased. Fields that are absent were absent from",
-    "the log, not judged unimportant.",
-    "",
-    "```yaml",
-    yaml.trimEnd(),
-    "```",
-  ];
-
-  if (logHint) {
-    parts.push(
-      "",
-      "The full log is on disk and nothing has been deleted from it. When you need a",
-      "detail this state does not carry, read it rather than guessing:",
-      `  - segment index: ${logHint.manifestPath}`,
-      `  - previous segment: ${logHint.segmentPath}`,
-      "Each line is one JSON event. Recover originals using the declared tools' contracts; if evidence is inaccessible, state the gap instead of guessing.",
-    );
-  }
-
-  const unverified = handoff.state.unverified_claims.length;
-  if (unverified > 0) {
-    parts.push(
-      "",
-      `${unverified} earlier completion ${unverified === 1 ? "claim was" : "claims were"} not matched`,
-      "to a passing command in the log. They are listed under state.unverified_claims",
-      "and must be treated as NOT done.",
-    );
-  }
-
-  if (handoff.file_anchors.length > 0) {
-    parts.push(
-      "",
-      "file_anchors records the digest each file had when it was last touched. Re-read",
-      "a file before relying on it; if the digest differs, the environment changed",
-      "underneath this state.",
-    );
-  }
-
-  return { role: "user", content: [{ type: "text", text: parts.join("\n") }] };
-}
-
-export function projectContext(input: ProjectInput): ProjectResult {
-  const violations: ProjectViolation[] = [];
-  const messages: Message[] = [];
-  const sources: string[][] = [];
-  const append = (message: Message, ids: string[]) => { messages.push(message); sources.push(ids); };
-
-  if (input.handoff) {
-    append(renderHandoffMessage(input.handoff, input.logHint), [`handoff:${input.handoff.predecessor?.node ?? "root"}`]);
-  }
-
-  const events = input.events.filter(replayable);
-
-  // Tool results are buffered so that every result for one assistant turn lands in
-  // a SINGLE user message. Splitting them across messages teaches the model to stop
-  // issuing parallel calls, which is a silent, permanent capability regression.
-  let pending: ContentBlock[] = [];
-  let pendingSources: string[] = [];
-  const flushPending = () => {
-    if (pending.length > 0) {
-      append({ role: "user", content: pending }, pendingSources);
-      pending = [];
-      pendingSources = [];
-    }
-  };
-
-  /** tool_use ids emitted by the most recent assistant turn and not yet answered. */
-  let awaiting = new Set<string>();
-
-  for (const e of events) {
-    if (e.t === "acceptance_contract" || e.t === "acceptance_decision") {
-      flushPending();
-      if (awaiting.size) violations.push({ code: "UNPAIRED_TOOL_USE", detail: `acceptance event ${e.id} follows unanswered tools` });
-      append({ role: "user", content: [{ type: "text", text: e.t === "acceptance_contract"
-        ? `Declared acceptance contract (execution success alone does not satisfy it): ${JSON.stringify(e.contract)}`
-        : `User accepted criterion ${e.criterion} of contract ${e.contract_id} for request ${e.request}.` +
-          (e.target_binding ? ` Bound to runtime instance ${e.target_binding}, observation ${e.target_observation}. Later runtime changes invalidate this acceptance.` : "") }] }, [e.id]);
-      continue;
-    }
-    if (e.t === "extension") {
-      flushPending();
-      if (awaiting.size) violations.push({ code: "UNPAIRED_TOOL_USE", detail: `custom message ${e.id} follows unanswered tool_use ${[...awaiting].join(", ")}` });
-      append({ role: "user", content: [{ type: "text", text: e.content }] }, [e.id]);
-      continue;
-    }
-    if (e.t === "user_bash") {
-      flushPending();
-      append({ role: "user", content: [{ type: "text", text: `User ran: ${e.command}\n${e.content}` }] }, [e.id]);
-      continue;
-    }
-    if (e.t === "rewind") {
-      // Flushed first for the same reason a user turn is: it opens a user
-      // message, and a pending tool_result batch has to close before it.
-      flushPending();
-      append(renderRewindMessage(e), [e.id]);
-      continue;
-    }
-    if (e.t === "user" || e.t === "guidance") {
-      flushPending();
-      if (awaiting.size > 0) {
-        violations.push({
-          code: "UNPAIRED_TOOL_USE",
-          detail: `user turn ${e.id} follows unanswered tool_use ${[...awaiting].join(", ")}`,
-        });
-        awaiting = new Set();
-      }
-      append({ role: "user", content: [...(e.text || e.t === "guidance" || !e.images?.length ? [{ type: "text" as const, text: e.text }] : []),
-        ...(e.t === "user" ? (e.images ?? []).map(image => ({ type: "image" as const, image })) : [])] }, [e.id]);
-      continue;
-    }
-    if (e.t === "interrupt") {
-      // Own message so the preceding user turn stays byte-stable (P7). A
-      // look-ahead mutation of that turn would rewrite it once a later
-      // event (tool_use, another user) was already projected after it.
-      flushPending();
-      append({ role: "user", content: [{ type: "text", text: INTERRUPT_NOTE }] }, [e.id]);
-      continue;
-    }
-
-    if (e.t === "assistant") {
-      flushPending();
-      violations.push(...toolCallIdentityViolations(e.blocks).map(violation => ({
-        ...violation, detail: `assistant turn ${e.id}: ${violation.detail}`,
-      })));
-      if (awaiting.size > 0) {
-        violations.push({
-          code: "UNPAIRED_TOOL_USE",
-          detail: `assistant turn ${e.id} follows unanswered tool_use ${[...awaiting].join(", ")}`,
-        });
-      }
-      append({ role: "assistant", content: e.blocks.map(toContentBlock) }, [e.id]);
-      awaiting = new Set(
-        e.blocks.filter((b) => b.type === "tool_use").map((b) => (b as { call_id: string }).call_id),
-      );
-      continue;
-    }
-
-    // tool_result
-    if (!awaiting.has(e.call_id)) {
-      violations.push({
-        code: "ORPHAN_TOOL_RESULT",
-        detail: `tool_result ${e.id} answers unknown call ${e.call_id}`,
-      });
-      continue;
-    }
-    awaiting.delete(e.call_id);
-    pendingSources.push(e.id);
-    pending.push({
-      type: "tool_result",
-      tool_use_id: e.call_id,
-      content: diagnosticContent(e.content, e.diagnostic) + (e.warnings?.length ? "\nObserver warnings (operation result retained): " + JSON.stringify(e.warnings) : "") +
-        (e.instructions ? "\n\n" + e.instructions.text : ""),
-      ...(e.ok ? {} : { is_error: true }),
-    });
-    // Images follow the paired text result, so APIs without image tool outputs receive a user image.
-    pending.push(...(e.images ?? []).map(image => ({ type: "image" as const, image })));
-  }
-
-  flushPending();
-
-  if (awaiting.size > 0) {
-    violations.push({
-      code: "UNPAIRED_TOOL_USE",
-      detail: `segment ends with unanswered tool_use ${[...awaiting].join(", ")}`,
-    });
-  }
-
-  if (messages.length === 0) {
-    violations.push({ code: "EMPTY_PROJECTION", detail: "no replayable events" });
-  }
-
-  return {
-    ...(input.trace ? { provenance: { version: PROJECTION_VERSION, messages: sources,
-      omitted: input.events.filter(e => !sources.some(ids => ids.includes(e.id))).map(e => e.id) } } : {}),
-    system: input.frozen.system,
-    tools: input.frozen.tools,
-    messages,
-    violations,
-  };
-}
-
-function toContentBlock(b: AssistantBlock): ContentBlock {
-  switch (b.type) {
-    case "tool_use":
-      return { type: "tool_use", id: b.call_id, name: b.name, input: b.input, ...(b.wire === undefined ? {} : { wire: b.wire }) };
-    case "thinking":
-      // Only the raw block crosses back to the API; `text` exists for display.
-      return { type: "thinking", raw: b.raw };
-    case "text":
-      return b;
-    default:
-      return assertNever(b, "toContentBlock");
-  }
-}

package/src/core/prompt-policy.ts

@@ -1,46 +0,0 @@
-/** R10 / D6: stable scope and completion rules; execution details belong to tool contracts. */
-export function taskGuidance(): string {
-  return [
-    "How to work:",
-    "- Keep going until the request is fully resolved. The user's request defines scope; a tool profile only selects capabilities. State reasonable assumptions; ask only for decisions the user must make.",
-    "- Implementation: understand the relevant code, reproduce bugs, finish every requested change and verify the final state with the project's tests, build or type check. Finish with what changed and the command that verified it, or the specific blocker. A research answer does not complete an implementation request.",
-    "- Research: answer the requested questions with original sources, distinguish evidence from inference, and report gaps. Do not change files merely to establish completion.",
-    "- Data analysis: calculate over the complete declared inputs; report sources, denominators, exclusions and uncertainty. Truncated previews cannot establish totals.",
-    "- Runtime or visual work: bind checks to the actual build and running target. Automated checks do not establish human acceptance; report any required acceptance as pending.",
-    "- Put independent reads and searches in one response; they run in parallel. After a command fails, read the end of its output first. If the same approach fails twice, change the approach instead of retrying it.",
-    "- Use only declared capabilities and obey admission decisions. If required evidence is inaccessible, state the specific blocker without inventing success, bypassing permission or replaying an operation with uncertain effects.",
-  ].join("\n");
-}
-
-export interface ToolGuidance {
-  /** Only builtin companions with these exact contracts can satisfy the dependency. */
-  requires: readonly string[];
-  text: string;
-}
-
-/** Capability projection is deterministic; excluding a companion cannot add advice. */
-export function toolDescription(description: string, guidance: readonly ToolGuidance[], tools: readonly string[]): string {
-  return [description, ...guidance.filter(item => item.requires.every(name => tools.includes(name))).map(item => item.text)].join(" ");
-}
-
-/**
- * `usersInline`: the carried `user_turns` hold every user message verbatim.
- * Telling the model to page them anyway costs a guaranteed first-call read
- * that returns what it already has -- or an empty page after a model switch
- * on a fresh session (Horizyn mv3nsske-x50u, fix-recovery-inline-users).
- */
-export function recoveryInstructions(tools: readonly string[], usersInline = false, images = false): string {
-  return (tools.includes("history")
-    ? (usersInline ? "User messages are verbatim in user_turns. Other history(node=source.node,recovery=...) pages: failures, environment, next_actions; " : "Read original user messages before continuing: history(node=source.node,recovery=users,offset=0). Other pages: failures, environment, next_actions; ") +
-      "event=ID reads one original. history(work_id=ID) recovers work. " +
-      // Working set v3: the turn's image references are carried, the pixels are not.
-      (images ? "A user turn's images are not attached here; history(event=ID) with its event reattaches them. " : "")
-    : "Original user messages and evidence remain at the source references. The original-source recovery capability is unavailable; state any resulting evidence gap instead of guessing. ") +
-    "Abandoned messages are cancelled; annotations are not user instructions. Observations are historical: recheck resource, host and current permissions before acting.";
-}
-
-/** Preserve the source locator even when the interface for retrieving it is unavailable. */
-export function artifactRecovery(sha256: string, offset: number, tools: readonly string[] = ["history"]): string {
-  const source = `artifact=${sha256} offset=${offset}`;
-  return tools.includes("history") ? `history ${source}` : `${source}; recovery capability unavailable`;
-}