@visual-z/xeno 0.1.3 → 0.2.0

package/src/core/keymap.ts

@@ -7,39 +7,8 @@
  * pi's scheme; the action list is ours.
  */
 
-export const ACTION_IDS = [
-  "editor.cursorLeft",
-  "editor.cursorRight",
-  "editor.cursorWordLeft",
-  "editor.cursorWordRight",
-  "editor.cursorLineStart",
-  "editor.cursorLineEnd",
-  "editor.cursorUp",
-  "editor.cursorDown",
-  "editor.deleteCharBackward",
-  "editor.deleteCharForward",
-  "editor.deleteWordBackward",
-  "editor.deleteToLineStart",
-  "editor.deleteToLineEnd",
-  "editor.submit",
-  "editor.newLine",
-  "editor.undo",
-  "editor.yank",
-  "editor.deleteWordForward",
-  "editor.complete",
-  "app.toggleTools",
-  "app.toggleThinking",
-  "app.interrupt",
-  "app.exit",
-  "app.message.followUp",
-  "app.message.dequeue",
-  "app.model",
-  "app.cycleModel",
-  "app.cycleModelReverse",
-  "app.cycleThinking",
-  "app.saveDefault",
-  "app.externalEditor",
-] as const;
+import { ACTION_DEFAULTS, ACTION_ALIASES } from "./action-defaults.ts";
+export const ACTION_IDS = Object.keys(ACTION_DEFAULTS) as (keyof typeof ACTION_DEFAULTS)[];
 
 export type ActionId = (typeof ACTION_IDS)[number];
 
@@ -118,87 +87,56 @@ export function resolveAction(map: Keymap, spec: string): ActionId | undefined {
   return map.byKey[formatKey(parsed)];
 }
 
-export function defaultKeymap(): Keymap {
-  return parseKeymap(
-    {
-      "editor.cursorLeft": ["left", "ctrl+b"],
-      "editor.cursorRight": ["right", "ctrl+f"],
-      "editor.cursorWordLeft": ["alt+left", "ctrl+left", "alt+b"],
-      "editor.cursorWordRight": ["alt+right", "ctrl+right", "alt+f"],
-      "editor.cursorLineStart": ["home", "ctrl+a"],
-      "editor.cursorLineEnd": ["end", "ctrl+e"],
-      "editor.cursorUp": ["up"],
-      "editor.cursorDown": ["down"],
-      "editor.deleteCharBackward": ["backspace"],
-      "editor.deleteCharForward": ["delete", "ctrl+d"],
-      "editor.deleteWordBackward": ["ctrl+w", "alt+backspace"],
-      "editor.deleteWordForward": ["alt+d"],
-      "editor.deleteToLineStart": ["ctrl+u"],
-      "editor.deleteToLineEnd": ["ctrl+k"],
-      "editor.submit": ["enter"],
-      "editor.newLine": ["shift+enter", "ctrl+j"],
-      "editor.undo": ["ctrl+-", "ctrl+z", "ctrl+_"],
-      "editor.yank": ["ctrl+y"],
-      "editor.complete": ["tab"],
-      "app.toggleTools": ["ctrl+o"],
-      "app.toggleThinking": ["ctrl+t"],
-      "app.interrupt": ["escape"],
-      "app.exit": ["ctrl+c"],
-      "app.message.followUp": ["alt+enter"],
-      "app.message.dequeue": ["alt+up"],
-      "app.model": ["ctrl+l"],
-      "app.cycleModel": ["ctrl+p"],
-      "app.cycleModelReverse": ["ctrl+shift+p"],
-      "app.cycleThinking": ["shift+tab"],
-      "app.saveDefault": ["ctrl+s"],
-      "app.externalEditor": ["ctrl+g"],
-    },
-    emptyKeymap(),
-  );
+export function defaultKeymap(platform: "posix" | "win32" | "wsl" = "posix"): Keymap {
+  // Pi's Windows shortcuts avoid terminal-reserved chords; WSL still supports job control.
+  return parseKeymap({ ...ACTION_DEFAULTS, ...(platform === "posix" ? {} : {
+    "app.suspend": platform === "win32" ? [] : ["ctrl+z"],
+    "editor.undo": platform === "win32" ? ["ctrl+z"] : ["alt+z"],
+    "app.cycleModelReverse": ["alt+p"], "app.message.followUp": ["ctrl+q"],
+    "app.message.dequeue": ["alt+q"], "app.clipboard.pasteImage": ["alt+v"],
+    "tui.altScreen.previousPrompt": ["ctrl+up"], "tui.altScreen.nextPrompt": ["ctrl+down"],
+    "tui.altScreen.search": ["ctrl+f"],
+  }) });
 }
 
+/** Modal scopes deliberately share chords. Only collisions within one owner replace a binding. */
+export function actionScope(action: string): string {
+  if (action === "app.exit") return "exit";
+  if (action === "tui.input.copy") return "copy";
+  if (action.startsWith("tui.select.")) return "select";
+  if (action.startsWith("tui.altScreen.")) return "viewport";
+  if (action.startsWith("app.tree.")) return "tree";
+  if (action.startsWith("app.models.")) return "models";
+  if (action.startsWith("app.session.") && !["app.session.new", "app.session.tree", "app.session.fork", "app.session.resume"].includes(action)) return "session";
+  return "global";
+}
 export function parseKeymap(json: unknown, base?: Keymap): Keymap {
-  const diagnostics: string[] = [];
-  const byKey: { [k: string]: ActionId } = { ...(base?.byKey ?? {}) };
-
-  if (json === undefined || json === null) {
-    return finish(byKey, base?.diagnostics ?? []);
-  }
-  if (typeof json !== "object" || Array.isArray(json)) {
-    return finish(byKey, [...(base?.diagnostics ?? []), "keybindings is not an object"]);
-  }
-
-  const rec = json as { readonly [k: string]: unknown };
-  for (const [action, raw] of Object.entries(rec)) {
-    if (!ACTION_SET.has(action)) {
-      diagnostics.push(`unknown action: ${action}`);
-      continue;
-    }
+  const diagnostics = [...(base?.diagnostics ?? [])];
+  const byAction: Record<string,string[]> = Object.fromEntries(Object.entries(base?.byAction ?? {}).map(([k,v]) => [k,[...v]]));
+  if (json !== undefined && json !== null && (typeof json !== "object" || Array.isArray(json))) diagnostics.push("keybindings is not an object");
+  else for (const [rawAction,raw] of Object.entries(json ?? {})) {
+    const action = ACTION_ALIASES[rawAction] ?? rawAction;
+    if (!ACTION_SET.has(action)) { diagnostics.push("unknown action: " + rawAction); continue; }
     const specs = keySpecs(raw);
-    if (specs === null) {
-      diagnostics.push(`${action}: bindings must be a string or array of strings`);
-      continue;
-    }
-    // User (or this file) replaces the previous chords for this action.
-    for (const [k, a] of Object.entries(byKey)) {
-      if (a === action) delete byKey[k];
-    }
+    if (!specs) { diagnostics.push(action + ": bindings must be a string or array of strings"); continue; }
+    const keys: string[] = [];
+    byAction[action] = keys;
     for (const spec of specs) {
       const parsed = parseKey(spec);
-      if ("error" in parsed) {
-        diagnostics.push(`${parsed.error} (action ${action})`);
-        continue;
-      }
-      const id = formatKey(parsed);
-      const prev = byKey[id];
-      if (prev !== undefined && prev !== action) {
-        diagnostics.push(`key ${id} is bound to both ${prev} and ${action}; ${action} wins`);
+      if ("error" in parsed) { diagnostics.push(parsed.error + " (action " + action + ")"); continue; }
+      const key = formatKey(parsed);
+      for (const [other, bindings] of Object.entries(byAction)) {
+        if (other !== action && actionScope(other) === actionScope(action) && bindings.includes(key)) {
+          diagnostics.push("key " + key + " is bound to both " + other + " and " + action + "; " + action + " wins");
+          byAction[other] = bindings.filter(k => k !== key);
+        }
       }
-      byKey[id] = action as ActionId;
+      if (!keys.includes(key)) keys.push(key);
     }
   }
-
-  return finish(byKey, [...(base?.diagnostics ?? []), ...diagnostics]);
+  const byKey: Record<string,ActionId> = {};
+  for (const [action,keys] of Object.entries(byAction)) if (["global", "exit"].includes(actionScope(action))) for (const key of keys) byKey[key] = action as ActionId;
+  return { byKey, byAction, diagnostics };
 }
 
 export function listBindings(map: Keymap): { action: string; keys: readonly string[] }[] {
@@ -208,20 +146,6 @@ export function listBindings(map: Keymap): { action: string; keys: readonly stri
   }));
 }
 
-function emptyKeymap(): Keymap {
-  return { byKey: {}, byAction: {}, diagnostics: [] };
-}
-
-function finish(byKey: { readonly [k: string]: ActionId }, diagnostics: readonly string[]): Keymap {
-  const byAction: { [k: string]: string[] } = {};
-  for (const [key, action] of Object.entries(byKey)) {
-    const list = byAction[action] ?? [];
-    list.push(key);
-    byAction[action] = list;
-  }
-  return { byKey, byAction, diagnostics };
-}
-
 function keySpecs(raw: unknown): string[] | null {
   if (typeof raw === "string") return [raw];
   if (Array.isArray(raw) && raw.every((x) => typeof x === "string")) return raw as string[];

package/src/core/model-replay.ts

@@ -0,0 +1,22 @@
+import type { LogEvent } from "./events.ts";
+
+export interface ReplayModel {
+  provider: string; id: string; api: string; driver?: string; wireId?: string; baseUrl?: string;
+  compat?: unknown; nativeCompat?: unknown; thinkingLevelMap?: unknown;
+}
+function canonical(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonical(item)]));
+  return value;
+}
+
+/** D8: replay identity excludes prices, UI labels, credentials and sampling choices. */
+export function replayDescriptor(model: ReplayModel): string {
+  return JSON.stringify(canonical([model.provider, model.id, model.api, model.driver ?? "legacy", model.wireId ?? model.id,
+    model.baseUrl ?? "", model.compat ?? null, model.nativeCompat ?? null, model.thinkingLevelMap ?? null]));
+}
+
+/** Old native profiles have no provable wire identity. One checkpoint makes subsequent replay explicit. */
+export function needsReplayCheckpoint(events: readonly LogEvent[], key: string, requireKnown: boolean): boolean {
+  return events.some(event => event.t === "assistant" && (event.replay_key === undefined ? requireKnown : event.replay_key !== key));
+}

package/src/core/model-scope.ts

@@ -0,0 +1,53 @@
+/** Ordered model identities are session state until explicitly saved. D13: never resolve bare IDs here. */
+import { asThinkingLevel, type ThinkingLevel } from "./thinking.ts";
+import { modelKey } from "./session-position.ts";
+
+export interface ScopedModel<T> { model: T; thinking?: ThinkingLevel }
+
+/** Exact full references win before suffix parsing, including IDs whose colon is literal (Pi 02eed88). */
+export function resolveScope<T extends { id: string; provider: string }>(
+  patterns: readonly string[], match: (pattern: string) => readonly T[], strict = false,
+): { entries: ScopedModel<T>[]; diagnostics: string[] } {
+  const entries: ScopedModel<T>[] = [], diagnostics: string[] = [], seen = new Set<string>();
+  for (const pattern of patterns) {
+    let matches = match(pattern), thinking: ThinkingLevel | undefined;
+    if (!matches.length) {
+      const colon = pattern.lastIndexOf(":");
+      if (colon > 0) {
+        const suffix = pattern.slice(colon + 1), level = asThinkingLevel(suffix);
+        if (level || !strict) {
+          matches = match(pattern.slice(0, colon));
+          if (matches.length) {
+            thinking = level;
+            if (!level) diagnostics.push(`Invalid thinking level ${JSON.stringify(suffix)} in ${JSON.stringify(pattern)}; using the default`);
+          }
+        }
+      }
+    }
+    if (!matches.length) diagnostics.push(`No models match ${JSON.stringify(pattern)}`);
+    for (const model of matches) {
+      const key = modelKey(model); if (seen.has(key)) continue; seen.add(key);
+      entries.push({ model, ...(thinking === undefined ? {} : { thinking }) });
+    }
+  }
+  return { entries, diagnostics };
+}
+
+export function scopeReference<T extends { id: string; provider: string }>(entry: ScopedModel<T>): string {
+  return modelKey(entry.model) + (entry.thinking ? `:${entry.thinking}` : "");
+}
+
+export type ScopeChange = { readonly kind: "toggle"; readonly ids: readonly string[] } |
+  { readonly kind: "enable" | "disable"; readonly ids: readonly string[] } |
+  { readonly kind: "move"; readonly id: string; readonly delta: -1 | 1 };
+export function changeModelScope(current: readonly string[], change: ScopeChange): string[] {
+  const next = [...new Set(current)];
+  if (change.kind === "move") {
+    const index = next.indexOf(change.id), target = index + change.delta;
+    if (index >= 0 && target >= 0 && target < next.length) [next[index], next[target]] = [next[target]!, next[index]!];
+    return next;
+  }
+  const ids = new Set(change.ids);
+  const disable = change.kind === "disable" || change.kind === "toggle" && change.ids.every(id => next.includes(id));
+  return disable ? next.filter(id => !ids.has(id)) : [...next, ...[...ids].filter(id => !next.includes(id))];
+}

package/src/core/packages.ts

@@ -0,0 +1,47 @@
+/** Pi package identities and filters, independent of installation and I/O (D13). */
+import { parseResourcePattern, type ResourceKind } from "./resource-selection.ts";
+
+export type PackageDeclaration = string | ({ source: string; autoload?: boolean } & Partial<Record<ResourceKind, readonly string[]>>);
+export type PackageSource =
+  | { kind: "local"; id: string; path: string; source: string; pinned: true }
+  | { kind: "npm"; id: string; name: string; spec: string; version?: string; source: string; pinned: boolean }
+  | { kind: "git"; id: string; repo: string; ref?: string; source: string; pinned: boolean };
+export function packageDeclaration(value: unknown): value is PackageDeclaration {
+  if (typeof value === "string") return value.trim().length > 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const entry = value as Record<string, unknown>;
+  return typeof entry["source"] === "string" && entry["source"].trim().length > 0 &&
+    (entry["autoload"] === undefined || typeof entry["autoload"] === "boolean") &&
+    ["extensions", "skills", "prompts", "themes"].every(key => entry[key] === undefined || Array.isArray(entry[key]) && entry[key].every(p => typeof p === "string"));
+}
+export function packageConfig(value: PackageDeclaration): Exclude<PackageDeclaration, string> { return typeof value === "string" ? { source: value } : value; }
+export function parsePackageSource(raw: string, localPath: (path: string) => string): PackageSource {
+  const source = raw.trim(); if (!source || source.startsWith("-") || /[\x00-\x1f]/.test(source)) throw Error("Invalid package source");
+  if (source.startsWith("npm:")) {
+    const spec = source.slice(4), at = spec.lastIndexOf("@"), name = at > 0 ? spec.slice(0, at) : spec, version = at > 0 ? spec.slice(at + 1) : undefined;
+    if (!/^(?:@[a-zA-Z0-9][a-zA-Z0-9._-]*\/)?[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name) || version === "" || version?.startsWith("-")) throw Error("Invalid npm package source");
+    return { kind: "npm", id: "npm:" + name, source, name, spec, ...(version === undefined ? {} : { version }), pinned: !!version && /^v?\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(version) };
+  }
+  if (/^(git:|git\+|https?:\/\/|ssh:\/\/|git@)/.test(source)) {
+    let repo = source.replace(/^git:(?!\/\/)/, "").replace(/^git\+/, ""), ref: string | undefined;
+    const hash = repo.lastIndexOf("#"), at = repo.lastIndexOf("@");
+    const authorityEnd = /^\w+:\/\//.test(repo) ? repo.indexOf("/",repo.indexOf("://")+3) : repo.startsWith("git@") ? repo.indexOf(":") : repo.indexOf("/");
+    const split = hash >= 0 ? hash : at > authorityEnd && authorityEnd >= 0 ? at : -1;
+    if (split >= 0) { ref = repo.slice(split + 1); repo = repo.slice(0, split); if (!ref || ref.startsWith("-")) throw Error("Invalid git ref"); }
+    if (!/^(\w+:\/\/|git@|\/|\.\.?\/)/.test(repo)) repo = "https://" + repo;
+    const remote = /^\w+:\/\//.test(repo) ? new URL(repo) : undefined;
+    const canonical = (remote ? remote.host.toLowerCase()+remote.pathname : repo.replace(/^git@([^:]+):/, "$1/")).replace(/\.git\/?$/, "").replace(/\/$/, "");
+    if (!canonical.includes("/")) throw Error("Invalid git repository");
+    return { kind: "git", source, repo, id: "git:" + canonical, ...(ref === undefined ? {} : { ref }), pinned: ref !== undefined };
+  }
+  const path = localPath(source); return { kind: "local", id: "local:" + path, source, path, pinned: true };
+}
+
+/** Missing filters inherit; [] excludes all; ordinary positive patterns form a whitelist. */
+export function packageResourceEnabled(patterns: readonly string[] | undefined, matches: (pattern: string, exact: boolean) => boolean, inherited = true): boolean {
+  if (patterns === undefined) return inherited;
+  if (patterns.length === 0) return false;
+  let enabled = patterns.some(pattern => !/^[!+-]/.test(pattern)) ? false : inherited;
+  for (const raw of patterns) { const pattern = parseResourcePattern(raw); if (matches(pattern.pattern,pattern.explicit)) enabled = pattern.enabled; }
+  return enabled;
+}

package/src/core/progress.ts

@@ -88,6 +88,15 @@ export function deriveProgress(
         if (observation !== undefined) observations.add(observation);
       }
     } else if (effect?.kind === "command" && effect.exit === 0) {
+      // D9 revision (2026-09-29, user-approved): output never seen before is a
+      // new observation, exactly as for read/grep. A model exploring with
+      // `sed -n` or `grep` in the shell is gathering evidence too; the digest
+      // excludes wall time, so an unchanged `git status` repeats and stalls.
+      if (observation !== undefined && !observations.has(observation)) {
+        observations.add(observation);
+        evidence.push({ kind: "observation", sha256: observation, source });
+        progressed = true;
+      }
       const key = checkKey(effect.cmd, effect.gate, effect.workspace_sha256);
       if (!checks.has(key)) {
         checks.add(key);

package/src/core/project.ts

@@ -28,10 +28,12 @@
 
 import type { LogEvent, AssistantBlock } from "./events.ts";
 import { assertNever } from "./exhaustive.ts";
+import type { ImageContent } from "./images.ts";
 import { type Handoff, emitHandoff } from "./handoff.ts";
 
 export type ContentBlock =
-  | { type: "text"; text: string }
+  | ImageContent
+  | { type: "text"; text: string; wire?: unknown }
   /**
    * The provider's own thinking block, replayed verbatim. It is carried as
    * opaque rather than reconstructed because the API rejects modified blocks,
@@ -108,9 +110,11 @@ export interface ProjectViolation {
  * two things". It is a following message rather than a mutation of the user
  * turn so appending the event only appends to the projection (P7).
  */
-type ReplayEvent = Extract<LogEvent, { t: "user" | "guidance" | "interrupt" | "assistant" | "tool_result" | "rewind" | "snapshot" }>;
+type ReplayEvent = Extract<LogEvent, { t: "user" | "user_bash" | "guidance" | "interrupt" | "assistant" | "tool_result" | "rewind" | "snapshot" | "extension" }>;
 
 function replayable(e: LogEvent): e is ReplayEvent {
+  if (e.t === "extension") return e.inContext;
+  if (e.t === "user_bash") return !e.excludeFromContext;
   if (e.t === "rewind") return e.mode !== "both";
   if (e.t === "snapshot") return e.undeclared.length > 0;
   return e.t === "user" || e.t === "guidance" || e.t === "interrupt" || e.t === "assistant" || e.t === "tool_result";
@@ -269,6 +273,17 @@ export function projectContext(input: ProjectInput): ProjectResult {
   let awaiting = new Set<string>();
 
   for (const e of events) {
+    if (e.t === "extension") {
+      flushPending();
+      if (awaiting.size) violations.push({ code: "UNPAIRED_TOOL_USE", detail: `custom message ${e.id} follows unanswered tool_use ${[...awaiting].join(", ")}` });
+      messages.push({ role: "user", content: [{ type: "text", text: e.content }] });
+      continue;
+    }
+    if (e.t === "user_bash") {
+      flushPending();
+      messages.push({ role: "user", content: [{ type: "text", text: `User ran: ${e.command}\n${e.content}` }] });
+      continue;
+    }
     if (e.t === "snapshot") {
       flushPending();
       messages.push({ role: "user", content: [{ type: "text",
@@ -292,7 +307,8 @@ export function projectContext(input: ProjectInput): ProjectResult {
         });
         awaiting = new Set();
       }
-      messages.push({ role: "user", content: [{ type: "text", text: e.text }] });
+      messages.push({ role: "user", content: [...(e.text || e.t === "guidance" || !e.images?.length ? [{ type: "text" as const, text: e.text }] : []),
+        ...(e.t === "user" ? (e.images ?? []).map(image => ({ type: "image" as const, image })) : [])] });
       continue;
     }
     if (e.t === "interrupt") {
@@ -334,6 +350,8 @@ export function projectContext(input: ProjectInput): ProjectResult {
       content: e.content,
       ...(e.ok ? {} : { is_error: true }),
     });
+    // Images follow the paired text result, so APIs without image tool outputs receive a user image.
+    pending.push(...(e.images ?? []).map(image => ({ type: "image" as const, image })));
   }
 
   flushPending();

package/src/core/prompts.ts

@@ -31,15 +31,43 @@ export function expandTemplate(
       names.push(name);
     }
   }
-  if (arg.length > 0) {
-    return { text: content.replace(PLACEHOLDER, arg), diagnostics: [] };
-  }
   return {
-    text: content,
-    diagnostics: names.map((name) => `unfilled placeholder: ${name}`),
+    text: substituteArgs(content, parseCommandArgs(arg), arg),
+    diagnostics: arg.length ? [] : names.map((name) => `unfilled placeholder: ${name}`),
   };
 }
 
+/** Ported from pi core/prompt-templates.ts (MIT, 02eed88); quote handling is Pi's, not shell execution. */
+export function parseCommandArgs(text: string): string[] {
+  const args: string[] = [];
+  let current = "", quote: string | null = null;
+  for (const char of text) {
+    if (quote) { if (char === quote) quote = null; else current += char; }
+    else if (char === '"' || char === "'") quote = char;
+    else if (/\s/.test(char)) { if (current) { args.push(current); current = ""; } }
+    else current += char;
+  }
+  if (current) args.push(current);
+  return args;
+}
+
+/** Pi positional/default/slice syntax and legacy named syntax share one pass: inserted text stays literal. */
+function substituteArgs(content: string, args: readonly string[], legacy: string): string {
+  const all = args.join(" ");
+  return content.replace(/\{\{([A-Za-z_][A-Za-z0-9_-]*)\}\}|\$\{(\d+|ARGUMENTS|@):-([^}]*)\}|\$\{@:(\d+)(?::(\d+))?\}|\$(ARGUMENTS|@|\d+)/g,
+    (match: string, named: string | undefined, target: string | undefined, fallback: string | undefined,
+      start: string | undefined, length: string | undefined, simple: string | undefined) => {
+      if (named) return legacy.length ? legacy : match;
+      if (target) return (target === "@" || target === "ARGUMENTS" ? all : args[Number(target) - 1]) || fallback || "";
+      if (start !== undefined) {
+        const from = Math.max(0, Number(start) - 1);
+        return args.slice(from, length === undefined ? undefined : from + Number(length)).join(" ");
+      }
+      if (simple === "@" || simple === "ARGUMENTS") return all;
+      return args[Number(simple) - 1] ?? "";
+    });
+}
+
 export function parsePromptTemplate(input: {
   readonly filePath: string;
   readonly text: string;

package/src/core/queue.ts

@@ -12,12 +12,15 @@
  */
 
 import { assertNever } from "./exhaustive.ts";
+import type { ImageRef } from "./images.ts";
 
 export type QueueKind = "steering" | "followup";
+export type DeliveryMode = "all" | "one-at-a-time";
 
 export interface QueuedMessage {
   readonly kind: QueueKind;
   readonly text: string;
+  readonly images?: readonly ImageRef[];
 }
 
 /**
@@ -58,3 +61,18 @@ function firstOfKind(
   }
   return null;
 }
+
+/** Bash remains an atomic follow-up; batching never turns commands into model prompts. */
+export function deliveryBatch(queue: readonly QueuedMessage[], phase: Phase,
+  modes: { steering?: DeliveryMode; followup?: DeliveryMode }): readonly QueuedMessage[] {
+  const first = nextDelivery(queue, phase);
+  if (first === null) return [];
+  if (modes[first.kind] !== "all" || first.text.startsWith("!")) return [first];
+  const batch: QueuedMessage[] = [];
+  for (const item of queue) {
+    if (item.kind !== first.kind) continue;
+    if (item.text.startsWith("!")) break;
+    batch.push(item);
+  }
+  return batch;
+}

package/src/core/resource-selection.ts

@@ -0,0 +1,36 @@
+/** 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/{runtime → core}/resume.ts

@@ -7,35 +7,26 @@
  * filesystem.
  */
 
-import type { Cursor } from "../store/log.ts";
+import type { SavedModel } from "./session-entry.ts";
 
-export type ResumePlan =
+export type ResumePlan<T extends SavedModel> =
   | { kind: "fresh" }
-  | { kind: "resume"; cursor: Cursor }
+  | { kind: "resume"; cursor: T }
   | { kind: "refuse"; reason: string };
 
 /**
  * A session's thinking blocks belong to the model that produced them.
  *
- * Every provider this harness talks to requires them replayed unchanged, and
- * the two do not use the same representation at all: DeepSeek carries
- * `reasoning_content`, Anthropic carries a signed block. Handing one to the
- * other is a bad request, and it would surface on the first turn of the
- * resumed session rather than here.
- *
- * Refusing rather than converting is the point. pi converts, wrapping a
- * foreign thinking trace in `<thinking>` tags inside assistant content -- a
- * lossy, opinionated rewrite of what the model is told happened. This
- * project's position is that the context is a recomputable projection of the
- * log, so a resume that silently rewrites history breaks the one property
- * everything else rests on. The log is intact; switching back to the model
- * that wrote it picks up exactly where it left off.
+ * 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(
-  cursor: Cursor | null,
+export function planResume<T extends SavedModel>(
+  cursor: T | null,
   model: string,
   hasNodes: boolean,
-): ResumePlan {
+  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
@@ -53,12 +44,14 @@ export function planResume(
         }
       : { kind: "fresh" };
   }
-  if (cursor.model !== model) {
+  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 ${cursor.model}, and ${model} cannot replay its ` +
-        `thinking blocks. Resume it with --model ${cursor.model}, or start a ` +
+        `this session ran under ${saved}, and ${target} cannot replay its ` +
+        `thinking blocks. Resume it with --model ${saved}, or start a ` +
         `separate session with --fresh`,
     };
   }

package/src/core/session-archive.ts

@@ -0,0 +1,4 @@
+/** 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);
+}