@visual-z/xeno 0.8.4 → 0.9.0

package/src/core/runtime-target.ts

@@ -1,94 +0,0 @@
-/** R8: declarations select a target; only an owned runtime observation supplies its identity. */
-import { parseCommandArtifactPlan, validArtifactPath, type CommandArtifactPlan } from "./command-artifacts.ts";
-import type { ArtifactRef } from "./events.ts";
-import { isObservationArtifact } from "./observation-view.ts";
-import type { ProcessSource } from "./process-receipt.ts";
-
-export type RuntimeTarget = { id: string; build: string; artifacts: CommandArtifactPlan; entry: string;
-  interpreter?: string; args?: string[]; workdir?: string; port?: number };
-export type TargetBuild = { node: number; event: string; manifest: ArtifactRef };
-export type RuntimeInstance = { id: string; session: number; pid: number; source: ProcessSource;
-  entry: { path: string; sha256: string }; program: { path: string; sha256: string; device: string; inode: string } };
-export type RuntimeTargetReceipt = {
-  kind: "runtime_target"; version: 1; target: string; request: string; contract_event: string;
-  state: "ready" | "not_ready" | "stale" | "unknown"; reason: string; observed_at: string;
-  source: ProcessSource; build?: TargetBuild; instance?: RuntimeInstance; port?: number;
-  checks: { build: boolean; inputs: boolean; artifacts: boolean; process: boolean; image: boolean; port: boolean | null };
-  manifest?: ArtifactRef;
-};
-export type TargetAcceptance = { id: string; build: string; status: "not_run" | RuntimeTargetReceipt["state"];
-  observation?: string; binding?: string; session?: number; pid?: number; entry?: string; port?: number; build_event?: string; reason?: string };
-
-const record = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value);
-const id = (value: unknown): value is string => typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,79}$/.test(value);
-const text = (value: unknown): value is string => typeof value === "string" && value.length > 0;
-const digest = (value: unknown): value is string => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
-const natural = (value: unknown): value is number => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-const source = (value: unknown): value is ProcessSource => record(value) && ["host", "workspace", "cwd", "runtime"].every(key => text(value[key]));
-
-export function parseRuntimeTarget(value: unknown): RuntimeTarget {
-  if (!record(value) || Object.keys(value).some(key => !["id", "build", "artifacts", "entry", "interpreter", "args", "workdir", "port"].includes(key)) ||
-    !id(value["id"]) || !id(value["build"]) || !validArtifactPath(value["entry"])) throw Error("invalid runtime target declaration");
-  const artifacts = parseCommandArtifactPlan(value["artifacts"]);
-  if (!artifacts.paths.includes(value["entry"])) throw Error("target entry must be an observed build artifact");
-  const interpreter = value["interpreter"], args = value["args"], workdir = value["workdir"], port = value["port"];
-  if (interpreter !== undefined && (typeof interpreter !== "string" || !interpreter.startsWith("/") || /[\x00-\x1f\x7f]/.test(interpreter) || interpreter.length > 4096)) throw Error("target interpreter needs an explicit absolute path");
-  // Assumed argv budget prevents declarations from becoming an unbounded prompt or exec payload.
-  if (args !== undefined && (!Array.isArray(args) || args.length > 64 || !args.every(arg => typeof arg === "string" && !arg.includes("\0")) || JSON.stringify(args).length > 8192)) throw Error("target args must be a bounded literal string array");
-  if (workdir !== undefined && workdir !== "." && !validArtifactPath(workdir)) throw Error("target workdir must stay inside the workspace");
-  if (port !== undefined && (!natural(port) || port < 1 || port > 65535)) throw Error("target port must be 1..65535 on IPv4 loopback");
-  return { id: value["id"], build: value["build"], entry: value["entry"], artifacts,
-    ...(interpreter !== undefined ? { interpreter: interpreter as string } : {}), ...(args !== undefined ? { args: [...args as string[]] } : {}),
-    ...(workdir !== undefined ? { workdir: workdir as string } : {}), ...(port !== undefined ? { port: port as number } : {}) };
-}
-
-export function targetIsReady(receipt: Pick<RuntimeTargetReceipt, "build" | "instance" | "checks">): boolean {
-  return receipt.build !== undefined && receipt.instance !== undefined && receipt.checks.build && receipt.checks.inputs && receipt.checks.artifacts &&
-    receipt.checks.process && receipt.checks.image && receipt.checks.port !== false;
-}
-export function isRuntimeTargetReceipt(value: unknown): value is RuntimeTargetReceipt {
-  if (!record(value) || value["kind"] !== "runtime_target" || value["version"] !== 1 || !id(value["target"]) || !text(value["request"]) ||
-    !text(value["contract_event"]) || !text(value["observed_at"]) || !text(value["reason"]) || !source(value["source"]) ||
-    !["ready", "not_ready", "stale", "unknown"].includes(String(value["state"]))) return false;
-  const build = value["build"], instance = value["instance"], checks = value["checks"], port = value["port"];
-  if (build !== undefined && (!record(build) || !natural(build["node"]) || !text(build["event"]) || !isObservationArtifact(build["manifest"]))) return false;
-  if (instance !== undefined && (!record(instance) || !text(instance["id"]) || !natural(instance["session"]) || instance["session"] < 1 ||
-    !natural(instance["pid"]) || instance["pid"] < 1 || !source(instance["source"]) ||
-    !["host", "workspace", "cwd", "runtime"].every(key => (instance["source"] as Record<string, string>)[key] === (value["source"] as Record<string, string>)[key]) ||
-    !record(instance["entry"]) || !text(instance["entry"]["path"]) || !digest(instance["entry"]["sha256"]) ||
-    !record(instance["program"]) || !text(instance["program"]["path"]) || !digest(instance["program"]["sha256"]) ||
-    !text(instance["program"]["device"]) || !text(instance["program"]["inode"]))) return false;
-  if (!record(checks) || !["build", "inputs", "artifacts", "process", "image"].every(key => typeof checks[key] === "boolean") ||
-    !(checks["port"] === null || typeof checks["port"] === "boolean") ||
-    (port === undefined ? checks["port"] !== null : !natural(port) || port < 1 || port > 65535 || checks["port"] === null)) return false;
-  if (value["manifest"] !== undefined && !isObservationArtifact(value["manifest"])) return false;
-  return value["state"] !== "ready" || targetIsReady(value as RuntimeTargetReceipt) && isObservationArtifact(value["manifest"]);
-}
-
-/** lsof -F0 is a field protocol; matching a process name or display substring proves nothing. */
-export function lsofFiles(output: string, pid: number): Record<string, string>[] {
-  let process = -1, file: Record<string, string> | undefined;
-  const files: Record<string, string>[] = [];
-  for (const chunk of output.split("\0")) {
-    const field = chunk.replace(/^\n/, "");
-    if (!field) continue;
-    const key = field[0]!, value = field.slice(1);
-    if (key === "p") { process = Number(value); file = undefined; }
-    else if (key === "f") { file = { f: value }; if (process === pid) files.push(file); }
-    else if (file && process === pid) {
-      if (key === "T") { const split = value.indexOf("="); if (split > 0) file[`T${value.slice(0, split)}`] = value.slice(split + 1); }
-      else file[key] = value;
-    }
-  }
-  return files;
-}
-export function lsofOwnsImage(output: string, pid: number, device: string, inode: string): boolean {
-  return lsofFiles(output, pid).some(file => {
-    if (file["f"] !== "txt" || file["i"] !== inode || !/^0x[0-9a-f]+$/i.test(file["D"] ?? "")) return false;
-    try { return BigInt(file["D"]!) === BigInt(device); } catch { return false; }
-  });
-}
-export function lsofOwnsPort(output: string, pid: number, port: number): boolean {
-  return lsofFiles(output, pid).some(file => file["t"] === "IPv4" && file["P"] === "TCP" && file["TST"] === "LISTEN" &&
-    ["*", "127.0.0.1"].some(host => file["n"] === `${host}:${port}`));
-}

package/src/core/scheduling.ts

@@ -1,8 +0,0 @@
-/** O.5: shared work may overlap only before the next exclusive barrier. */
-export function schedulingWindow(modes: readonly ("parallel" | "exclusive")[], start: number, limit: number): number {
-  if (!Number.isSafeInteger(limit) || limit < 1) throw new RangeError("maxParallelTools must be a positive integer");
-  if (modes[start] !== "parallel") return Math.min(start + 1, modes.length);
-  let end = start;
-  while (end < modes.length && modes[end] === "parallel" && end - start < limit) end++;
-  return end;
-}

package/src/core/search-observation.ts

@@ -1,97 +0,0 @@
-/** R2: scan completeness and preview completeness answer different questions. */
-import { headTailSelection, isObservationArtifact, isBytePreview, type BytePreview } from "./observation-view.ts";
-import type { ArtifactRef } from "./events.ts";
-import { artifactRecovery } from "./prompt-policy.ts";
-
-export interface SearchRow { prefix: string; text: string; }
-export interface SearchScan {
-  status: "complete" | "partial" | "unknown";
-  reasons: { code: string; path?: string }[];
-  examined_files: number | null;
-  source_versions: "recorded" | "unknown";
-}
-export interface SearchObservation {
-  engine: "walk" | "ripgrep" | "fd" | "directory";
-  rows: SearchRow[];
-  scan: SearchScan;
-  sources: { path: string; sha256: string }[];
-  raw?: Uint8Array;
-  rawErrors?: Uint8Array;
-  limit: number;
-  empty: string;
-}
-
-export interface SearchReceipt {
-  kind: "search";
-  version: 1;
-  source: { host: string; workspace: string; resource: string };
-  engine: SearchObservation["engine"];
-  scan: { status: SearchScan["status"]; reasons: string[]; examined_files: number | null; source_versions: SearchScan["source_versions"] };
-  matches: number;
-  artifact: ArtifactRef;
-  manifest: ArtifactRef;
-  raw?: ArtifactRef;
-  raw_errors?: ArtifactRef;
-  preview: BytePreview;
-}
-
-const object = (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;
-export function isSearchReceipt(value: unknown): value is SearchReceipt {
-  if (!object(value) || value["kind"] !== "search" || value["version"] !== 1 || !isObservationArtifact(value["artifact"]) || !isObservationArtifact(value["manifest"]) || !natural(value["matches"])) return false;
-  if (!["walk", "ripgrep", "fd", "directory"].includes(String(value["engine"])) || value["raw"] !== undefined && !isObservationArtifact(value["raw"])) return false;
-  if (value["raw_errors"] !== undefined && !isObservationArtifact(value["raw_errors"])) return false;
-  const source = value["source"], scan = value["scan"];
-  if (!object(source) || !["host", "workspace", "resource"].every(key => typeof source[key] === "string" && source[key] !== "")) return false;
-  if (!object(scan) || !["complete", "partial", "unknown"].includes(String(scan["status"])) || !["recorded", "unknown"].includes(String(scan["source_versions"])) ||
-    !Array.isArray(scan["reasons"]) || !scan["reasons"].every(reason => typeof reason === "string") || scan["examined_files"] !== null && !natural(scan["examined_files"])) return false;
-  if (scan["status"] === "complete" && scan["reasons"].length !== 0 || scan["status"] !== "complete" && scan["reasons"].length === 0) return false;
-  return isBytePreview(value["preview"], value["artifact"].bytes);
-}
-
-const encoder = new TextEncoder();
-const bytes = (text: string) => encoder.encode(text).length;
-export const searchObservationText = (rows: readonly SearchRow[]): string => rows.map(row => row.prefix + row.text).join("\n");
-
-/** Map count, per-line, and UTF-8 byte cuts back to the same immutable full observation. */
-export function previewSearchObservation(observation: SearchObservation, artifact: string, maxBytes: number, maxLineChars = 500, notice = "", tools?: readonly string[]) {
-  let text = "", source = 0, view = 0;
-  const spans: { view: number; source: number; bytes: number }[] = [];
-  const mapped = (value: string) => { const size = bytes(value); if (size) spans.push({ view, source, bytes: size }); text += value; view += size; };
-  const synthetic = (value: string) => { text += value; view += bytes(value); };
-  if (notice) synthetic(notice + "\n");
-  const shown = Math.max(0, Math.min(observation.rows.length, observation.limit));
-  for (let index = 0; index < observation.rows.length; index++) {
-    const row = observation.rows[index]!;
-    if (index < shown) {
-      let end = Math.min(maxLineChars, row.text.length);
-      if (end > 0 && end < row.text.length && /[\uD800-\uDBFF]/.test(row.text[end - 1]!)) end--;
-      const kept = row.prefix + row.text.slice(0, end);
-      mapped(kept);
-      if (end < row.text.length) synthetic(`… [line truncated; ${artifactRecovery(artifact, source + bytes(kept), tools)}]`);
-    }
-    source += bytes(row.prefix + row.text);
-    if (index < observation.rows.length - 1) { if (index < shown) mapped("\n"); source++; }
-  }
-  if (!observation.rows.length) synthetic(observation.scan.status === "complete" ? observation.empty : "[No matches observed in the scanned portion]");
-  if (shown < observation.rows.length) synthetic(`[${observation.rows.length - shown} more matches omitted; ${artifactRecovery(artifact, 0, tools)}]`);
-  if (observation.scan.status !== "complete") synthetic(`\n[scan ${observation.scan.status}: ${[...new Set(observation.scan.reasons.map(reason => reason.code === "match_timeout" ? "search cut off: match_timeout" : reason.code))].join(", ")}]`);
-  const previewBytes = encoder.encode(text);
-  const selected = headTailSelection(previewBytes, previewBytes, previewBytes.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(searchObservationText(observation.rows));
-  const semantic = visible.map(([lo, hi]) => new TextDecoder().decode(full.subarray(lo, hi))).join("");
-  return { text: selected.text, semantic, preview: { unit: "utf8_bytes" as const, complete: next === source,
-    visible, next_offset: next === source ? null : next } };
-}

package/src/core/secrets.ts

@@ -1,188 +0,0 @@
-/**
- * Credential redaction at the log boundary (S.9).
- *
- * The log is the only truth and every model request is a projection of it, so
- * a credential that reaches the log is resent on every later request and
- * survives every cut through `objective` and `user_turns` (D2). Masking at
- * projection time would leave the original in an append-only file forever.
- * Redaction therefore happens before an event is written: the secret is
- * replaced by a placeholder, and the value lives in a separate per-session
- * vault that no projection reads.
- *
- * The placeholder is an exact inverse: tools expand it back to the value when
- * they run (OpenHands' SecretRegistry does the same with secret names), and
- * any output that echoes a known value is masked again. A false positive
- * therefore costs readability, never correctness -- an edit whose old_string
- * holds a placeholder still matches the file.
- *
- * Only high-confidence shapes are detected (gitleaks prefix rules plus
- * "secret-named key = value"); entropy detection is deliberately absent because
- * its false positives on hashes and code are irreversible in a live view.
- * A bare password has no shape, so it is recognised only by context: a short
- * token the user sends right after the assistant asked for a credential.
- */
-
-export interface SecretEntry {
-  /** The placeholder's number: `[[xeno-secret-<n>]]`. */
-  n: number;
-  value: string;
-  /** Which rule found it, for the audit trail; never the value. */
-  rule: string;
-}
-
-export type Vault = readonly SecretEntry[];
-
-export const placeholder = (n: number): string => `[[xeno-secret-${n}]]`;
-const PLACEHOLDER = /\[\[xeno-secret-(\d+)\]\]/g;
-
-/**
- * A known value shorter than this is too likely to occur by accident ("admin",
- * "123456") to mask everywhere it appears. Assumed, not measured; Codex's
- * key-assignment rule uses the same 8.
- */
-export const MIN_SECRET_LENGTH = 8;
-
-interface Rule { id: string; pattern: RegExp; /** Capture group holding the secret; 0 is the whole match. */ group: number }
-
-// Prefix rules follow gitleaks' default config (b58d3f10) and Gemini CLI's
-// environmentSanitization.ts; tskey- is added for Tailscale, which gitleaks lacks.
-const RULES: readonly Rule[] = [
-  { id: "pem-private-key", pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]+?-----END [A-Z ]*PRIVATE KEY-----/g, group: 0 },
-  { id: "anthropic-key", pattern: /\bsk-ant-[A-Za-z0-9_-]{20,}/g, group: 0 },
-  { id: "openai-key", pattern: /\bsk-(?:proj-|svcacct-)?[A-Za-z0-9_-]{20,}/g, group: 0 },
-  { id: "github-token", pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{36,}|github_pat_[A-Za-z0-9_]{22,})/g, group: 0 },
-  { id: "gitlab-token", pattern: /\bglpat-[A-Za-z0-9_-]{20,}/g, group: 0 },
-  { id: "slack-token", pattern: /\bxox[abposr]-[A-Za-z0-9-]{10,}/g, group: 0 },
-  { id: "aws-access-key", pattern: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g, group: 0 },
-  { id: "google-api-key", pattern: /\bAIza[0-9A-Za-z_-]{35}/g, group: 0 },
-  { id: "stripe-key", pattern: /\b[sr]k_live_[0-9A-Za-z]{24,}/g, group: 0 },
-  // tskey-<kind>-<id with a digit>-<secret>; documentation like "tskey-auth-reusable-" has no digit in the id.
-  { id: "tailscale-key", pattern: /\btskey-[a-z]+-[A-Za-z0-9]*\d[A-Za-z0-9]*-[A-Za-z0-9]{10,}/g, group: 0 },
-  { id: "npm-token", pattern: /\bnpm_[A-Za-z0-9]{36}\b/g, group: 0 },
-  { id: "jwt", pattern: /\beyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, group: 0 },
-  { id: "bearer-token", pattern: /\bBearer\s+([A-Za-z0-9._~+/=-]{20,})/g, group: 1 },
-  { id: "url-password", pattern: /\b[a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:([^\s/@]{3,})@/gi, group: 1 },
-  // A secret-named key assigned a literal. The value class excludes quotes,
-  // brackets and parentheses so `token = getToken()` and `password: string`
-  // stay code; requiring a digit or 16+ characters keeps `secret: undefined`.
-  { id: "secret-assignment", group: 1,
-    // Up to three prefix words, so access_token, HUILIANYI_REFRESH_TOKEN and db-password count.
-    pattern: /\b(?:[a-z0-9]+[_-]){0,3}(?:api[_-]?key|access[_-]?key|secret(?:[_-]?key)?|client[_-]?secret|token|password|passwd|pwd)["']?\s*[:=]\s*["']?([^\s"'`(){}[\]<>;,]{8,})/gi },
-  { id: "secret-assignment-zh", group: 1, pattern: /(?:密码|口令|密钥|令牌)\s*(?:是|为|[:：=])\s*["'“]?([^\s"'”，。,;；]{4,})/g },
-];
-
-const plausibleAssigned = (value: string): boolean =>
-  !/^(?:\$|process\.|os\.|env\.|self\.|this\.)/.test(value) && !value.startsWith("[[xeno-secret-") &&
-  // A pure number after a token-named key is a count (input_tokens=12000000), not a credential.
-  !/^\d+$/.test(value) &&
-  // Credentials carry digits; a digit-free value is a path, a member access or a placeholder word
-  // (replayed 2026-10-12 sessions: "internal/server/…", "auth.AccessToken"). A long mixed-case
-  // value without separators is the one digit-free exception.
-  (/\d/.test(value) && /[A-Za-z]/.test(value) || value.length >= 20 && /[A-Z]/.test(value) && /[a-z]/.test(value) && !/[./]/.test(value));
-
-/** Every secret-shaped span in `text`, with the rule that found it. Overlaps resolve to the earliest, longest. */
-export function findSecrets(text: string): { start: number; end: number; rule: string }[] {
-  const spans: { start: number; end: number; rule: string }[] = [];
-  for (const rule of RULES) {
-    for (const match of text.matchAll(rule.pattern)) {
-      const value = match[rule.group];
-      if (value === undefined || match.index === undefined) continue;
-      if (rule.id === "secret-assignment" && !plausibleAssigned(value)) continue;
-      const start = match.index + match[0].lastIndexOf(value);
-      spans.push({ start, end: start + value.length, rule: rule.id });
-    }
-  }
-  spans.sort((a, b) => a.start - b.start || b.end - a.end);
-  const kept: typeof spans = [];
-  for (const span of spans) if (kept.length === 0 || span.start >= kept.at(-1)!.end) kept.push(span);
-  return kept;
-}
-
-/**
- * Replaces known values and newly found secrets with placeholders. Returns the
- * vault entries it had to add; the caller persists them before the text is
- * written anywhere, so a placeholder in the log always has a value to expand to.
- */
-export function redactText(text: string, vault: Vault, candidates: readonly { value: string; rule: string }[] = []): { text: string; added: SecretEntry[] } {
-  if (text.length === 0) return { text, added: [] };
-  const added: SecretEntry[] = [];
-  let next = vault.reduce((max, entry) => Math.max(max, entry.n), 0) + 1;
-  // Candidates (secret-named environment values) join the vault only when they
-  // actually appear, so a placeholder number is never spent on a value no event holds.
-  const known: SecretEntry[] = [...vault];
-  for (const candidate of candidates) {
-    if (candidate.value.length < MIN_SECRET_LENGTH || !text.includes(candidate.value) || known.some(entry => entry.value === candidate.value)) continue;
-    const entry = { n: next++, value: candidate.value, rule: candidate.rule };
-    known.push(entry); added.push(entry);
-  }
-  let out = maskKnown(text, known);
-  const spans = findSecrets(out);
-  if (spans.length === 0) return { text: out, added };
-  let result = "", at = 0;
-  for (const span of spans) {
-    const value = out.slice(span.start, span.end);
-    const existing = known.find(entry => entry.value === value);
-    const entry = existing ?? { n: next++, value, rule: span.rule };
-    if (!existing) { known.push(entry); added.push(entry); }
-    result += out.slice(at, span.start) + placeholder(entry.n);
-    at = span.end;
-  }
-  // Values found in this pass may occur again where a neighbouring match split
-  // them (two tokens with no delimiter); a second known-value pass closes that.
-  return { text: maskKnown(result + out.slice(at), known), added };
-}
-
-/** Longest first, so a value containing another is masked whole. A short value is masked only where a rule found it. */
-function maskKnown(text: string, known: readonly SecretEntry[]): string {
-  let out = text;
-  for (const entry of known.filter(entry => entry.value.length >= MIN_SECRET_LENGTH).sort((a, b) => b.value.length - a.value.length)) {
-    if (out.includes(entry.value)) out = out.split(entry.value).join(placeholder(entry.n));
-  }
-  return out;
-}
-
-/** The inverse of redactText for tool inputs. An unknown placeholder is left as written. */
-export function expandText(text: string, vault: Vault): string {
-  if (!text.includes("[[xeno-secret-")) return text;
-  return text.replace(PLACEHOLDER, (whole, n: string) => vault.find(entry => entry.n === Number(n))?.value ?? whole);
-}
-
-const ASKED_FOR_CREDENTIAL = /password|passcode|passphrase|credential|api[ _-]?key|access[ _-]?token|\btoken\b|密码|口令|密钥|凭据|凭证|令牌|验证码/i;
-
-/**
- * A bare password has no shape; what identifies it is the exchange. A message
- * that is a single token with mixed character classes, sent right after the
- * assistant asked for a credential, is that credential (the 2026-10-12 ticket
- * session: the assistant asked for a login password, the user replied with it).
- */
-export function isSolicitedSecret(userText: string, previousAssistantText: string | undefined): boolean {
-  const value = userText.trim();
-  if (previousAssistantText === undefined || !ASKED_FOR_CREDENTIAL.test(previousAssistantText)) return false;
-  if (!/^\S{6,128}$/.test(value) || value.startsWith("[[xeno-secret-")) return false;
-  // Letters with digits, or three character classes: "dsm612566" and "Pa$$word"
-  // qualify, an identifier like "OPENAI_API_KEY" or a branch name does not.
-  const classes = [/[a-z]/, /[A-Z]/, /\d/, /[^A-Za-z0-9]/].filter(pattern => pattern.test(value)).length;
-  const lettersAndDigits = /[A-Za-z]/.test(value) && /\d/.test(value);
-  return (lettersAndDigits || classes >= 3) && !/^[a-z]+:\/\//i.test(value) && !/^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$/.test(value);
-}
-
-/** Applies `redact` to every string in a JSON value, preserving its shape. */
-export function mapStrings(value: unknown, redact: (text: string) => string, skip: (key: string) => boolean = () => false): unknown {
-  if (typeof value === "string") return redact(value);
-  if (Array.isArray(value)) return value.map(item => mapStrings(item, redact, skip));
-  if (value !== null && typeof value === "object") {
-    const out: Record<string, unknown> = {};
-    for (const [key, item] of Object.entries(value)) out[key] = skip(key) ? item : mapStrings(item, redact, skip);
-    return out;
-  }
-  return value;
-}
-
-/** Environment variables whose names say they hold a secret; their values are masked wherever they appear. */
-export function secretEnvironmentValues(env: Readonly<Record<string, string | undefined>>): { value: string; rule: string }[] {
-  return Object.entries(env).flatMap(([name, value]) =>
-    value !== undefined && value.length >= MIN_SECRET_LENGTH && !value.startsWith("/") &&
-      /(?:^|_)(?:API_?KEY|KEY|SECRET|TOKEN|PASSWORD|PASSWD|CREDENTIALS?|AUTH)(?:_|$)/i.test(name) &&
-      !/(?:^|_)(?:PATH|DIR|FILE|URL|HOST|PORT|USER|NAME|ID|MODE|TYPE)$/i.test(name)
-      ? [{ value, rule: `env:${name}` }] : []).sort((a, b) => a.rule < b.rule ? -1 : a.rule > b.rule ? 1 : 0);
-}

package/src/core/session-archive.ts

@@ -1,4 +0,0 @@
-/** Archive paths are a closed storage vocabulary, never arbitrary filesystem destinations (D3). */
-export function archivePath(path: unknown): path is string {
-  return typeof path === "string" && /^(?:node-\d{4,}\.jsonl|handoff-\d{4,}\.yaml|manifest\.json|metadata\.jsonl|(?:artifacts|blobs)\/[a-f0-9]{2}\/[a-f0-9]{62})$/.test(path);
-}

package/src/core/session-browser.ts

@@ -1,82 +0,0 @@
-/** Pi session-selector-search (MIT, 02eed88), independent of its AgentSession and clock. */
-export type SessionSort = "threaded" | "recent" | "relevance";
-export interface SessionRow {
-  path: string; id: string; name: string | null; updated_at: string | null;
-  workspace?: string; parent_session?: string; text?: string;
-}
-export interface SearchQuery {
-  tokens: { kind: "fuzzy" | "phrase"; value: string }[];
-  regex?: RegExp;
-  error?: string;
-}
-export function parseSessionQuery(query: string): SearchQuery {
-  const trimmed = query.trim();
-  if (trimmed.startsWith("re:")) {
-    if (!trimmed.slice(3).trim()) return { tokens: [], error: "Empty regex" };
-    try { return { tokens: [], regex: new RegExp(trimmed.slice(3).trim(), "i") }; }
-    catch (error) { return { tokens: [], error: String(error) }; }
-  }
-  const tokens: SearchQuery["tokens"] = [];
-  let buffer = "", quoted = false;
-  const flush = () => { if (buffer.trim()) tokens.push({ kind: quoted ? "phrase" : "fuzzy", value: buffer.trim() }); buffer = ""; };
-  for (const char of trimmed) {
-    if (char === '"') { flush(); quoted = !quoted; }
-    else if (!quoted && /\s/.test(char)) flush();
-    else buffer += char;
-  }
-  if (quoted) return { tokens: trimmed.split(/\s+/).filter(Boolean).map(value => ({ kind: "fuzzy", value })) };
-  flush(); return { tokens };
-}
-export function selectSessions<T extends SessionRow>(rows: readonly T[], query: string, sort: SessionSort, named: boolean,
-  fuzzy: (query: string, text: string) => { matches: boolean; score: number }): (T & { depth: number })[] {
-  const parsed = parseSessionQuery(query);
-  if (parsed.error) return [];
-  const scored = rows.flatMap(row => {
-    if (named && !row.name?.trim()) return [];
-    const text = `${row.id} ${row.name ?? ""} ${row.text ?? ""} ${row.workspace ?? ""}`;
-    let score = 0;
-    if (parsed.regex) { const i = text.search(parsed.regex); if (i < 0) return []; score = i * 0.1; }
-    else for (const token of parsed.tokens) {
-      if (token.kind === "phrase") {
-        const i = text.toLowerCase().replace(/\s+/g, " ").indexOf(token.value.toLowerCase().replace(/\s+/g, " "));
-        if (i < 0) return []; score += i * 0.1;
-      } else { const match = fuzzy(token.value, text); if (!match.matches) return []; score += match.score; }
-    }
-    return [{ row, score }];
-  });
-  const recent = (a: SessionRow, b: SessionRow) => (b.updated_at ?? "").localeCompare(a.updated_at ?? "") || a.path.localeCompare(b.path);
-  scored.sort((a, b) => query.trim() && sort !== "recent" ? a.score - b.score || recent(a.row, b.row) : recent(a.row, b.row));
-  if (sort !== "threaded" || query.trim()) return scored.map(({ row }) => ({ ...row, depth: 0 }));
-  const byPath = new Map(scored.map(({ row }) => [row.path, row]));
-  const children = new Map<string, T[]>();
-  const roots: T[] = [];
-  for (const { row } of scored) {
-    if (row.parent_session && row.parent_session !== row.path && byPath.has(row.parent_session)) {
-      const list = children.get(row.parent_session) ?? []; list.push(row); children.set(row.parent_session, list);
-    } else roots.push(row);
-  }
-  // Allocation can be arbitrarily deep. Iterative traversal handles cycles without hiding their rows.
-  const latest = new Map(scored.map(({ row }) => [row.path, row.updated_at ?? ""]));
-  for (const { row } of scored) {
-    const visited = new Set<string>([row.path]);
-    let parent = row.parent_session;
-    while (parent && byPath.has(parent) && !visited.has(parent)) {
-      visited.add(parent);
-      if ((row.updated_at ?? "") > (latest.get(parent) ?? "")) latest.set(parent, row.updated_at ?? "");
-      parent = byPath.get(parent)?.parent_session;
-    }
-  }
-  const byActivity = (a: T, b: T) => (latest.get(b.path) ?? "").localeCompare(latest.get(a.path) ?? "") || recent(a, b);
-  roots.sort(byActivity); for (const list of children.values()) list.sort(byActivity);
-  const out: (T & { depth: number })[] = [], visited = new Set<string>();
-  for (const root of [...roots, ...scored.map(s => s.row)]) {
-    const stack = [{ row: root, depth: 0 }];
-    while (stack.length) {
-      const next = stack.pop()!;
-      if (visited.has(next.row.path)) continue;
-      visited.add(next.row.path); out.push({ ...next.row, depth: next.depth });
-      for (const row of [...children.get(next.row.path) ?? []].reverse()) stack.push({ row, depth: next.depth + 1 });
-    }
-  }
-  return out;
-}

package/src/core/session-entry.ts

@@ -1,61 +0,0 @@
-/** Session intent is decided before any log is opened (D8, Pi entry parity). */
-export interface SessionEntryFlags {
-  explicit?: string;
-  fresh?: boolean;
-  continueLatest?: boolean;
-  noSession?: boolean;
-  session?: string;
-  sessionId?: string;
-  resume?: string | boolean;
-  forkFrom?: string;
-}
-
-export type SessionEntry =
-  | { kind: "new" }
-  | { kind: "ephemeral" }
-  | { kind: "continue" }
-  | { kind: "select" }
-  | { kind: "named"; id: string }
-  | { kind: "open"; target: string; explicit: boolean }
-  | { kind: "fork"; target: string };
-
-export function planSessionEntry(flags: SessionEntryFlags): SessionEntry {
-  const choices: { flag: string; entry: SessionEntry }[] = [];
-  if (flags.explicit) choices.push({ flag: "--log", entry: { kind: "open", target: flags.explicit, explicit: true } });
-  if (flags.session) choices.push({ flag: "--session", entry: { kind: "open", target: flags.session, explicit: false } });
-  if (flags.sessionId) {
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(flags.sessionId)) throw new Error("--session-id requires a plain session identifier");
-    choices.push({ flag: "--session-id", entry: { kind: "named", id: flags.sessionId } });
-  }
-  if (flags.resume) choices.push({ flag: "--resume", entry: typeof flags.resume === "string"
-    ? { kind: "open", target: flags.resume, explicit: false } : { kind: "select" } });
-  if (flags.forkFrom) choices.push({ flag: "--fork", entry: { kind: "fork", target: flags.forkFrom } });
-  if (flags.continueLatest) choices.push({ flag: "--continue", entry: { kind: "continue" } });
-  // --fresh predates --no-session; together they still mean a fresh ephemeral log.
-  if (flags.fresh || flags.noSession) choices.push({ flag: flags.noSession ? "--no-session" : "--fresh",
-    entry: { kind: flags.noSession ? "ephemeral" : "new" } });
-  if (choices.length > 1) throw new Error(`conflicting session options: ${choices.map((c) => c.flag).join(", ")}`);
-  return choices[0]?.entry ?? { kind: "new" };
-}
-
-export interface SavedModel {
-  model: string;
-  provider?: string;
-}
-
-/**
- * S.3: every cursor of this session format names its provider, so a resume
- * restores exactly that provider/model and never guesses one from a model ID
- * that several providers serve.
- */
-export function restoreSessionModel<T extends { id: string; provider: string }>(
-  saved: SavedModel,
-  catalog: readonly T[],
-): T {
-  if (saved.provider === undefined) throw new Error(`saved model ${saved.model} names no provider, which this session format always records. Start a new session`);
-  const matches = catalog.filter((m) => m.id === saved.model && m.provider === saved.provider);
-  const label = `${saved.provider}/${saved.model}`;
-  if (matches.length === 0) throw new Error(`saved model ${label} is unavailable. Restore its catalog entry, or start a new session`);
-  if (matches.length !== 1) throw new Error(`saved model ${label} is ambiguous across providers. Restore an unambiguous catalog before resuming`);
-  return matches[0]!;
-}

package/src/core/session-exit.ts

@@ -1,42 +0,0 @@
-/** D8 / D11: terminal exit is a bounded projection of execution facts, never a replay. */
-import type { LogEvent } from "./events.ts";
-import { pendingToolCalls } from "./execution.ts";
-import { modelOutcome } from "./outcome.ts";
-import { currentRequestEvents } from "./request-state.ts";
-
-export const DEFAULT_FULLSCREEN_EXIT_OUTPUT = "resume-hint";
-
-/** The identifiers `--session-id` accepts; anything else is printed as a path. */
-const PLAIN_ID = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/;
-
-/**
- * The command a person retypes to come back. Claude Code prints
- * `claude --resume <id>` and Codex `codex resume <id>`: an id, not a path.
- * `--resume <id>` resolves only inside the sessions directory of the shell's
- * cwd, so a session stored anywhere else (`--session-dir`, `--state-dir`,
- * `-w` elsewhere) keeps the explicit path rather than a command that cannot
- * find it.
- */
-export function resumeCommand(session: { id: string; directory: string; path: string }, cwdSessions: string): string {
-  return session.directory === cwdSessions && PLAIN_ID.test(session.id)
-    ? `xeno --resume ${session.id}` : `xeno --session ${JSON.stringify(session.path)}`;
-}
-
-/** Terminal controls and arbitrarily large reason text do not own the shell surface. */
-export function exitLine(text: string, limit = 180): string {
-  return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, " ").replace(/\s+/g, " ").trim().slice(0, limit);
-}
-
-export function sessionExitStatus(events: readonly LogEvent[]): string {
-  const current = currentRequestEvents(events);
-  const outcome = current.findLast(event => event.t === "outcome" || event.t === "user_bash");
-  if (outcome?.t === "outcome") return exitLine(`${outcome.outcome.status} · ${outcome.outcome.reason} · ${outcome.reason}`);
-  if (outcome?.t === "user_bash") return `${outcome.outcome.status} · ${outcome.outcome.reason} · command exit ${outcome.exit}`;
-  if (current.some(event => event.t === "interrupt")) return "cancelled · user interrupted";
-  const assistant = current.findLast(event => event.t === "assistant");
-  if (assistant?.t === "assistant" && !assistant.blocks.some(block => block.type === "tool_use") && pendingToolCalls(current).length === 0) {
-    const result = modelOutcome(assistant.stop_reason ?? null);
-    return result.reason === "model_end" ? "model finished · verification remains in session evidence" : `${result.status} · ${result.reason}`;
-  }
-  return current.length === 0 ? "session saved" : "unfinished · inspect recorded receipts before continuing";
-}