@visual-z/xeno 0.8.4 → 0.9.1

package/src/core/request-state.ts

@@ -1,273 +0,0 @@
-/**
- * The request ledger (S.1, Q23 / D8 / D11): what the current request has
- * evidence for, derived only from the selected log ancestry.
- *
- * Every view of "is this request done" -- the completion check, the goal
- * panel, terminal status, branch receipts -- maps from this one derivation,
- * so they cannot disagree. Only harness-observed facts move it: command
- * receipts with their workspace fingerprints, file versions, and the user's
- * acceptance decisions. A model note can describe a blocker; it never changes
- * the status.
- */
-import type { LogEvent } from "./events.ts";
-import { counterVerdict, deriveAcceptance, type AcceptanceState, type CounterVerdict } from "./acceptance.ts";
-import { changedPaths, workspaceChanged } from "./checkpoints.ts";
-import { evidenceStale, isCommandResult, resolveEvidence } from "./evidence.ts";
-import { executionOutcome, modelOutcome, type ExecutionOutcome } from "./outcome.ts";
-import { deriveWorkItems, type WorkItem } from "./work-state.ts";
-import { deriveRequestProgress, type RequestProgress, type RequestRecord, type RequestSource } from "./request-progress.ts";
-
-export type RequestPart = { node: number; events: readonly LogEvent[] };
-export type RequestCommand = {
-  source: RequestSource; command: string; exit: number; status: "pass" | "fail" | "stale" | "superseded";
-  gate?: string; workspace_sha256?: string; workspace_scope?: "source-v1"; criteria: string[];
-};
-export type RequestArtifact = { source: RequestSource; path: string; sha256: string | null;
-  kind: "read" | "edit" | "checkpoint" | "command_output" };
-
-/**
- * One requirement this request must meet. With a declared contract these are
- * its criteria. Without one, a request that changed the workspace still has
- * one requirement: a successful check after its last change.
- */
-export type RequestCriterion = {
-  id: string; kind: "command" | "human" | "fresh_check"; description: string;
-  status: "pass" | "fail" | "stale" | "not_run" | "awaiting_human" | "accepted";
-  command?: string; evidence?: string;
-  /** A declared guard: it must pass before and after the work, rather than fail before it (S.7). */
-  guard?: true;
-  /** The latest counter-check of this criterion in the request, when one ran, read against its role. */
-  counter?: CounterVerdict;
-  /**
-   * Consecutive runs of this exact command that failed with the same exit code
-   * against the same workspace. Two or more mean rerunning it unchanged will
-   * not change the answer: the work, or the check itself, must change.
-   */
-  repeated_failures?: number;
-  /** A fresh check under strict verification: only a configured gate counts (O.11). */
-  gate_only?: true;
-};
-
-/** The rungs of the evidence ladder this derivation can establish. */
-export type RequestEvidence = {
-  /** Every required check ran successfully against the current workspace. */
-  ran: "pass" | "fail" | "stale" | "missing" | "not_applicable";
-  /** Every required human criterion was accepted by the user. */
-  human: "accepted" | "pending" | "not_required";
-  /**
-   * Every passing check meant to test the change failed once this request's
-   * changes were undone (feat-counter-check). `missing`: every check is a guard
-   * that held, so nothing shows the work changed anything (S.7).
-   */
-  discriminating: "pass" | "vacuous" | "unavailable" | "not_run" | "missing" | "not_applicable";
-  /** Blind checks the model never touched passed on the final result (feat-blind-checks). */
-  independent: "pass" | "fail" | "exposed" | "unavailable" | "not_run" | "not_applicable";
-};
-
-export type RequestStatus = "not_applicable" | "unchecked" | "checked" | "needs_work" | "awaiting_human" | "verified";
-
-export type RequestState = {
-  request: RequestSource; inputs: RequestSource[];
-  /**
-   * Without a contract: not_applicable (nothing changed), unchecked, or
-   * checked. With one: needs_work, awaiting_human, verified, or
-   * not_applicable for a changes-scoped contract over an unchanged workspace.
-   */
-  status: RequestStatus;
-  criteria: RequestCriterion[]; evidence: RequestEvidence; unmet: string[];
-  execution?: ExecutionOutcome; acceptance?: AcceptanceState;
-  commands: RequestCommand[]; artifacts: RequestArtifact[]; work: WorkItem[];
-  /** What the model said blocks it. Shown to the user; never a verdict (D11). */
-  reported_blockers: { source: RequestSource; reason: string }[];
-  progress: RequestProgress;
-  changed: boolean; used_tools: boolean; reviewed: boolean;
-  final?: { source: RequestSource; text: string; has_tools: boolean };
-};
-
-export type LedgerOptions = {
-  /** The CLI's strict verification: only a configured gate command counts as the fresh check. */
-  strict?: boolean;
-  /** The session declares blind checks, so their absence means "not run" rather than "not applicable". */
-  blind?: boolean;
-};
-
-/** New steering events refer to their original user event. A user event without that link opens a request. */
-export function currentRequestRecords(parts: readonly RequestPart[]): RequestRecord[] {
-  const records = parts.flatMap(part => part.events.map(event => ({ node: part.node, event })));
-  const last = records.findLastIndex(({ event }) => event.t === "user");
-  if (last < 0) return [];
-  const user = records[last]!.event;
-  if (user.t !== "user") return [];
-  const start = user.request === undefined ? last : records.findIndex(({ event }) => event.t === "user" && event.id === user.request);
-  // Never reach through an unrelated user request because of an invalid reference.
-  if (start < 0 || records.slice(start + 1, last + 1).some(({ event }) => event.t === "user" && event.request !== user.request)) return records.slice(last);
-  return records.slice(start);
-}
-
-/**
- * The current request's events in one flat stream: the one slicer every
- * per-request notice uses, so steering never restarts a request's budget,
- * notices or failure counts. Empty when the stream holds no user event.
- */
-export function currentRequestEvents(events: readonly LogEvent[]): LogEvent[] {
-  return currentRequestRecords([{ node: 0, events }]).map(record => record.event);
-}
-
-const FRESH_CHECK = "a successful check after the last change";
-
-export function deriveRequestState(parts: readonly RequestPart[], options: LedgerOptions = {}): RequestState | undefined {
-  const records = currentRequestRecords(parts);
-  const first = records[0];
-  if (!first) return undefined;
-  const events = records.map(record => record.event);
-  const source = ({ node, event }: RequestRecord): RequestSource => ({ node, event: event.id });
-  const request = source(first);
-  const acceptance = deriveAcceptance(undefined, events.filter(event => event.t !== "acceptance_contract" || event.request === request.event));
-  const commands: (RequestCommand & { index: number })[] = [], artifacts: RequestArtifact[] = [];
-  const lastCommands = new Map<string, string>();
-  for (const event of events) if (isCommandResult(event)) lastCommands.set(event.effect.cmd, event.id);
-  let work: WorkItem[] = [];
-  const ids = new Set(events.map(event => event.id)), completed = new Set<string>();
-  // Keep the existing work-item same-segment evidence contract (D11/O.2).
-  for (const part of parts) {
-    work = deriveWorkItems(work, part.events);
-    for (let index = 0; index < part.events.length; index++) {
-      const event = part.events[index]!;
-      // Untyped completed claims supersede a same-named blocker only when the
-      // original same-segment evidence resolves, just as in deriveHandoff.
-      if (event.t === "claim" && event.work_id === undefined && ids.has(event.id) &&
-          resolveEvidence(part.events.slice(0, index), event.evidence).ok) completed.add(event.what);
-    }
-  }
-  work = work.filter(item => ids.has(item.opened_at) || ids.has(item.updated_at));
-  const reported_blockers: RequestState["reported_blockers"] = [];
-  let execution: ExecutionOutcome | undefined, final: RequestState["final"], changed = false, lastChange = -1;
-  records.forEach((record, index) => {
-    const event = record.event, ref = source(record);
-    if (event.t === "user") { execution = undefined; final = undefined; }
-    else if (event.t === "assistant") {
-      final = { source: ref, text: event.blocks.flatMap(block => block.type === "text" ? [block.text] : []).join("\n").trim(),
-        has_tools: event.blocks.some(block => block.type === "tool_use") };
-      execution = final.has_tools ? undefined : modelOutcome(event.stop_reason ?? null);
-    } else if (event.t === "outcome") execution = { ...event.outcome };
-    else if (event.t === "interrupt") execution = executionOutcome("cancelled");
-    else if (event.t === "guidance" && (event.reason === "completion_review" || event.reason === "output_recovery")) execution = undefined;
-    if (event.t === "blocked" && (event.work_id ? work.some(item => item.id === event.work_id && item.status === "blocked") : !completed.has(event.what))) {
-      reported_blockers.push({ source: ref, reason: event.reason });
-    }
-    if (workspaceChanged(event)) { changed = true; lastChange = index; }
-    if (isCommandResult(event)) {
-      const effect = event.effect;
-      const evidence = { command: effect.cmd, exit: effect.exit, event_id: event.id, at: event.at,
-        ...(effect.workspace_sha256 === undefined ? {} : { workspace_sha256: effect.workspace_sha256 }),
-        ...(effect.workspace_scope === undefined ? {} : { workspace_scope: effect.workspace_scope }) };
-      commands.push({ index, source: ref, command: effect.cmd, exit: effect.exit,
-        status: !event.ok || effect.exit !== 0 ? "fail" : effect.workspace_observed === false || evidenceStale(events, evidence) ? "stale"
-          : lastCommands.get(effect.cmd) !== event.id ? "superseded" : "pass",
-        ...(effect.gate === undefined ? {} : { gate: effect.gate }),
-        ...(effect.workspace_sha256 === undefined ? {} : { workspace_sha256: effect.workspace_sha256 }),
-        ...(effect.workspace_scope === undefined ? {} : { workspace_scope: effect.workspace_scope }),
-        criteria: acceptance?.criteria.filter(item => item.kind === "command" && item.command === effect.cmd).map(item => item.id) ?? [] });
-      for (const output of effect.artifacts?.outputs ?? []) if (output.after.state === "observed") artifacts.push({
-        source: ref, path: output.path, sha256: output.after.sha256, kind: "command_output" });
-    } else if (event.t === "tool_result" && (event.effect?.kind === "read" || event.effect?.kind === "edit")) {
-      const effect = event.effect;
-      artifacts.push({ source: ref, path: effect.path, sha256: effect.kind === "read" ? effect.sha256 : effect.sha256_after, kind: effect.kind });
-    } else if (event.t === "checkpoint" && event.phase === "applied") {
-      for (const path of changedPaths(event.changes)) artifacts.push({ source: ref, path, sha256: event.changes[path]!.after?.sha256 ?? null, kind: "checkpoint" });
-    }
-  });
-
-  const ledger = acceptance ? contractLedger(acceptance) : freshCheckLedger(commands, changed, lastChange, options);
-  const { criteria, status } = ledger;
-  for (const event of events) if (event.t === "counter_check" && event.request === request.event) {
-    const criterion = criteria.find(item => item.id === event.criterion && item.kind === "command");
-    if (criterion) criterion.counter = counterVerdict(event);
-  }
-  for (const criterion of criteria) if (criterion.kind === "command" && criterion.command && criterion.status === "fail") {
-    const runs = commands.filter(command => command.command === criterion.command);
-    const last = runs.at(-1);
-    let streak = 0;
-    for (let i = runs.length - 1; i >= 0; i--) {
-      const run = runs[i]!;
-      if (run.status !== "fail" || run.exit !== last!.exit || run.workspace_sha256 === undefined || run.workspace_sha256 !== last!.workspace_sha256) break;
-      streak++;
-    }
-    if (streak >= 2) criterion.repeated_failures = streak;
-  }
-  const blind = new Map<string, Extract<LogEvent, { t: "blind_check" }>>();
-  for (const event of events) if (event.t === "blind_check" && event.request === request.event) blind.set(event.check, event);
-  const blindRuns = [...blind.values()];
-  const independent: RequestEvidence["independent"] = blindRuns.length === 0 ? (options.blind ? "not_run" : "not_applicable")
-    : blindRuns.some(run => "exit" in run && run.exit !== 0) ? "fail" : blindRuns.some(run => "reason" in run) ? "unavailable"
-    : blindRuns.some(run => run.exposed) ? "exposed" : "pass";
-  const evidence: RequestEvidence = { ...ledger.evidence, independent, discriminating: testsTheChange(criteria) };
-  const unmet = criteria.filter(item => item.status !== "pass" && item.status !== "accepted").map(item => `${item.description}: ${item.status}`);
-  return { request, inputs: records.filter(record => record.event.t === "user").map(source),
-    status, criteria, evidence, unmet,
-    ...(execution ? { execution } : {}), ...(acceptance ? { acceptance } : {}),
-    commands: commands.map(({ index: _index, ...command }) => command), artifacts, work, reported_blockers,
-    progress: deriveRequestProgress(records), changed,
-    used_tools: events.some(event => event.t === "tool_result"),
-    reviewed: events.some(event => event.t === "guidance" && event.reason === "completion_review"),
-    ...(final ? { final } : {}) };
-}
-
-/**
- * The discriminating rung (S.1, S.7), decided by the checks meant to test the
- * change: each must fail once the request's changes are undone. A guard that
- * held is what a guard should do, so it neither fails the rung nor holds it
- * back. A guard that did not hold does test the change -- the observation
- * outranks the declaration (D11) -- so it counts for the rung. With only
- * guards, all held, nothing shows the work changed anything: missing. A
- * passing fresh check is a check like any declared command and must test the
- * change too.
- */
-function testsTheChange(criteria: readonly RequestCriterion[]): RequestEvidence["discriminating"] {
-  const tests = criteria.filter(item => item.kind === "command" && !item.guard || item.kind === "fresh_check" && item.status === "pass");
-  const guards = criteria.filter(item => item.kind === "command" && item.guard);
-  if (tests.length === 0 && guards.length === 0) return "not_applicable";
-  if (tests.some(item => item.counter === "vacuous")) return "vacuous";
-  if (tests.some(item => item.counter === "unavailable")) return "unavailable";
-  if (tests.some(item => item.counter !== "discriminating")) return "not_run";
-  if (tests.length > 0 || guards.some(item => item.counter === "not_held")) return "pass";
-  if (guards.some(item => item.counter === "unavailable")) return "unavailable";
-  return guards.every(item => item.counter === "held") ? "missing" : "not_run";
-}
-
-/** A declared contract defines what this request must finish (O.11); nothing is inferred beyond it. */
-type LedgerCore = Pick<RequestState, "criteria" | "status"> & { evidence: Omit<RequestEvidence, "discriminating" | "independent"> };
-
-function contractLedger(acceptance: AcceptanceState): LedgerCore {
-  const criteria: RequestCriterion[] = acceptance.criteria.map(item => ({ id: item.id, kind: item.kind, description: item.description,
-    status: item.status, ...(item.kind === "command" ? { command: item.command, ...(item.guard ? { guard: true as const } : {}) } : {}),
-    ...(item.evidence ? { evidence: item.evidence.event_id } : item.accepted_event ? { evidence: item.accepted_event } : {}) }));
-  const checks = criteria.filter(item => item.kind === "command"), humans = criteria.filter(item => item.kind === "human");
-  const targetsReady = (acceptance.targets ?? []).every(target => target.status === "ready");
-  const ran: RequestEvidence["ran"] = checks.length === 0 ? "not_applicable"
-    : checks.every(item => item.status === "pass") && targetsReady ? "pass"
-    : checks.some(item => item.status === "fail") ? "fail" : checks.some(item => item.status === "stale") ? "stale" : "missing";
-  return { criteria, status: acceptance.status,
-    evidence: { ran, human: humans.length === 0 ? "not_required" : humans.every(item => item.status === "accepted") ? "accepted" : "pending" } };
-}
-
-/**
- * Without a contract, a request that changed the workspace still owes one
- * thing: a successful check against the changed workspace. That is all an
- * exit code can say -- not that the request's words were met -- so the status
- * is "checked", never "verified".
- */
-function freshCheckLedger(commands: readonly (RequestCommand & { index: number })[], changed: boolean, lastChange: number,
-  options: LedgerOptions): LedgerCore {
-  const none = { human: "not_required" as const };
-  if (!changed) return { criteria: [], status: "not_applicable", evidence: { ran: "not_applicable", ...none } };
-  const after = commands.filter(command => command.index > lastChange && (!options.strict || command.gate !== undefined));
-  const pass = after.find(command => command.status === "pass");
-  const status: RequestCriterion["status"] = pass ? "pass" : after.some(command => command.status === "fail") ? "fail"
-    : after.some(command => command.status === "stale") ? "stale" : "not_run";
-  const criterion: RequestCriterion = { id: "fresh-check", kind: "fresh_check",
-    description: options.strict ? `${FRESH_CHECK} (a configured gate)` : FRESH_CHECK, status, ...(options.strict ? { gate_only: true as const } : {}),
-    ...(pass ? { command: pass.command, evidence: pass.source.event } : {}) };
-  return { criteria: [criterion], status: pass ? "checked" : "unchecked",
-    evidence: { ran: status === "pass" ? "pass" : status === "not_run" ? "missing" : status, ...none } };
-}

package/src/core/resource-selection.ts

@@ -1,36 +0,0 @@
-/** Pi +/-/! resource choices; discovery and path resolution belong to store. */
-export type ResourceKind = "skills" | "prompts" | "themes" | "extensions";
-export type ResourceScope = "user" | "project" | "cli";
-export type ResourceOverride = "inherit" | "load" | "skip";
-export interface ResourceEntry {
-  kind: ResourceKind;
-  path: string;
-  name: string;
-  scope: ResourceScope;
-  source: string;
-  enabled: boolean;
-  inherited: boolean;
-  override: ResourceOverride;
-  trusted: boolean;
-  package?: { source: string; identity: string; root: string };
-}
-export interface ResourcePattern { pattern: string; enabled: boolean; explicit: boolean }
-export function parseResourcePattern(raw: string): ResourcePattern {
-  const first = raw[0];
-  return { pattern: ["+", "-", "!"].includes(first ?? "") ? raw.slice(1) : raw,
-    enabled: first !== "-" && first !== "!", explicit: first === "+" || first === "-" };
-}
-export function resourceOverride(patterns: readonly string[], matches: (pattern: string) => boolean): ResourceOverride {
-  let result: ResourceOverride = "inherit";
-  for (const raw of patterns) { const choice = parseResourcePattern(raw); if (matches(choice.pattern)) result = choice.enabled ? "load" : "skip"; }
-  return result;
-}
-export function updateResourcePatterns(patterns: readonly string[], path: string, state: ResourceOverride,
-  same: (pattern: string) => boolean): string[] {
-  const next = patterns.filter(raw => !same(parseResourcePattern(raw).pattern));
-  if (state !== "inherit") next.push((state === "load" ? "+" : "-") + path);
-  return next;
-}
-export function nextResourceOverride(state: ResourceOverride): ResourceOverride {
-  return state === "inherit" ? "load" : state === "load" ? "skip" : "inherit";
-}

package/src/core/response-recovery.ts

@@ -1,59 +0,0 @@
-/** N.12: a returned response is durable evidence, not necessarily a completed action. */
-import type { AssistantBlock, GuidanceEvent, LogEvent } from "./events.ts";
-import { currentRequestEvents } from "./request-state.ts";
-
-// One appended attempt is an operational assumption, not a measured optimum.
-// It shares the existing request ceiling and never replays a tool automatically.
-export const DEFAULT_OUTPUT_RECOVERY_LIMIT = 1;
-
-export function validateOutputRecoveryLimit(limit: number): void {
-  if (!Number.isSafeInteger(limit) || limit < 0) throw new RangeError("output recovery limit must be a nonnegative safe integer");
-}
-
-/** Both wire dialects have explicit terminal reasons; an unknown reason is not success. */
-export function isCompleteResponse(reason: string | null | undefined): boolean {
-  return reason !== undefined && reason !== null && ["stop", "end_turn", "stop_sequence", "tool_calls", "tool_use"].includes(reason);
-}
-
-/**
- * A stop that asks for tool execution must carry a tool call. One that does not
- * is a malformed provider response, not the model's answer: taken as a final
- * reply it ends the request with outcome unknown and nothing on screen
- * (session mv28chr8-oc3x, an Anthropic-compatible gateway returning
- * `stop_reason: tool_use` with no content). Adapters reject it inside their
- * retry so the loop only sees a coherent turn or a definite failure.
- */
-export function isToolStopWithoutCall(stopReason: string | null | undefined, blocks: readonly AssistantBlock[]): boolean {
-  return (stopReason === "tool_use" || stopReason === "tool_calls") && !blocks.some(block => block.type === "tool_use");
-}
-
-export function isOutputLimit(reason: string | null | undefined): boolean {
-  return reason === "length" || reason === "max_tokens";
-}
-
-export function incompleteToolText(reason: string | null | undefined): string {
-  return `not executed: the model response ${isOutputLimit(reason) ? "reached its output limit" : "did not finish successfully"}; ` +
-    "no tools from that response were run. Regenerate a complete call only if the action is still needed.";
-}
-
-/** Explicit metadata proves non-execution; legacy pending calls remain unknown (D11). */
-export function knownUnexecutedTool(events: readonly LogEvent[], callId: string): string | null {
-  const owner = events.findLast(event => event.t === "assistant" && event.blocks.some(block => block.type === "tool_use" && block.call_id === callId));
-  return owner?.t === "assistant" && owner.stop_reason !== undefined && !isCompleteResponse(owner.stop_reason)
-    ? incompleteToolText(owner.stop_reason) : null;
-}
-
-/** Supply effective ancestry, not only the current segment: cutting must not reset this limit. */
-export function outputRecoveryNotice(events: readonly LogEvent[], limit: number, remainingRequests: number):
-  Pick<GuidanceEvent, "reason" | "sources" | "text"> | null {
-  validateOutputRecoveryLimit(limit);
-  const current = currentRequestEvents(events).slice(1);
-  const assistant = current.findLast(event => event.t === "assistant");
-  const notices = current.filter(event => event.t === "guidance" && event.reason === "output_recovery");
-  if (assistant?.t !== "assistant" || !isOutputLimit(assistant.stop_reason) || notices.length >= limit || remainingRequests < 1 ||
-      notices.some(event => event.t === "guidance" && event.sources.includes(assistant.id))) return null;
-  return { reason: "output_recovery", sources: [assistant.id], text:
-    "Harness: the previous response hit its output token limit and is incomplete. All tool calls in that response were left unexecuted. " +
-    "Continue from the existing evidence, avoid repeating the earlier analysis, and give a concise result or the next necessary complete tool call. " +
-    "Do not claim unexecuted actions succeeded. This recovery consumes the existing request allowance." };
-}

package/src/core/resume.ts

@@ -1,59 +0,0 @@
-/**
- * Picking a session back up where it stopped.
- *
- * Pure: it decides, given a recorded cursor and the model about to run, what
- * should happen. Doing the reading and the refusing in separate places keeps
- * the one interesting rule -- when a resume is unsafe -- testable without a
- * filesystem.
- */
-
-import type { SavedModel } from "./session-entry.ts";
-
-export type ResumePlan<T extends SavedModel> =
-  | { kind: "fresh" }
-  | { kind: "resume"; cursor: T }
-  | { kind: "refuse"; reason: string };
-
-/**
- * A session's thinking blocks belong to the model that produced them.
- *
- * Same-model resume preserves the original projection. An explicit model
- * change uses Session.switchModel after opening with the recorded identity
- * (N.8); it never reinterprets signed or opaque thinking during replay.
- */
-export function planResume<T extends SavedModel>(
-  cursor: T | null,
-  model: string,
-  hasNodes: boolean,
-  provider?: string,
-): ResumePlan<T> {
-  if (cursor === null) {
-    // No cursor and no nodes is simply a new session. No cursor but nodes on
-    // disk is a log this build cannot place itself in -- written before the
-    // cursor existed, or with a manifest that was lost. Refused rather than
-    // guessed: the whole reason the cursor is recorded is that the tree shape
-    // cannot be read backwards to find it, and inventing an answer here would
-    // reintroduce exactly the ambiguity it exists to remove.
-    return hasNodes
-      ? {
-          kind: "refuse",
-          reason:
-            "this log has nodes but no recorded cursor, so there is no way to " +
-            "know which one the session was in. It is intact and nothing will " +
-            "be touched -- start a separate session with --fresh",
-        }
-      : { kind: "fresh" };
-  }
-  if (cursor.model !== model || (cursor.provider !== undefined && cursor.provider !== provider)) {
-    const saved = cursor.provider === undefined ? cursor.model : `${cursor.provider}/${cursor.model}`;
-    const target = provider === undefined ? model : `${provider}/${model}`;
-    return {
-      kind: "refuse",
-      reason:
-        `this session ran under ${saved}, and ${target} cannot replay its ` +
-        `thinking blocks. Resume it with --model ${saved}, or start a ` +
-        `separate session with --fresh`,
-    };
-  }
-  return { kind: "resume", cursor };
-}

package/src/core/review.ts

@@ -1,68 +0,0 @@
-/** Review scopes and checkpoint projection are data, never authorization (D8 / D11). */
-import type { LogEvent } from "./events.ts";
-import { sameVersion, changedPaths, type FileChanges } from "./checkpoints.ts";
-export type ReviewScope = { kind: "working" } | { kind: "branch"; base: string } |
-  { kind: "commit"; commit: string } | { kind: "last-turn" };
-export interface ReviewSnapshot {
-  scope: ReviewScope;
-  label: string;
-  diff: string;
-  paths: string[];
-  limitations: string[];
-  /** Resolved commits are immutable review premises, never raw shell expressions. */
-  base?: string;
-}
-
-/** Fold observed operations after the latest request; uncaptured effects remain unknown. */
-export function lastTurnChanges(events: readonly LogEvent[]): { changes: FileChanges; limitations: string[] } {
-  let start = 0;
-  for (let i = events.length - 1; i >= 0; i--) if (events[i]!.t === "user" || events[i]!.t === "user_bash") { start = i + 1; break; }
-  const changes: FileChanges = Object.create(null) as FileChanges;
-  const limitations = new Set<string>(["Last-turn diff covers durable file checkpoints; uncaptured command or external changes are unknown."]);
-  const suffix = events.slice(start);
-  const finalPhases = new Map(suffix.filter(event => event.t === "checkpoint").map(event => [event.operation, event.phase]));
-  for (const event of suffix) {
-    if (event.t !== "checkpoint") continue;
-    if (event.phase === "unavailable" && finalPhases.get(event.operation) !== "applied") limitations.add(event.reason ?? "A file checkpoint is unavailable.");
-    if (event.phase !== "applied" || finalPhases.get(event.operation) !== "applied") continue;
-    for (const path of changedPaths(event.changes)) {
-      const next = event.changes[path]!, previous = changes[path];
-      if (previous && !sameVersion(previous.after, next.before)) throw new Error(`discontinuous last-turn checkpoint: ${path}; external changes cannot be attributed`);
-      changes[path] = { before: previous ? previous.before : next.before, after: next.after };
-    }
-  }
-  return { changes: Object.fromEntries(changedPaths(changes).map(path => [path, changes[path]!])), limitations: [...limitations] };
-}
-
-/** A linear contiguous hunk avoids quadratic whole-file diff memory. No bytes are omitted. */
-export function unifiedFileDiff(path: string, before: string | null, after: string | null, destination = path): string {
-  if (before === after && path === destination) return "";
-  const lines = (text: string | null): { text: string; newline: boolean }[] => {
-    if (!text) return [];
-    const result = text.split("\n");
-    if (text.endsWith("\n")) result.pop();
-    return result.map((line, index) => ({ text: line, newline: index < result.length - 1 || text.endsWith("\n") }));
-  };
-  const oldLines = lines(before), newLines = lines(after);
-  const equal = (left: typeof oldLines[number] | undefined, right: typeof oldLines[number] | undefined) =>
-    left !== undefined && right !== undefined && left.text === right.text && left.newline === right.newline;
-  let prefix = 0, suffix = 0;
-  while (prefix < oldLines.length && prefix < newLines.length && equal(oldLines[prefix], newLines[prefix])) prefix++;
-  while (suffix < oldLines.length - prefix && suffix < newLines.length - prefix && equal(oldLines.at(-suffix - 1), newLines.at(-suffix - 1))) suffix++;
-  // Assumed familiar Git default: retain three lines of unchanged context per side.
-  const start = Math.max(0, prefix - 3), oldEnd = Math.min(oldLines.length, oldLines.length - suffix + 3), newEnd = Math.min(newLines.length, newLines.length - suffix + 3);
-  const quoted = (value: string) => /[\s"\\]/.test(value) ? JSON.stringify(value) : value;
-  const emit = (entries: typeof oldLines, marker: string) => entries.flatMap(line =>
-    [marker + line.text, ...(line.newline ? [] : ["\"])]);
-  const body = [...emit(oldLines.slice(start, prefix), " "),
-    ...emit(oldLines.slice(prefix, oldLines.length - suffix), "-"),
-    ...emit(newLines.slice(prefix, newLines.length - suffix), "+"),
-    ...emit(oldLines.slice(oldLines.length - suffix, oldEnd), " ")];
-  const range = (count: number) => count ? start + 1 : 0;
-  const oldCount = oldEnd - start, newCount = newEnd - start;
-  const headers = [`diff --git ${quoted("a/" + path)} ${quoted("b/" + destination)}`,
-    ...(path === destination ? [] : [`rename from ${quoted(path)}`, `rename to ${quoted(destination)}`]),
-    `--- ${before === null ? "/dev/null" : quoted("a/" + path)}`, `+++ ${after === null ? "/dev/null" : quoted("b/" + destination)}`];
-  if (body.length) headers.push(`@@ -${range(oldCount)},${oldCount} +${range(newCount)},${newCount} @@`, ...body);
-  return headers.join("\n") + "\n";
-}

package/src/core/ripgrep-release.ts

@@ -1,64 +0,0 @@
-/**
- * The one ripgrep build xeno will install, per platform.
- *
- * Models write `rg` in shell commands because the harnesses they were trained
- * in ship it (Claude Code bundles it; Pi downloads it on first use). On a
- * machine without it every such command exits 127 and costs a request. xeno
- * installs it only when the user has none, and only this exact archive:
- * running a binary fetched from the network needs proof that it is the one
- * reviewed, which a pinned digest gives and "latest" (Pi's choice) does not.
- *
- * Digests are the upstream release's published `.sha256` files for 14.1.1;
- * the aarch64-apple-darwin archive was also downloaded and hashed locally on
- * 2026-10-11 and matched. Upgrading means changing this table and releasing.
- */
-import { truthy } from "./update-check.ts";
-
-export const RIPGREP_VERSION = "14.1.1";
-
-export interface RipgrepAsset {
-  readonly url: string;
-  readonly sha256: string;
-  /** Archive member holding the executable; nothing else is extracted. */
-  readonly member: string;
-}
-
-const DIGESTS: Readonly<Record<string, string>> = {
-  "aarch64-apple-darwin": "24ad76777745fbff131c8fbc466742b011f925bfa4fffa2ded6def23b5b937be",
-  "x86_64-apple-darwin": "fc87e78f7cb3fea12d69072e7ef3b21509754717b746368fd40d88963630e2b3",
-  // musl is static, so it runs on glibc and musl distributions alike.
-  "x86_64-unknown-linux-musl": "4cf9f2741e6c465ffdb7c26f38056a59e2a2544b51f7cc128ef28337eeae4d8e",
-  // 14.1.1 publishes no aarch64 musl build; this one needs glibc.
-  "aarch64-unknown-linux-gnu": "c827481c4ff4ea10c9dc7a4022c8de5db34a5737cb74484d62eb94a95841ab2f",
-};
-
-function target(platform: string, arch: string): string | null {
-  if (platform === "darwin") return arch === "arm64" ? "aarch64-apple-darwin" : arch === "x64" ? "x86_64-apple-darwin" : null;
-  if (platform === "linux") return arch === "arm64" ? "aarch64-unknown-linux-gnu" : arch === "x64" ? "x86_64-unknown-linux-musl" : null;
-  return null;
-}
-
-/** Null for platforms without a pinned build: those keep the TypeScript search. */
-export function ripgrepAsset(platform: string, arch: string): RipgrepAsset | null {
-  const triple = target(platform, arch);
-  if (triple === null) return null;
-  const name = `ripgrep-${RIPGREP_VERSION}-${triple}`;
-  return {
-    url: `https://github.com/BurntSushi/ripgrep/releases/download/${RIPGREP_VERSION}/${name}.tar.gz`,
-    sha256: DIGESTS[triple]!,
-    member: `${name}/rg`,
-  };
-}
-
-/**
- * Whether xeno may fetch the binary on its own, in the background.
- *
- * The same occasions the update check stays off the network (core/update-check.ts):
- * offline, CI, and a source checkout -- the last is also what keeps test
- * subprocesses, which run the CLI from this repository, from downloading.
- * XENO_NO_TOOL_INSTALL opts out explicitly; the user's own rg makes it moot.
- */
-export function toolInstallAllowed(input: { env: Readonly<Record<string, string | undefined>>; offline: boolean; install: string }): boolean {
-  const on = (name: string) => truthy(input.env[name]);
-  return !input.offline && input.install !== "checkout" && !on("XENO_OFFLINE") && !on("XENO_NO_TOOL_INSTALL") && !on("CI") && !on("CONTINUOUS_INTEGRATION");
-}