@visual-z/xeno 0.8.4 → 0.9.0

package/src/core/skills.ts

@@ -1,165 +0,0 @@
-/**
- * Skill validation and the frozen-prefix fragment.
- *
- * A skill is a text resource, not a tool. The system prompt gets the name
- * and description so the model can decide whether to read the file; the
- * body stays out of the prefix because the prefix is sent on every request
- * (feat-skills-and-prompts design; Agent Skills progressive disclosure).
- */
-
-import { parseFrontmatter } from "./frontmatter.ts";
-import type { LogEvent } from "./events.ts";
-
-/** Agent Skills name rule. Assumed from the spec, not measured. */
-const MAX_NAME_LENGTH = 64;
-
-/**
- * 1–64 chars, lowercase / digits / hyphens, no leading, trailing, or
- * doubled hyphen. A name that fails this is skipped, not coerced — an
- * auto-slug would make two different directories collide silently.
- */
-const NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-
-export interface Skill {
-  readonly name: string;
-  readonly description: string;
-  readonly filePath: string;
-  readonly body: string;
-  readonly disableModelInvocation: boolean;
-  readonly userInvocable?: boolean;
-  readonly context?: "fork";
-  readonly allowedTools?: readonly string[];
-  readonly disallowedTools?: readonly string[];
-  /** Stored outside the model prefix so resource reads reproduce the loaded bytes. */
-  readonly sourceText?: string;
-}
-
-export type LoadedSkill = { name: string; path: string; sha256: string; artifact: string;
-  mode: "inline" | "fork" | "read"; origin: "user" | "model"; node: number; event: string };
-
-/** O.12: explicit capability intersection, never an approval grant. */
-export function skillTools(parent: readonly string[], skill: Skill): string[] {
-  return parent.filter(name => (skill.allowedTools === undefined || skill.allowedTools.includes(name)) && !skill.disallowedTools?.includes(name));
-}
-
-export function deriveLoadedSkills(previous: readonly LoadedSkill[], events: readonly LogEvent[], node: number): LoadedSkill[] {
-  const loaded = new Map(previous.map(item => [item.path, item]));
-  for (const e of events) if (e.t === "skill_loaded") loaded.set(e.path, {
-    name: e.name, path: e.path, sha256: e.sha256, artifact: e.artifact, mode: e.mode, origin: e.origin, node, event: e.id,
-  });
-  return [...loaded.values()];
-}
-
-export function isValidSkillName(name: string): boolean {
-  return name.length >= 1 && name.length <= MAX_NAME_LENGTH && NAME_RE.test(name);
-}
-
-export function parseSkill(input: {
-  readonly filePath: string;
-  readonly parentDirName: string;
-  readonly text: string;
-}): { skill: Skill | null; diagnostics: readonly string[] } {
-  const parsed = parseFrontmatter(input.text);
-  const diagnostics = [...parsed.diagnostics];
-  const supported = ["name", "description", "disable-model-invocation", "user-invocable", "context", "allowed-tools", "disallowed-tools", "license", "compatibility"];
-  for (const key of Object.keys(parsed.fields)) if (!supported.includes(key)) diagnostics.push(`${input.filePath}: unsupported skill field ${key}`);
-  for (const key of ["disable-model-invocation", "user-invocable"]) {
-    if (parsed.fields[key] !== undefined && typeof parsed.fields[key] !== "boolean") diagnostics.push(`${input.filePath}: ${key} must be boolean`);
-  }
-  if (parsed.fields["context"] !== undefined && parsed.fields["context"] !== "fork") diagnostics.push(`${input.filePath}: context must be fork`);
-  const toolNames = (key: string): string[] | undefined => {
-    const value = parsed.fields[key];
-    if (value === undefined) return undefined;
-    const aliases: Record<string, string> = { Read: "read", Write: "write", Edit: "edit", Grep: "grep", Glob: "find", Bash: "bash" };
-    const names = Array.isArray(value) ? value : typeof value === "string" ? value.split(/[\s,]+/).filter(Boolean) : [];
-    if ((names.length === 0 && value !== "") || names.some(name => !/^[A-Za-z][A-Za-z0-9_-]*$/.test(name))) diagnostics.push(`${input.filePath}: ${key} requires explicit tool names; permission patterns are unsupported`);
-    return [...new Set(names.map(name => aliases[name] ?? name))];
-  };
-  const allowedTools = toolNames("allowed-tools"), disallowedTools = toolNames("disallowed-tools");
-  if (diagnostics.length > 0) return { skill: null, diagnostics };
-  const desc = parsed.fields["description"];
-  const description = typeof desc === "string" ? desc.trim() : "";
-  if (description.length === 0) {
-    diagnostics.push(`${input.filePath}: missing description`);
-    return { skill: null, diagnostics };
-  }
-
-  const named = parsed.fields["name"];
-  const name = typeof named === "string" && named.trim().length > 0
-    ? named.trim()
-    : input.parentDirName;
-  if (!isValidSkillName(name)) {
-    diagnostics.push(`${input.filePath}: name "${name}" is not a valid skill name`);
-    return { skill: null, diagnostics };
-  }
-
-  const disable = parsed.fields["disable-model-invocation"] === true;
-  return {
-    skill: {
-      name,
-      description,
-      filePath: input.filePath,
-      body: parsed.body,
-      disableModelInvocation: disable,
-      userInvocable: parsed.fields["user-invocable"] !== false,
-      sourceText: input.text,
-      ...(parsed.fields["context"] === "fork" ? { context: "fork" as const } : {}),
-      ...(allowedTools ? { allowedTools } : {}),
-      ...(disallowedTools ? { disallowedTools } : {}),
-    },
-    diagnostics,
-  };
-}
-
-/**
- * XML fragment per the Agent Skills integrate-skills shape, so a skill
- * written for pi is recognised here. Location is the path the model should
- * `read`; the body is deliberately absent.
- */
-export function formatSkillsForPrompt(skills: readonly Skill[]): string {
-  const visible = skills.filter((s) => !s.disableModelInvocation);
-  if (visible.length === 0) return "";
-  const lines = [
-    "The following skills provide specialized instructions for specific tasks.",
-    "Use the read tool to load a skill's file when the task matches its description.",
-    "When a skill file references a relative path, resolve it against the skill directory.",
-    "",
-    "<available_skills>",
-  ];
-  for (const skill of visible) {
-    lines.push("  <skill>");
-    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
-    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
-    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
-    lines.push("  </skill>");
-  }
-  lines.push("</available_skills>");
-  return lines.join("\n");
-}
-
-/** Append the skills section without touching the context-file assembly. */
-export function appendSkillsToSystem(system: string, skills: readonly Skill[]): string {
-  const section = formatSkillsForPrompt(skills);
-  return section.length === 0 ? system : `${system}\n\n${section}`;
-}
-
-/**
- * `/skill:name` is the user forcing a read. Wrapping the body with the
- * path lets relative references inside the skill resolve the same way a
- * model-issued `read` would.
- */
-export function skillInvocationMessage(skill: Skill, args: string): string {
-  const wrapped =
-    `<skill name="${escapeXml(skill.name)}" location="${escapeXml(skill.filePath)}">\n` +
-    `${skill.body}\n` +
-    `</skill>`;
-  return args.length > 0 ? `${wrapped}\n\nUser: ${args}` : wrapped;
-}
-
-function escapeXml(s: string): string {
-  return s
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;");
-}

package/src/core/sql-query.ts

@@ -1,211 +0,0 @@
-/** Q.17: an optional syntax for DataQuery, never an alternate execution path. */
-import { parseDataQuery, type DataQuery } from "./data-query.ts";
-import { isRecord } from "./event-validation.ts";
-
-// Assumed synchronous parsing budgets, not measured model or database limits.
-// Reject over-budget input before lexing; never execute a parsed prefix.
-export const MAX_SQL_CHARS = 16_384;
-export const MAX_SQL_TOKENS = 4_096;
-export const SQL_QUERY_HELP = "SQL-style subset: SELECT * or fields/COUNT/SUM/AVG/MIN/MAX(field) AS alias FROM source; optional WHERE comparisons, IS [NOT] NULL or CONTAINS(field, literal), joined by AND; GROUP BY; ORDER BY field [ASC|DESC]. No comments, joins, subqueries, OR, HAVING, DISTINCT, LIMIT/OFFSET or multiple statements. Use artifact pages for large results.";
-
-type Token = { kind: "word" | "identifier" | "string" | "number" | "symbol" | "end"; text: string; at: number };
-type Aggregate = NonNullable<DataQuery["aggregate"]>[number];
-type Predicate = NonNullable<DataQuery["where"]>[number];
-const OPERATIONS = ["count", "sum", "avg", "min", "max"] as const;
-const RESERVED = new Set(("SELECT FROM SOURCE WHERE GROUP BY ORDER ASC DESC AS AND IS NOT NULL TRUE FALSE CONTAINS " +
-  "COUNT SUM AVG MIN MAX DISTINCT LIMIT OFFSET HAVING JOIN INNER LEFT RIGHT OUTER ON UNION WITH OR IN LIKE BETWEEN " +
-  "INSERT UPDATE DELETE DROP CREATE ALTER INTO VALUES RETURNING").split(" "));
-const JSON_OPERATORS = ["where", "select", "group_by", "aggregate", "order_by"] as const;
-
-function sqlError(at: number, message: string): never {
-  // Locations refer to UTF-16 offsets in the supplied string, without echoing data literals.
-  throw new Error("SQL at offset " + at + ": " + message + ". " + SQL_QUERY_HELP);
-}
-function tokenize(sql: string): Token[] {
-  if (sql.length > MAX_SQL_CHARS) sqlError(MAX_SQL_CHARS, "input exceeds " + MAX_SQL_CHARS + " characters");
-  const tokens: Token[] = [];
-  let at = 0;
-  const emit = (kind: Token["kind"], text: string, start: number) => {
-    if (tokens.length >= MAX_SQL_TOKENS) sqlError(start, "input exceeds " + MAX_SQL_TOKENS + " tokens");
-    tokens.push({ kind, text, at: start });
-  };
-  while (at < sql.length) {
-    const c = sql[at]!;
-    if (/\s/.test(c)) { at++; continue; }
-    const start = at;
-    if (c === "'" || c === '"') {
-      const quote = c;
-      let value = "", closed = false;
-      at++;
-      while (at < sql.length) {
-        const next = sql[at++]!;
-        if (next !== quote) value += next;
-        else if (sql[at] === quote) { value += quote; at++; }
-        else { closed = true; break; }
-      }
-      if (!closed) sqlError(start, "unterminated quoted value");
-      emit(quote === "'" ? "string" : "identifier", value, start);
-    } else if (/[A-Za-z_]/.test(c)) {
-      at++;
-      while (at < sql.length && /[A-Za-z0-9_$]/.test(sql[at]!)) at++;
-      emit("word", sql.slice(start, at), start);
-    } else if (/[0-9+-]/.test(c) || (c === "." && /[0-9]/.test(sql[at + 1] ?? ""))) {
-      const numeric = /^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?/.exec(sql.slice(at));
-      if (!numeric || !Number.isFinite(Number(numeric[0]))) sqlError(start, "expected a finite numeric literal; comments are unsupported");
-      at += numeric[0].length;
-      emit("number", numeric[0], start);
-    } else {
-      const pair = sql.slice(at, at + 2);
-      if (["<=", ">=", "!=", "<>"].includes(pair)) { at += 2; emit("symbol", pair, start); }
-      else if (",().*;=<>".includes(c)) { at++; emit("symbol", c, start); }
-      else sqlError(start, "unsupported character");
-    }
-  }
-  tokens.push({ kind: "end", text: "", at: sql.length });
-  return tokens;
-}
-
-class SqlParser {
-  private readonly tokens: readonly Token[];
-  private index = 0;
-  constructor(sql: string) { this.tokens = tokenize(sql); }
-  private get current(): Token { return this.tokens[this.index]!; }
-  private isWord(word: string): boolean { return this.current.kind === "word" && this.current.text.toUpperCase() === word; }
-  private word(word: string): boolean {
-    if (!this.isWord(word)) return false;
-    this.index++; return true;
-  }
-  private symbol(text: string): boolean {
-    if (this.current.kind !== "symbol" || this.current.text !== text) return false;
-    this.index++; return true;
-  }
-  private requireWord(word: string): void {
-    if (!this.word(word)) sqlError(this.current.at, "expected " + word);
-  }
-  private requireSymbol(text: string): void {
-    if (!this.symbol(text)) sqlError(this.current.at, "expected " + text);
-  }
-  private identifier(): string {
-    const token = this.current;
-    if (token.kind !== "identifier" && (token.kind !== "word" || RESERVED.has(token.text.toUpperCase()))) {
-      sqlError(token.at, 'expected a field or alias; quote reserved names with double quotes');
-    }
-    if (!token.text) sqlError(token.at, "field and alias names must be nonempty");
-    this.index++;
-    return token.text;
-  }
-  private field(): string {
-    const parts = [this.identifier()];
-    while (this.symbol(".")) parts.push(this.identifier());
-    return parts.join(".");
-  }
-  private fields(): string[] {
-    const fields = [this.field()];
-    while (this.symbol(",")) fields.push(this.field());
-    return fields;
-  }
-  private literal(): string | number | boolean {
-    const token = this.current;
-    if (token.kind === "number") { this.index++; return Number(token.text); }
-    if (token.kind === "string") { this.index++; return token.text; }
-    if (this.word("TRUE")) return true;
-    if (this.word("FALSE")) return false;
-    sqlError(token.at, "expected a string, finite number or boolean literal; use IS NULL for null checks");
-  }
-  private predicate(): Predicate {
-    if (this.word("CONTAINS")) {
-      this.requireSymbol("(");
-      const field = this.field();
-      this.requireSymbol(",");
-      const value = this.literal();
-      this.requireSymbol(")");
-      return { field, op: "contains", value };
-    }
-    const field = this.field();
-    if (this.word("IS")) {
-      const not = this.word("NOT");
-      this.requireWord("NULL");
-      return { field, op: not ? "ne" : "eq", value: null };
-    }
-    const token = this.current;
-    const ops: Record<string, Predicate["op"]> = { "=": "eq", "!=": "ne", "<>": "ne", "<": "lt", "<=": "lte", ">": "gt", ">=": "gte" };
-    const op = token.kind === "symbol" ? ops[token.text] : undefined;
-    if (op === undefined) sqlError(token.at, "expected a comparison operator or IS [NOT] NULL");
-    this.index++;
-    return { field, op, value: this.literal() };
-  }
-  parse(source: Pick<DataQuery, "format" | "pointer">): DataQuery {
-    this.requireWord("SELECT");
-    const wildcard = this.symbol("*");
-    const selected: string[] = [], fields: string[] = [], aggregates: Aggregate[] = [];
-    if (!wildcard) {
-      do {
-        const token = this.current;
-        const op = OPERATIONS.find(value => token.kind === "word" && value.toUpperCase() === token.text.toUpperCase());
-        if (op !== undefined) {
-          this.index++;
-          this.requireSymbol("(");
-          const star = this.symbol("*");
-          if (star && op !== "count") sqlError(token.at, "only COUNT accepts *");
-          const field = star ? undefined : this.field();
-          this.requireSymbol(")"); this.requireWord("AS");
-          const alias = this.identifier();
-          aggregates.push({ op, ...(field === undefined ? {} : { field }), as: alias });
-          selected.push(alias);
-        } else {
-          const field = this.field();
-          selected.push(field); fields.push(field);
-        }
-      } while (this.symbol(","));
-    }
-    this.requireWord("FROM"); this.requireWord("SOURCE");
-    const query: DataQuery = { ...source, ...(!wildcard ? { select: selected } : {}) };
-    if (this.word("WHERE")) {
-      const where = [this.predicate()];
-      while (this.word("AND")) where.push(this.predicate());
-      query.where = where;
-    }
-    if (this.word("GROUP")) { this.requireWord("BY"); query.group_by = this.fields(); }
-    if (this.word("ORDER")) {
-      this.requireWord("BY");
-      const order: NonNullable<DataQuery["order_by"]>[number][] = [];
-      do {
-        const field = this.field(), descending = this.word("DESC");
-        if (!descending) this.word("ASC");
-        order.push({ field, ...(descending ? { descending: true } : {}) });
-      } while (this.symbol(","));
-      query.order_by = order;
-    }
-    this.symbol(";");
-    if (this.current.kind !== "end") sqlError(this.current.at, "unexpected clause or additional statement");
-    if (aggregates.length) {
-      query.aggregate = aggregates;
-      const grouped = query.group_by ?? [];
-      if (fields.length !== grouped.length || fields.some(field => !grouped.includes(field))) {
-        sqlError(this.current.at, "GROUP BY must match the selected non-aggregate fields");
-      }
-      if (query.order_by?.some(order => !selected.includes(order.field))) {
-        sqlError(this.current.at, "aggregate ORDER BY must name a selected group field or aggregate alias");
-      }
-    }
-    // The existing algebra owns arity, duplicate names, and grouping invariants.
-    try { return parseDataQuery(query); }
-    catch (error) { return sqlError(this.current.at, String(error)); }
-  }
-}
-
-/** Compiles one finite statement. It neither opens sources nor evaluates code. */
-export function compileSqlQuery(sql: string, source: Pick<DataQuery, "format" | "pointer">): DataQuery {
-  return new SqlParser(sql).parse(parseDataQuery(source));
-}
-
-/** Both syntaxes converge before source I/O, permissions, execution and archival. */
-export function parseQueryInput(input: unknown): DataQuery {
-  if (!isRecord(input) || !Object.hasOwn(input, "sql")) return parseDataQuery(input);
-  if (typeof input["sql"] !== "string") throw new Error("sql must be a string");
-  if (JSON_OPERATORS.some(key => Object.hasOwn(input, key))) {
-    throw new Error("sql cannot be combined with where, select, group_by, aggregate or order_by");
-  }
-  const source = parseDataQuery({ format: input["format"], ...(input["pointer"] === undefined ? {} : { pointer: input["pointer"] }) });
-  return compileSqlQuery(input["sql"], source);
-}

package/src/core/stall.ts

@@ -1,128 +0,0 @@
-/** N.9: restartable progress accounting independent of model-context boundaries. */
-import type { LogEvent } from "./events.ts";
-import { pendingToolCalls } from "./execution.ts";
-import { exchangeProgressChecks } from "./evidence.ts";
-import { deriveProgress, type ProgressEvidence } from "./progress.ts";
-import { isProcessReceipt } from "./process-receipt.ts";
-import { canonicalValue } from "./continuation.ts";
-
-/**
- * S.8: the watchdog is now an on/off switch -- 0 disables it, any other
- * allowed value enables it. Sessions persist this field (S.3); a stored 12
- * still means "on" and is never reread as "twelve repeats".
- */
-export const DEFAULT_STALL_LIMIT = 12;
-/**
- * How many times a cycle must repeat. A hypothesis, not measured: OpenCode's
- * doom loop, Cline and Roo use 3; OpenHands 4 counting the first, novel,
- * observation; Gemini 5. Lower asks too often, higher pays for more repeats.
- */
-export const CYCLE_REPEATS = 3;
-/** Longest cycle recognised; Gemini CLI's bound, and the user's (S.8). */
-export const MAX_CYCLE = 5;
-
-export interface StallExchange { readonly signature: string; readonly progressed: boolean }
-export interface StallState {
-  evidence: readonly ProgressEvidence[];
-  pending: readonly LogEvent[];
-  pendingNode: number;
-  /** The request's latest exchanges, oldest first, at most MAX_CYCLE × CYCLE_REPEATS. */
-  recent: readonly StallExchange[];
-  failures: number;
-  emptyWaits: number;
-  /** A cycle was already pointed out to the model; the next one goes to the user. */
-  nudged: boolean;
-  /** The previous exchange's tool calls, canonical; empty after real user input. */
-  previous: string;
-  /**
-   * A completion review just asked the model to re-read the request and
-   * verify. Its answer is the harness's own request, so that one exchange
-   * stays out of the cycle window (fix-review-induced-stall).
-   */
-  reviewed: boolean;
-}
-export function emptyStallState(): StallState {
-  return { evidence: [], pending: [], pendingNode: 0, recent: [], failures: 0, emptyWaits: 0, nudged: false, previous: "", reviewed: false };
-}
-
-/**
- * The shortest period k <= MAX_CYCLE such that the last k × repeats exchanges
- * are one k-call cycle repeated, none of which brought new evidence -- or null.
- * Distinct calls that each tell nothing new are not a loop: that is reading
- * and re-checking, which a cumulative allowance wrongly punished (S.8).
- */
-export function repeatedCycle(recent: readonly StallExchange[], repeats = CYCLE_REPEATS): number | null {
-  for (let k = 1; k <= MAX_CYCLE; k++) {
-    const n = k * repeats;
-    if (recent.length < n) return null;
-    const window = recent.slice(-n);
-    if (window.some(item => item.progressed)) continue;
-    if (window.every((item, i) => i < k || item.signature === window[i - k]!.signature)) return k;
-  }
-  return null;
-}
-
-/** Name and arguments of every call, order-independent: what the model asked for, not what came back. */
-function exchangeSignature(assistant: Extract<LogEvent, { t: "assistant" }>): string {
-  return assistant.blocks.flatMap(block => block.type === "tool_use" ? [`${block.name}:${canonicalValue(block.input)}`] : []).sort().join("\n");
-}
-
-export function finishStallExchange(state: StallState): StallState {
-  const assistant = state.pending[0];
-  if (assistant?.t !== "assistant" || pendingToolCalls(state.pending).length > 0) return state;
-  if (!assistant.blocks.some((block) => block.type === "tool_use")) return { ...state, pending: [] };
-  const checks = exchangeProgressChecks(state.pending);
-  const progress = deriveProgress(state.evidence, state.pending, state.pendingNode, checks);
-  const signature = exchangeSignature(assistant);
-  const waits = new Set(assistant.blocks.flatMap(block => block.type === "tool_use" && block.name === "write_stdin" ? [block.call_id] : []));
-  // S.6 item 2: asking
-  // for exactly what the previous exchange asked for is a rerun on an
-  // unchanged premise, so output that differs only by timing (a failing test's
-  // "[123ms]") is not news. Reads and edits are content-addressed and keep
-  // their own rules; waiting on a running process is not a rerun. Only the
-  // immediately previous exchange: an edit, in any tool, between two runs is
-  // what makes the second one worth running (Gemini, Cline, OpenCode and Roo
-  // detect identical consecutive calls the same way).
-  const rerun = signature === state.previous
-    ? deriveProgress(state.evidence, state.pending.filter(event => event.t !== "tool_result" || waits.has(event.call_id) ||
-        (event.effect?.kind !== "command" && !isProcessReceipt(event.data))), state.pendingNode, checks).progressed
-    : progress.progressed;
-  const results = state.pending.filter(event => event.t === "tool_result");
-  // Waiting on a process that is still running is not another attempt: its
-  // own timeout bounds it and the user can interrupt (S.8). Only exchanges
-  // that try something enter the cycle window.
-  const waiting = results.length > 0 && results.every(result => waits.has(result.call_id) && isProcessReceipt(result.data) && result.data.running === true);
-  const recent = state.reviewed || waiting ? state.recent : [...state.recent, { signature, progressed: rerun }].slice(-MAX_CYCLE * CYCLE_REPEATS);
-  return { ...state, pending: [], evidence: progress.evidence, previous: signature, reviewed: false, recent,
-    failures: state.failures + results.filter(result => !result.ok).length,
-    emptyWaits: state.emptyWaits + results.filter(result => waits.has(result.call_id) && isProcessReceipt(result.data) &&
-      result.data.running === true && result.data.cursor !== undefined && result.data.cursor.start === result.data.cursor.end).length };
-}
-
-/** Fold original events, never the retained projection where evidence can repeat. */
-export function advanceStall(state: StallState, entries: readonly { node: number; event: LogEvent }[]): StallState {
-  let result = state;
-  for (const { node, event } of entries) {
-    const review = event.t === "guidance" && event.reason === "completion_review";
-    const nudge = event.t === "guidance" && event.reason === "stall";
-    if (event.t === "assistant" || event.t === "user" || event.t === "cut" || review || nudge) {
-      result = finishStallExchange(result);
-      if (review) result = { ...result, reviewed: true };
-      // A nudge, or the user's "continue", starts a fresh window: only a new
-      // full cycle after it counts, never the one already reported.
-      if (nudge) result = { ...result, nudged: true, recent: [] };
-      if (event.t === "user") result = { ...result, pending: [], recent: [], failures: 0, emptyWaits: 0, nudged: false, previous: "", reviewed: false };
-      if (event.t === "assistant") result = { ...result, pending: [event], pendingNode: node };
-    } else if (result.pending.length > 0) result = { ...result, pending: [...result.pending, event] };
-  }
-  return result;
-}
-export function stallDecision(state: StallState, limit: number) {
-  if (!Number.isSafeInteger(limit) || limit < 0 || limit === 1) throw new RangeError("stall limit must be zero or an integer of at least two");
-  const current = finishStallExchange(state);
-  const cycle = limit > 0 ? repeatedCycle(current.recent) : null;
-  // S.8: the first cycle is pointed out to the model; a second goes to the
-  // user when one can answer, and otherwise ends the request.
-  return { cycle, repeats: CYCLE_REPEATS, failures: current.failures, emptyWaits: current.emptyWaits,
-    warn: cycle !== null && !current.nudged, stop: cycle !== null && current.nudged };
-}

package/src/core/stop-report.ts

@@ -1,68 +0,0 @@
-/** D8 / D11: summarize termination mechanically; assistant claims never become receipts. */
-import type { LogEvent } from "./events.ts";
-import { isProcessReceipt, latestProcessReceipt } from "./process-receipt.ts";
-import { exitLine } from "./session-exit.ts";
-import { currentRequestEvents } from "./request-state.ts";
-
-export function stopReport(events: readonly LogEvent[], requests: number, limit: number, cause: string): string {
-  const scoped = currentRequestEvents(events);
-  const current = scoped.length > 0 ? scoped : events;
-  const results = current.filter(event => event.t === "tool_result");
-  // Q.22 keeps ok:false on a recorded-but-unverified claim so the model does
-  // not read "recorded" as "done"; to a person reading why work stopped it is
-  // an unproven statement, not a broken tool.
-  const unverified = results.filter(unverifiedClaim);
-  const failures = results.filter(event => !event.ok && !unverifiedClaim(event));
-  const exits = results.filter(event => event.effect?.kind === "command" && event.effect.exit === 0).length;
-  const ids = new Set<number>();
-  for (const event of current) {
-    if (event.t === "tool_result" && isProcessReceipt(event.data)) ids.add(event.data.session_id);
-    if (event.t === "process_exit") ids.add(event.session);
-  }
-  const running = [...ids].filter(id => latestProcessReceipt([{ node: 0, events: current }], id)?.receipt.running === true);
-  return [
-    requestLine(exitLine(cause), requests, limit),
-    `Recorded evidence: ${results.length} tool receipts; ${exits} successful command exits; ${failures.length} failed tool receipts${unverified.length ? `; ${unverified.length} unverified claims` : ""}. Task completion is not verified by this stop.`,
-    ...(failures.length ? [`Failed tools: ${failedTools(current, failures)}.`] : []),
-    ...(finalReplyGiven(current) ? ["A final reply was given before this stop; read it above — this stop does not mark it wrong."] : []),
-    ...(running.length ? [`Last observed running: ${running.slice(0, 3).join(", ")}${running.length > 3 ? ` (+${running.length - 3})` : ""}; inspect the process receipt before replaying a command.`] : []),
-    "Next: inspect /state or the recorded tool output, then provide a focused continuation; completed commands should not be replayed just to recover their output.",
-  ].join("\n");
-}
-
-/**
- * S.6 removed the default cap. A bare "(80 model requests)" in the same
- * brackets as "(3/7 model requests)" read as a ceiling that was hit
- * (fix-stop-report-request-count), so an uncapped run says it is a count.
- */
-function requestLine(cause: string, requests: number, limit: number): string {
-  if (limit !== Infinity) return `Stopped: ${cause} (${requests}/${limit} model requests).`;
-  return `Stopped: ${cause}. This request sent ${requests} model request${requests === 1 ? "" : "s"}; no request cap is set.`;
-}
-
-/**
- * The user reads this line; no command looks a receipt up by id, so ids told
- * them nothing (fix-stop-report-readable). Tool names say where it went wrong.
- */
-function failedTools(events: readonly LogEvent[], failures: readonly Extract<LogEvent, { t: "tool_result" }>[]): string {
-  const names = new Map<string, string>();
-  for (const event of events) if (event.t === "assistant") for (const block of event.blocks) if (block.type === "tool_use") names.set(block.call_id, block.name);
-  const counts = new Map<string, number>();
-  for (const failure of failures) { const name = names.get(failure.call_id) ?? "unknown"; counts.set(name, (counts.get(name) ?? 0) + 1); }
-  const ranked = [...counts].sort(([a, x], [b, y]) => y - x || (a < b ? -1 : a > b ? 1 : 0));
-  return ranked.slice(0, 3).map(([name, count]) => `${name} ×${count}`).join(", ") + (ranked.length > 3 ? ` (+${ranked.length - 3} more)` : "");
-}
-
-function unverifiedClaim(event: Extract<LogEvent, { t: "tool_result" }>): boolean {
-  if (event.ok || !event.content.startsWith("{")) return false;
-  try {
-    const body = JSON.parse(event.content) as { recorded?: unknown; verification?: unknown };
-    return body.recorded === true && body.verification === "unverified";
-  } catch { return false; }
-}
-
-/** A stop after the model already answered must not read as "the task failed". */
-function finalReplyGiven(events: readonly LogEvent[]): boolean {
-  return events.some(event => event.t === "assistant" && !event.blocks.some(block => block.type === "tool_use") &&
-    event.blocks.some(block => block.type === "text" && block.text.trim().length > 0));
-}

package/src/core/text-normalize.ts

@@ -1,81 +0,0 @@
-/**
- * Text views an edit is matched against.
- *
- * A model never sees the bytes of a file, only read's rendering of them:
- * no byte order mark, no carriage returns. An edit copied from that
- * rendering has to be matched against the same view and written back in the
- * file's own encoding -- otherwise every edit to a CRLF file fails, however
- * exactly the model copied what it was shown.
- */
-
-export interface TextView {
-  /** Content with the BOM removed and every line ending as `\n`. */
-  text: string;
-  bom: boolean;
-  /** Decided by the first line ending, as pi does; mixed files take the first. */
-  ending: "\n" | "\r\n";
-}
-
-export function toView(raw: string): TextView {
-  const bom = raw.startsWith("");
-  const body = bom ? raw.slice(1) : raw;
-  const lf = body.indexOf("\n");
-  const ending = lf > 0 && body[lf - 1] === "\r" ? "\r\n" : "\n";
-  return { text: toLF(body), bom, ending };
-}
-
-export function fromView(view: TextView, text: string): string {
-  return (view.bom ? "" : "") + (view.ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text);
-}
-
-export function toLF(text: string): string {
-  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-
-/**
- * The equivalence a copied snippet is allowed to differ by.
- *
- * Each rule is a known way a model's copy drifts from the file: trailing
- * whitespace dropped, typographic quotes and dashes straightened, exotic
- * spaces turned into plain ones, compatibility forms folded (NFKC). Ported
- * from pi-mono `edit-diff.ts` `normalizeForFuzzyMatch` (MIT, 6f75515).
- *
- * The line count is preserved -- no rule adds or removes a `\n` -- which is
- * what lets a match found here be mapped back onto whole lines of the
- * original, leaving every untouched line byte for byte as it was.
- */
-export function normalizeLoose(text: string): string {
-  return text
-    .normalize("NFKC")
-    .split("\n")
-    .map((line) => line.trimEnd())
-    .join("\n")
-    .replace(/[‘’‚‛]/g, "'")
-    .replace(/[“”„‟]/g, "\"")
-    .replace(/[‐‑‒–—―−]/g, "-")
-    .replace(/[  -   　]/g, " ");
-}
-
-/** Levenshtein distance with the row buffer reused; inputs are bounded by callers. */
-export function editDistance(a: string, b: string): number {
-  if (a === b) return 0;
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
-  let current = new Array<number>(b.length + 1);
-  for (let i = 1; i <= a.length; i++) {
-    current[0] = i;
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
-      current[j] = Math.min(previous[j]! + 1, current[j - 1]! + 1, previous[j - 1]! + cost);
-    }
-    [previous, current] = [current, previous];
-  }
-  return previous[b.length]!;
-}
-
-/** 1 for identical, 0 for nothing in common. */
-export function similarity(a: string, b: string): number {
-  const longest = Math.max(a.length, b.length);
-  return longest === 0 ? 1 : 1 - editDistance(a, b) / longest;
-}