@visual-z/xeno 0.8.4 → 0.9.0

package/src/core/prompts.ts

@@ -1,111 +0,0 @@
-/**
- * Prompt-template expansion. Pure: the file is read in store.
- *
- * `{{name}}` is filled with the remainder of `/template rest`. An empty
- * remainder keeps the placeholder and names it — emptying it would drop a
- * sentence from the prompt with no trace (feat-skills-and-prompts design).
- */
-
-import { parseFrontmatter } from "./frontmatter.ts";
-
-export interface PromptTemplate {
-  readonly name: string;
-  readonly description: string;
-  readonly argumentHint?: string;
-  readonly content: string;
-  readonly filePath: string;
-}
-
-const PLACEHOLDER = /\{\{([A-Za-z_][A-Za-z0-9_-]*)\}\}/g;
-
-export function expandTemplate(
-  content: string,
-  arg: string,
-): { text: string; diagnostics: readonly string[] } {
-  const names: string[] = [];
-  const seen = new Set<string>();
-  for (const match of content.matchAll(PLACEHOLDER)) {
-    const name = match[1]!;
-    if (!seen.has(name)) {
-      seen.add(name);
-      names.push(name);
-    }
-  }
-  return {
-    text: substituteArgs(content, parseCommandArgs(arg), arg),
-    diagnostics: arg.length ? [] : names.map((name) => `unfilled placeholder: ${name}`),
-  };
-}
-
-/** Ported from pi core/prompt-templates.ts (MIT, 02eed88); quote handling is Pi's, not shell execution. */
-export function parseCommandArgs(text: string): string[] {
-  const args: string[] = [];
-  let current = "", quote: string | null = null;
-  for (const char of text) {
-    if (quote) { if (char === quote) quote = null; else current += char; }
-    else if (char === '"' || char === "'") quote = char;
-    else if (/\s/.test(char)) { if (current) { args.push(current); current = ""; } }
-    else current += char;
-  }
-  if (current) args.push(current);
-  return args;
-}
-
-/** Pi positional/default/slice syntax and legacy named syntax share one pass: inserted text stays literal. */
-function substituteArgs(content: string, args: readonly string[], legacy: string): string {
-  const all = args.join(" ");
-  return content.replace(/\{\{([A-Za-z_][A-Za-z0-9_-]*)\}\}|\$\{(\d+|ARGUMENTS|@):-([^}]*)\}|\$\{@:(\d+)(?::(\d+))?\}|\$(ARGUMENTS|@|\d+)/g,
-    (match: string, named: string | undefined, target: string | undefined, fallback: string | undefined,
-      start: string | undefined, length: string | undefined, simple: string | undefined) => {
-      if (named) return legacy.length ? legacy : match;
-      if (target) return (target === "@" || target === "ARGUMENTS" ? all : args[Number(target) - 1]) || fallback || "";
-      if (start !== undefined) {
-        const from = Math.max(0, Number(start) - 1);
-        return args.slice(from, length === undefined ? undefined : from + Number(length)).join(" ");
-      }
-      if (simple === "@" || simple === "ARGUMENTS") return all;
-      return args[Number(simple) - 1] ?? "";
-    });
-}
-
-export function parsePromptTemplate(input: {
-  readonly filePath: string;
-  readonly text: string;
-}): { template: PromptTemplate | null; diagnostics: readonly string[] } {
-  const parsed = parseFrontmatter(input.text);
-  const diagnostics = [...parsed.diagnostics];
-  const base = fileName(input.filePath);
-  const name = base.replace(/\.md$/i, "").toLowerCase();
-  if (name.length === 0) {
-    diagnostics.push(`${input.filePath}: prompt template has no name`);
-    return { template: null, diagnostics };
-  }
-
-  const descField = parsed.fields["description"];
-  let description = typeof descField === "string" ? descField.trim() : "";
-  if (description.length === 0) {
-    const first = parsed.body.split("\n").find((line) => line.trim().length > 0);
-    description = first === undefined ? "" : first.trim();
-  }
-
-  const hintField = parsed.fields["argument-hint"];
-  const argumentHint = typeof hintField === "string" ? hintField : undefined;
-
-  return {
-    template: {
-      name,
-      description,
-      content: parsed.body,
-      filePath: input.filePath,
-      ...(argumentHint !== undefined ? { argumentHint } : {}),
-    },
-    diagnostics,
-  };
-}
-
-/** Path basename without node:path, so this module stays core-pure. */
-function fileName(path: string): string {
-  const trimmed = path.replace(/[\\/]+$/, "");
-  const slash = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
-  return slash >= 0 ? trimmed.slice(slash + 1) : trimmed;
-}

package/src/core/question.ts

@@ -1,94 +0,0 @@
-/** R13 / D11: an answer is bound to its original active invocation, never guessed. */
-
-// Product limits keep one interaction reviewable, not measured model limits.
-export const MAX_QUESTIONS = 3;
-export const MAX_QUESTION_CHOICES = 8;
-export interface QuestionChoice { readonly id: string; readonly label: string; readonly description?: string }
-export interface QuestionSpec {
-  readonly id: string;
-  readonly header: string;
-  readonly question: string;
-  readonly options: readonly QuestionChoice[];
-  readonly multiple: boolean;
-  readonly custom: boolean;
-}
-export interface QuestionRequest {
-  readonly request_id: string;
-  readonly turn_id: string;
-  readonly call_id: string;
-  readonly questions: readonly QuestionSpec[];
-}
-export interface QuestionAnswer { readonly id: string; readonly choices: readonly string[]; readonly text?: string }
-export interface QuestionReply {
-  readonly request_id: string;
-  readonly turn_id: string;
-  readonly answers: readonly QuestionAnswer[];
-}
-function object(value: unknown, label: string, fields: readonly string[]): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw Error(`${label} must be an object`);
-  const result = value as Record<string, unknown>;
-  if (Object.keys(result).some(key => !fields.includes(key))) throw Error(`${label} contains an unknown field`);
-  return result;
-}
-function string(value: unknown, label: string, max = 2000): string {
-  if (typeof value !== "string" || !value.trim() || value.length > max || /[\0\x1b]/.test(value)) throw Error(`${label} must be nonempty plain text (max ${max} characters)`);
-  return value;
-}
-function identifier(value: unknown, label: string): string {
-  const id = string(value, label, 64);
-  if (!/^[a-z][a-z0-9_-]*$/.test(id)) throw Error(`${label} must be a stable lowercase identifier`);
-  return id;
-}
-
-export function parseQuestions(value: unknown): QuestionSpec[] {
-  const input = object(value, "question input", ["questions"]);
-  const questions = input["questions"];
-  if (!Array.isArray(questions) || questions.length < 1 || questions.length > MAX_QUESTIONS) throw Error(`question requires 1..${MAX_QUESTIONS} questions`);
-  const parsed = questions.map(value => {
-    const item = object(value, "question", ["id", "header", "question", "options", "multiple", "custom"]);
-    const options = item["options"] ?? [];
-    if (!Array.isArray(options) || options.length > MAX_QUESTION_CHOICES) throw Error(`question options must contain at most ${MAX_QUESTION_CHOICES} choices`);
-    const choices = options.map(value => {
-      const choice = object(value, "question option", ["id", "label", "description"]);
-      return { id: identifier(choice["id"], "option id"), label: string(choice["label"], "option label", 120),
-        ...(choice["description"] !== undefined ? { description: string(choice["description"], "option description", 600) } : {}) };
-    });
-    if (new Set(choices.map(choice => choice.id)).size !== choices.length) throw Error("question option ids must be unique");
-    if (new Set(choices.map(choice => choice.label)).size !== choices.length) throw Error("question option labels must be unique");
-    for (const key of ["multiple", "custom"]) if (item[key] !== undefined && typeof item[key] !== "boolean") throw Error(`question ${key} must be boolean`);
-    const multiple = item["multiple"] === true, custom = item["custom"] !== false;
-    if (!choices.length && !custom) throw Error("question must offer choices or custom text");
-    return { id: identifier(item["id"], "question id"), header: string(item["header"], "question header", 40),
-      question: string(item["question"], "question text"), options: choices, multiple, custom };
-  });
-  if (new Set(parsed.map(question => question.id)).size !== parsed.length) throw Error("question ids must be unique");
-  return parsed;
-}
-
-export function questionRequest(turnId: string, callId: string, questions: readonly QuestionSpec[]): QuestionRequest {
-  if (!turnId || !callId || /[\r\n\0]/.test(turnId + callId)) throw Error("question requires a trusted active turn and call identity");
-  // Tuple encoding avoids slash/delimiter collisions in opaque runtime IDs.
-  return { request_id: JSON.stringify([turnId, callId]), turn_id: turnId, call_id: callId, questions: structuredClone(questions) };
-}
-
-export function validateQuestionReply(request: QuestionRequest, value: unknown): QuestionReply {
-  const reply = object(value, "question reply", ["request_id", "turn_id", "answers"]);
-  if (reply["request_id"] !== request.request_id || reply["turn_id"] !== request.turn_id) throw Error("question reply belongs to a different invocation or turn");
-  const answers = reply["answers"];
-  if (!Array.isArray(answers) || answers.length !== request.questions.length) throw Error("question reply must answer every question exactly once");
-  const parsed = answers.map(value => {
-    const answer = object(value, "question answer", ["id", "choices", "text"]);
-    const id = identifier(answer["id"], "answer id"), question = request.questions.find(question => question.id === id);
-    if (!question) throw Error("question reply contains an unknown question id");
-    const choices = answer["choices"];
-    if (!Array.isArray(choices) || choices.some(choice => typeof choice !== "string" || !question.options.some(option => option.id === choice)) || new Set(choices).size !== choices.length) throw Error("question reply contains unknown or duplicate choices");
-    const text = answer["text"] === undefined ? undefined : string(answer["text"], "answer text", 10000);
-    if (text !== undefined && !question.custom) throw Error("custom text is not permitted for this question");
-    const count = choices.length + (text === undefined ? 0 : 1);
-    if (count === 0 || (!question.multiple && count !== 1)) throw Error("question reply requires one answer, or multiple only when enabled");
-    return { id, choices: [...choices] as string[], ...(text !== undefined ? { text } : {}) };
-  });
-  if (new Set(parsed.map(answer => answer.id)).size !== parsed.length) throw Error("question reply contains duplicate question ids");
-  return { request_id: request.request_id, turn_id: request.turn_id,
-    answers: request.questions.map(question => parsed.find(answer => answer.id === question.id)!) };
-}

package/src/core/queue.ts

@@ -1,78 +0,0 @@
-/**
- * When a typed message may enter the log.
- *
- * The queue itself is UI state: a line the user may still retract. The log
- * is what happened. nextDelivery is the only decision — it says which
- * queued line is legal to deliver at this phase, or none. The caller
- * records the user event; this file never does.
- *
- * after_tools is the first legal moment to insert a user message, for the
- * same pairing reason switchModel already refuses a half-round: a tool_use
- * without its tool_result is a 400 (project.ts UNPAIRED_TOOL_USE).
- */
-
-import { assertNever } from "./exhaustive.ts";
-import type { ImageRef } from "./images.ts";
-
-export type QueueKind = "steering" | "followup";
-export type DeliveryMode = "all" | "one-at-a-time";
-
-export interface QueuedMessage {
-  readonly kind: QueueKind;
-  readonly text: string;
-  readonly images?: readonly ImageRef[];
-}
-
-/**
- * Where the turn is. after_tools means every tool_use of this assistant
- * round already has a result. turn_end means send() has returned. idle
- * is the editor waiting — leftover lines still deliver, steering first.
- */
-export type Phase = "after_tools" | "turn_end" | "idle";
-
-/**
- * Which queued message may be written to the log right now.
- *
- * Same kind stays in enqueue order. Steering as a group always precedes
- * follow-up: a follow-up is defined as "after the whole send", so it
- * cannot win while a steering line is still waiting.
- */
-export function nextDelivery(
-  queue: readonly QueuedMessage[],
-  phase: Phase,
-): QueuedMessage | null {
-  switch (phase) {
-    case "after_tools":
-      return firstOfKind(queue, "steering");
-    case "turn_end":
-    case "idle":
-      return firstOfKind(queue, "steering") ?? firstOfKind(queue, "followup");
-    default:
-      return assertNever(phase, "nextDelivery");
-  }
-}
-
-function firstOfKind(
-  queue: readonly QueuedMessage[],
-  kind: QueueKind,
-): QueuedMessage | null {
-  for (const item of queue) {
-    if (item.kind === kind) return item;
-  }
-  return null;
-}
-
-/** Bash remains an atomic follow-up; batching never turns commands into model prompts. */
-export function deliveryBatch(queue: readonly QueuedMessage[], phase: Phase,
-  modes: { steering?: DeliveryMode; followup?: DeliveryMode }): readonly QueuedMessage[] {
-  const first = nextDelivery(queue, phase);
-  if (first === null) return [];
-  if (modes[first.kind] !== "all" || first.text.startsWith("!")) return [first];
-  const batch: QueuedMessage[] = [];
-  for (const item of queue) {
-    if (item.kind !== first.kind) continue;
-    if (item.text.startsWith("!")) break;
-    batch.push(item);
-  }
-  return batch;
-}

package/src/core/read-bounds.ts

@@ -1,24 +0,0 @@
-/** N.12: recoverable file bounds are observation metadata, not model guesses. */
-export function readBounds(total: number, first: unknown, last: unknown):
-  { ok: true; start: number; end: number; notice: string } | { ok: false; message: string } {
-  if (!Number.isSafeInteger(total) || total < 1) throw new RangeError("split text must contain at least one line");
-  const start = first === undefined ? 1 : first, end = last === undefined ? total : last;
-  const bounds = `total lines: ${total}; valid range: 1-${total}`;
-  if (typeof start !== "number" || typeof end !== "number" || !Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 1 || end < 1) {
-    return { ok: false, message: `read start and end must be positive safe integers (${bounds})` };
-  }
-  if (start > total) return { ok: false, message: `read start ${start} is beyond end of file (${bounds}); choose a start in that range` };
-  if (end < start) return { ok: false, message: `read end ${end} precedes start ${start} (${bounds})` };
-  const actualEnd = Math.min(end, total);
-  return { ok: true, start, end: actualEnd, notice: readNotice(start, actualEnd, total) };
-}
-
-/**
- * The selection header. `budget` names the byte limit when it, rather than the
- * requested range, ended the selection, so "next start" is never mistaken for
- * the end of what was asked.
- */
-export function readNotice(start: number, end: number, total: number, budget?: number): string {
-  const rest = end < total ? `next start: ${end + 1}${budget === undefined ? "" : `; stopped at the ${budget}-byte output budget`}` : "end of file";
-  return `[Read selection: lines ${start}-${end}; total lines: ${total}; ${rest}.]`;
-}

package/src/core/read-observation.ts

@@ -1,106 +0,0 @@
-/** R2 / D8: source bytes, an unclipped observation, and the visible projection have distinct identities. */
-import type { ArtifactRef } from "./events.ts";
-import { artifactRecovery } from "./prompt-policy.ts";
-import { headTailSelection, isObservationArtifact as ref, isBytePreview, type BytePreview } from "./observation-view.ts";
-
-export interface ObservationReceipt {
-  version: 1;
-  source: { host: string; workspace: string; resource: string; sha256: string; raw: ArtifactRef };
-  artifact: ArtifactRef;
-  /** R4: content-addressed version premise, separate from this formatted observation. */
-  descriptor?: ArtifactRef;
-  selection: { start: number; end: number; total_lines: number };
-  preview: BytePreview;
-}
-
-const encoder = new TextEncoder();
-const size = (text: string) => encoder.encode(text).length;
-/** Existing assumed preview cap; archival removes data loss without changing the display policy. */
-const READ_MAX_LINE_CHARS = 2000;
-
-export function readObservationText(header: string, lines: readonly string[], start: number): string {
-  return header + lines.map((line, i) => `${start + i}\t${line}`).join("\n");
-}
-
-/** Map two successive cuts (per line and total bytes) back to the same immutable observation. */
-export function previewReadObservation(header: string, lines: readonly string[], start: number, artifact: string,
-  maxBytes: number, maxLineChars = READ_MAX_LINE_CHARS, tools?: readonly string[]): { text: string; preview: ObservationReceipt["preview"]; semantic: string } {
-  const spans: { view: number; source: number; bytes: number }[] = [];
-  let text = "", source = 0, view = 0;
-  const mapped = (value: string, offset: number) => {
-    const bytes = size(value);
-    if (bytes) spans.push({ view, source: offset, bytes });
-    text += value; view += bytes;
-  };
-  const synthetic = (value: string) => { text += value; view += size(value); };
-  mapped(header, 0); source += size(header);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]!, prefix = `${start + i}\t`;
-    let end = Math.min(line.length, maxLineChars);
-    // JavaScript string indices are UTF-16; a character can occupy a surrogate pair.
-    if (end > 0 && end < line.length && /[\uD800-\uDBFF]/.test(line[end - 1]!)) end--;
-    const kept = prefix + line.slice(0, end);
-    mapped(kept, source);
-    if (end < line.length) synthetic(` [line truncated: ${line.length} chars; ${artifactRecovery(artifact, source + size(kept), tools)}]`);
-    source += size(prefix + line);
-    if (i < lines.length - 1) { mapped("\n", source); source++; }
-  }
-  const bytes = encoder.encode(text);
-  const selected = headTailSelection(bytes, bytes, bytes.length, maxBytes,
-    omitted => `\n[truncated ${omitted} preview bytes; ${artifactRecovery(artifact, 0, tools)}]\n`);
-  const visible: [number, number][] = [];
-  for (const [lo, hi] of selected.visible) for (const span of spans) {
-    const begin = Math.max(lo, span.view), end = Math.min(hi, span.view + span.bytes);
-    if (end <= begin) continue;
-    const a = span.source + begin - span.view, b = span.source + end - span.view;
-    const last = visible.at(-1);
-    if (last?.[1] === a) last[1] = b;
-    else visible.push([a, b]);
-  }
-  let next = 0;
-  for (const [lo, hi] of visible) { if (lo !== next) break; next = hi; }
-  const full = encoder.encode(readObservationText(header, lines, start));
-  const semantic = visible.map(([lo, hi]) => new TextDecoder().decode(full.subarray(Math.max(lo, size(header)), Math.max(hi, size(header))))).join("");
-  return { text: selected.text, semantic, preview: { unit: "utf8_bytes", complete: next === source,
-    visible, next_offset: next === source ? null : next } };
-}
-
-/**
- * How many of `lines` a read shows whole within `maxBytes`. OpenCode and Pi cut
- * a file read at a line boundary and name the next offset; eliding the middle
- * lets a receipt claim "end of file" while hiding the lines between, so the
- * model re-reads them and the stall ledger, trusting the claimed range, counts
- * that as no progress. At least one line is kept: a single line over budget
- * is still cut inside itself, with its recovery reference.
- */
-export function linesWithin(header: (count: number) => string, lines: readonly string[], start: number,
-  maxBytes: number, maxLineChars = READ_MAX_LINE_CHARS, tools?: readonly string[]): number {
-  // Rendered without a byte cut, so only the budget decides; a line cut at
-  // maxLineChars is already part of the rendering. Any 64-hex artifact name
-  // renders recovery references at their final length.
-  const fits = (count: number) => size(previewReadObservation(header(count), lines.slice(0, count), start, "0".repeat(64),
-    Number.MAX_SAFE_INTEGER, maxLineChars, tools).text) <= maxBytes;
-  if (lines.length === 0 || fits(lines.length)) return lines.length;
-  let low = 1, high = lines.length - 1;
-  while (low < high) {
-    const mid = Math.ceil((low + high) / 2);
-    if (fits(mid)) low = mid; else high = mid - 1;
-  }
-  return low;
-}
-
-const record = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
-const natural = (value: unknown): value is number => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-const digest = (value: unknown): value is string => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
-
-/** Optional on old logs, strict when present. A cursor cannot certify bytes outside its artifact. */
-export function isObservationReceipt(value: unknown): value is ObservationReceipt {
-  if (!record(value) || value["version"] !== 1 || !ref(value["artifact"])) return false;
-  if (value["descriptor"] !== undefined && !ref(value["descriptor"])) return false;
-  const source = value["source"], selection = value["selection"], preview = value["preview"];
-  if (!record(source) || !["host", "workspace", "resource"].every(key => typeof source[key] === "string" && source[key] !== "") ||
-    !digest(source["sha256"]) || !ref(source["raw"]) || source["sha256"] !== source["raw"].sha256) return false;
-  if (!record(selection) || !natural(selection["start"]) || selection["start"] < 1 || !natural(selection["end"]) ||
-    !natural(selection["total_lines"]) || selection["end"] < selection["start"] || selection["end"] > selection["total_lines"]) return false;
-  return isBytePreview(preview, value["artifact"].bytes);
-}

package/src/core/recovery-sources.ts

@@ -1,74 +0,0 @@
-/** R9 / D8: navigation into original ancestry, never a semantic summary or permission grant. */
-import type { LogEvent } from "./events.ts";
-import { historyEntries, type HistoryEntry } from "./history-query.ts";
-import { isEnvironmentReceipt } from "./environment.ts";
-import { resourceKey } from "./evidence-links.ts";
-import type { ToolDiagnostic } from "./tool-contract.ts";
-
-export const RECOVERY_SECTIONS = ["users", "failures", "environment", "next_actions"] as const;
-export type RecoverySection = typeof RECOVERY_SECTIONS[number];
-export const RECOVERY_KINDS = { users: "user", failures: "failure", environment: "environment", next_actions: "next_action" } as const;
-export type RecoveryNodes = readonly { node: number; events: readonly LogEvent[] }[];
-export type RecoveryReference = {
-  node: number; event: string; kind: "user" | "failure" | "environment" | "next_action";
-  /** This is the recorded role, not proof of current authorization or human authorship. */
-  provenance: "user_message" | "observation" | "model_annotation";
-  abandoned?: true; tool?: string; work?: string;
-  resources?: readonly string[];
-  /** A failed request can name a resource without having observed it. */
-  requested_resource?: string;
-  diagnostic?: Pick<ToolDiagnostic, "code" | "execution" | "effects">;
-  host?: string; workspace?: string; cwd?: string; program?: string;
-};
-export type RecoverySources = Record<RecoverySection, RecoveryReference[]>;
-export type RecoveryRanges = Record<RecoverySection, { total: number; omitted: number }>;
-
-/** Newest first within each role; no keywords decide which user sentence is a constraint. */
-export function recoverySources(nodes: RecoveryNodes, entries: readonly HistoryEntry[] = historyEntries(nodes)): RecoverySources {
-  const abandoned = new Set(nodes.flatMap(part => part.events.flatMap(event => event.t === "interrupt" ? [event.user_id] : [])));
-  const result: RecoverySources = { users: [], failures: [], environment: [], next_actions: [] };
-  for (const entry of entries.toReversed()) {
-    const source = { node: entry.node, event: entry.event };
-    if (entry.kind === "user") result.users.push({ ...source, kind: "user", provenance: "user_message",
-      ...(abandoned.has(entry.event) ? { abandoned: true } : {}) });
-    if (entry.kind === "next_action") result.next_actions.push({ ...source, kind: "next_action", provenance: "model_annotation",
-      ...(entry.work_ids?.[0] ? { work: entry.work_ids[0] } : {}) });
-    if (entry.kind !== "tool_result") continue;
-    if (entry.ok === false) {
-      const input = entry.input !== null && typeof entry.input === "object" ? entry.input as Record<string, unknown> : {};
-      const requested = typeof input["path"] === "string" ? input["path"] : typeof input["cwd"] === "string" ? input["cwd"] : undefined;
-      const diagnostic = entry.diagnostic;
-      result.failures.push({ ...source, kind: "failure", provenance: "observation", ...(entry.tool ? { tool: entry.tool } : {}),
-        ...(entry.resources?.length ? { resources: entry.resources } : {}),
-        ...(requested ? { requested_resource: resourceKey(requested) } : {}),
-        ...(diagnostic ? { diagnostic: { code: diagnostic.code,
-          ...(diagnostic.execution ? { execution: diagnostic.execution } : {}), ...(diagnostic.effects ? { effects: diagnostic.effects } : {}) } } : {}) });
-    }
-    if (entry.tool === "environment") {
-      const receipt = entry.data;
-      // Only a validated actual receipt contributes identity. Text that looks
-      // like a host or a successful probe does not become a machine fact (D11).
-      const identity = isEnvironmentReceipt(receipt) && entry.effect?.kind === "command" && entry.effect.exit === receipt.evidence.exit
-        ? { host: receipt.source.host, workspace: receipt.source.workspace, cwd: receipt.source.cwd, program: receipt.query.program } : {};
-      result.environment.push({ ...source, kind: "environment", provenance: "observation", ...identity });
-    }
-  }
-  return result;
-}
-
-/** Source labels are stable even when the runtime attaches a fresh validity view. */
-export function recoveryPage(sources: RecoverySources, entries: readonly HistoryEntry[], section: RecoverySection, offset: number, limit: number): {
-  total: number; offset: number; next: number | null; items: { source: RecoveryReference; original: HistoryEntry }[];
-} {
-  if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 100) {
-    throw new RangeError("recovery offset must be nonnegative and limit must be 1..100");
-  }
-  const indexed = new Map(entries.map(entry => [entry.event, entry]));
-  const references = sources[section], end = Math.min(references.length, offset + limit);
-  return { total: references.length, offset, next: end < references.length ? end : null,
-    items: references.slice(offset, end).map(source => {
-      const original = indexed.get(source.event);
-      if (!original || original.node !== source.node) throw new Error("recovery source is absent from the selected ancestry");
-      return { source, original };
-    }) };
-}

package/src/core/regex-dialect.ts

@@ -1,25 +0,0 @@
-/**
- * Brings the ripgrep regex dialect to JS RegExp where the two differ in
- * spelling, not meaning.
- *
- * grep runs ripgrep when it is on PATH and a TypeScript walk otherwise, and
- * the model writes for ripgrep (Rust regex), where a leading `(?i)` is the
- * usual way to ask for case-insensitivity. JS rejects that spelling but
- * accepts the scoped form `(?i:...)`, so a leading global group is rewritten
- * into a scoped group around the rest of the pattern. Without this the same
- * call works or fails depending on whether rg happens to be installed.
- *
- * Only the leading form and only flags JS modifiers support (i, m, s) are
- * rewritten; anything else is passed through so RegExp reports it as it is.
- */
-const LEADING_FLAGS = /^\(\?([ims]+)\)/;
-
-export function jsPatternFromRipgrep(pattern: string): string {
-  const match = LEADING_FLAGS.exec(pattern);
-  if (match === null) return pattern;
-  const flags = match[1]!;
-  // A repeated flag is a SyntaxError inside a modifier group; ripgrep
-  // tolerates it, so duplicates are dropped rather than surfaced.
-  const unique = [...new Set(flags)].join("");
-  return `(?${unique}:${pattern.slice(match[0].length)})`;
-}

package/src/core/request-budget.ts

@@ -1,23 +0,0 @@
-/**
- * D6 / Q.26: finalization spends the existing budget and cannot admit new work.
- * `Infinity` is no cap (S.6 item 1): there is no final request to reserve, and
- * the stall watchdog is what ends a run that stops producing evidence.
- */
-export function requestPhase(index: number, limit: number): "work" | "finalize" | "exhausted" {
-  if (!(Number.isSafeInteger(limit) || limit === Infinity) || limit < 1 || !Number.isSafeInteger(index) || index < 0)
-    throw new RangeError("request budget requires a positive integer or unbounded limit and a nonnegative index");
-  if (index >= limit) return "exhausted";
-  // One request cannot both investigate and close. Preserve that work opportunity;
-  // its deterministic outcome is the exit, without a second paid request.
-  return limit > 1 && index === limit - 1 ? "finalize" : "work";
-}
-
-export function finalizationNotice(): string {
-  return "Harness: this is the final request in the existing budget. Tools are disabled by the host. Give the user a concise answer from the observations already recorded: what is established, what remains unresolved, and the next useful action. Do not claim unobserved execution or verified completion.";
-}
-
-/** Without a request cap the stall watchdog is the only backstop, so it cannot be off (S.6 item 1). */
-export function validateRequestBudget(limit: number, stallLimit: number): void {
-  requestPhase(0, limit);
-  if (limit === Infinity && stallLimit === 0) throw new RangeError("an unbounded request budget requires the stall watchdog");
-}

package/src/core/request-progress.ts

@@ -1,87 +0,0 @@
-/** Q23 / D9: diagnostic observations, never a new anti-stall or success policy. */
-import type { LogEvent, ToolResultEvent } from "./events.ts";
-import { deriveAcceptance, type AcceptanceState } from "./acceptance.ts";
-import { advanceRecovery, emptyRecoveryState, failureIdentity } from "./failure-recovery.ts";
-import { canonicalValue } from "./continuation.ts";
-import { changedPaths } from "./checkpoints.ts";
-
-export type RequestSource = { node: number; event: string };
-export type RequestRecord = { node: number; event: LogEvent };
-export type RequestProgress = Record<"observations" | "artifact_changes" | "acceptance_advances" |
-  "new_diagnostics" | "unchanged_retries" | "unknown_diagnostics", RequestSource[]>;
-const object = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
-
-function observationDigest(event: ToolResultEvent): string | undefined {
-  if (event.observation_sha256 !== undefined) return event.observation_sha256;
-  // Command receipts archive stdout/stderr before the timing/session header is
-  // rendered. Only that explicit matching output reference is a safe fallback.
-  const data = event.data;
-  if (event.effect?.kind !== "command" || !event.content_ref || !object(data) || data["capture"] === "partial") return undefined;
-  const output = data["output"];
-  return object(output) &&
-    output["sha256"] === event.content_ref.sha256 && output["bytes"] === event.content_ref.bytes ? event.content_ref.sha256 : undefined;
-}
-
-export function deriveRequestProgress(records: readonly RequestRecord[]): RequestProgress {
-  const result: RequestProgress = { observations: [], artifact_changes: [], acceptance_advances: [],
-    new_diagnostics: [], unchanged_retries: [], unknown_diagnostics: [] };
-  const observations = new Set<string>(), versions = new Set<string>(), failures = new Set<string>();
-  let acceptance: AcceptanceState | undefined;
-  let recovery = emptyRecoveryState();
-  const version = (path: string, before: string | null, after: string | null, source: RequestSource) => {
-    const key = (sha: string | null) => canonicalValue([path, sha]);
-    versions.add(key(before));
-    if (!versions.has(key(after))) result.artifact_changes.push(source);
-    versions.add(key(after));
-  };
-  for (const { node, event } of records) {
-    const source = { node, event: event.id };
-    const before = acceptance;
-    acceptance = deriveAcceptance(acceptance, [event]);
-    if (acceptance && before?.contract_event === acceptance.contract_event && acceptance.criteria.some(item =>
-      (item.status === "pass" || item.status === "accepted") &&
-      before.criteria.find(old => old.id === item.id)?.status !== item.status)) result.acceptance_advances.push(source);
-    if (event.t === "tool_result") {
-      const effect = event.effect;
-      const call = recovery.calls.get(event.call_id);
-      if (effect?.kind === "edit") version(effect.path, effect.sha256_before, effect.sha256_after, source);
-      if (effect?.kind === "read") versions.add(canonicalValue([effect.path, effect.sha256]));
-      // Semantic digests exclude command timing/preview metadata. Legacy raw
-      // output hashes cannot prove a new diagnostic and stay explicitly unknown.
-      const digest = observationDigest(event);
-      if (!event.ok) {
-        const identity = call ? failureIdentity(call, event, recovery, path => path) : null;
-        if (digest === undefined || identity === null) result.unknown_diagnostics.push(source);
-        else {
-          const key = canonicalValue([identity, digest]);
-          (failures.has(key) ? result.unchanged_retries : result.new_diagnostics).push(source);
-          failures.add(key);
-        }
-      } else if ((effect?.kind === "read" || effect?.kind === "command" ||
-          ["grep", "find", "ls", "query", "history", "environment"].includes(call?.name ?? "")) &&
-          digest !== undefined && (event.content_ref?.bytes ?? event.content.length) > 0 && !observations.has(digest)) {
-        result.observations.push(source); observations.add(digest);
-      }
-      if (effect?.kind === "command") for (const output of effect.artifacts?.outputs ?? []) {
-        if (output.after.state === "observed") version(output.path,
-          output.before.state === "observed" ? output.before.sha256 : null, output.after.sha256, source);
-      }
-    } else if (event.t === "checkpoint" && event.phase === "applied") {
-      for (const path of changedPaths(event.changes)) {
-        const change = event.changes[path]!;
-        version(path, change.before?.sha256 ?? null, change.after?.sha256 ?? null, source);
-      }
-    }
-    recovery = advanceRecovery(recovery, [event], path => path);
-  }
-  // One receipt may change several artifacts or satisfy several criteria.
-  for (const key of Object.keys(result) as (keyof RequestProgress)[]) {
-    const seen = new Set<string>();
-    result[key] = result[key].filter(source => {
-      const id = canonicalValue(source);
-      if (seen.has(id)) return false;
-      seen.add(id); return true;
-    });
-  }
-  return result;
-}