@superjackfruitlabs/salaam 0.0.4 → 0.0.5

package/src/terminal-status.ts

@@ -0,0 +1,103 @@
+import { execFile } from 'node:child_process';
+
+/**
+ * Salaam tells the terminal what it is doing (trial polish C, 2026-10-31): the window title says
+ * working / needs you, and inside Herdr the pane reports its state through Herdr's documented
+ * `pane report-agent` command (herdrdev/herdr, docs/next/.../add-herdr-support.mdx). Herdr's
+ * docs define no OSC 7501 sequence, so none is sent. SALAAM_TERMINAL_STATUS=off turns both off.
+ * Neither carries prompt text, command text or anything secret: only the state and a short
+ * session name.
+ */
+export type TerminalState = 'idle' | 'working' | 'blocked';
+
+export function terminalState(
+  snapshot: { attempts?: { state: string }[]; approvals?: { state: string }[] } | undefined,
+): TerminalState {
+  if (!snapshot) return 'idle';
+  if ((snapshot.approvals ?? []).some((a) => a.state === 'pending')) return 'blocked';
+  if (
+    (snapshot.attempts ?? []).some((a) => ['accepted', 'dispatching', 'running'].includes(a.state))
+  )
+    return 'working';
+  return 'idle';
+}
+
+export function titleFor(state: TerminalState, name: string | undefined): string {
+  // eslint-disable-next-line no-control-regex
+  const clean = name
+    ?.replace(/[\x00-\x1f\x7f-\x9f]/g, '')
+    .trim()
+    .slice(0, 32);
+  if (!clean) return 'Salaam';
+  const words = state === 'blocked' ? 'needs you' : state === 'working' ? 'working' : 'idle';
+  return `Salaam · ${clean} · ${words}`;
+}
+
+export function statusEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.SALAAM_TERMINAL_STATUS !== 'off';
+}
+
+type Run = (bin: string, args: string[], done: () => void) => void;
+const run: Run = (bin, args, done) => {
+  // Short timeout, failures ignored: Herdr must never slow Salaam down.
+  execFile(bin, args, { timeout: 2000, windowsHide: true }, () => done());
+};
+
+/** Reports to Herdr only inside a Herdr pane; one report in flight, newest state wins. */
+export class HerdrReporter {
+  readonly enabled: boolean;
+  private seq = 0;
+  private busy = false;
+  private queued?: string[];
+  private last?: string;
+  constructor(
+    private readonly env: NodeJS.ProcessEnv = process.env,
+    private readonly exec: Run = run,
+    private readonly now: () => number = Date.now,
+  ) {
+    this.enabled = !!(env.HERDR_ENV === '1' && env.HERDR_PANE_ID && env.HERDR_BIN_PATH);
+  }
+  private nextSeq(): string {
+    this.seq = Math.max(this.seq + 1, this.now());
+    return String(this.seq);
+  }
+  private head(verb: string): string[] {
+    return ['pane', verb, this.env.HERDR_PANE_ID!, '--source', 'salaam', '--agent', 'salaam'];
+  }
+  report(state: TerminalState, session: string | undefined): void {
+    if (!this.enabled) return;
+    const key = state + ' ' + (session ?? '');
+    if (key === this.last) return;
+    this.last = key;
+    this.queued = [
+      ...this.head('report-agent'),
+      '--state',
+      state,
+      '--seq',
+      '',
+      ...(state === 'blocked' ? ['--message', 'Waiting for your approval'] : []),
+      ...(session ? ['--agent-session-id', session, '--', 'salaam', '--session', session] : []),
+    ];
+    this.flush();
+  }
+  release(): void {
+    if (!this.enabled) return;
+    this.queued = undefined;
+    this.exec(
+      this.env.HERDR_BIN_PATH!,
+      [...this.head('release-agent'), '--seq', this.nextSeq()],
+      () => {},
+    );
+  }
+  private flush(): void {
+    if (this.busy || !this.queued) return;
+    const args = this.queued;
+    this.queued = undefined;
+    args[args.indexOf('--seq') + 1] = this.nextSeq();
+    this.busy = true;
+    this.exec(this.env.HERDR_BIN_PATH!, args, () => {
+      this.busy = false;
+      this.flush();
+    });
+  }
+}

package/src/tui-activity.ts

@@ -0,0 +1,133 @@
+import { humanTool, safeText } from './tui-theme.js';
+
+/**
+ * One compact line per tool call in the conversation (trial polish #9): what ran and how it
+ * ended, e.g. `Edit src/x.ts +3 −1` or `Bash npm test ✓ exit 0` with the last output lines.
+ * Built only from the recorded tool activity; it never reads the workspace.
+ */
+export interface ToolLine {
+  state: 'running' | 'finished' | 'failed';
+  label: string;
+  /** The last output lines of a finished command (at most `tail` lines). */
+  tail: string[];
+  /** A command's full output as text, for the transcript; absent when only the raw record exists. */
+  full?: string;
+}
+const lineCount = (text: string) => (text === '' ? 0 : text.replace(/\n$/, '').split('\n').length);
+function short(text: string, max = 60): string {
+  const first = safeText(text).split('\n')[0]!.trim();
+  return first.length > max ? first.slice(0, max - 1) + '…' : first;
+}
+/** The recorded result of a local command: its exit code and output, even from a truncated record. */
+function commandResult(output?: string): { exit?: number | null; text?: string } {
+  if (!output) return {};
+  try {
+    const parsed = JSON.parse(output) as { exit_code?: number | null; output?: string };
+    return { exit: parsed.exit_code, text: parsed.output };
+  } catch {
+    const exit = /"exit_code":(-?\d+|null)/.exec(output)?.[1];
+    return exit === undefined ? {} : { exit: exit === 'null' ? null : Number(exit) };
+  }
+}
+export function toolLine(
+  tool: string,
+  input: string | undefined,
+  finished: { failed?: boolean; output?: string } | undefined,
+  tail = 3,
+): ToolLine {
+  const state = !finished ? 'running' : finished.failed ? 'failed' : 'finished';
+  let args: {
+    action?: string;
+    command?: string;
+    background?: boolean;
+    edits?: {
+      path?: string;
+      content?: string;
+      sha256?: string | null;
+      replacements?: { old: string; new: string }[];
+    }[];
+  } = {};
+  try {
+    args = JSON.parse(input ?? '{}');
+  } catch {}
+  if (tool === 'salaam_local' && args.action === 'edit' && Array.isArray(args.edits)) {
+    let added = 0,
+      removed = 0,
+      created = false;
+    for (const edit of args.edits) {
+      if (edit.replacements?.length)
+        for (const r of edit.replacements) {
+          added += lineCount(r.new);
+          removed += lineCount(r.old);
+        }
+      else if (typeof edit.content === 'string') {
+        added += lineCount(edit.content);
+        if (edit.sha256 === null) created = true;
+      }
+    }
+    const what =
+      args.edits.length === 1
+        ? safeText(String(args.edits[0]!.path ?? ''))
+        : `${args.edits.length} files`;
+    return {
+      state,
+      label: `Edit ${what} +${added} −${removed}${created ? ' (new)' : ''}`,
+      tail: [],
+    };
+  }
+  if (tool === 'salaam_local' && args.action === 'command' && typeof args.command === 'string') {
+    const result = commandResult(finished?.output);
+    const ended =
+      !finished || args.background
+        ? args.background && finished
+          ? ' · background'
+          : ''
+        : result.exit === 0
+          ? ' ✓ exit 0'
+          : result.exit === undefined || result.exit === null
+            ? finished.failed
+              ? ' × did not finish'
+              : ''
+            : ` × exit ${result.exit}`;
+    const lines = (result.text ?? '')
+      .replace(/\n+$/, '')
+      .split('\n')
+      .filter((l) => l.trim() !== '');
+    return {
+      state:
+        finished && result.exit !== undefined && result.exit !== null && result.exit !== 0
+          ? 'failed'
+          : state,
+      label: `Bash ${short(args.command)}${ended}`,
+      tail: finished ? lines.slice(-tail).map((l) => short(l, 120)) : [],
+      ...(result.text !== undefined ? { full: result.text.replace(/\n+$/, '') } : {}),
+    };
+  }
+  return { state, label: humanTool(tool, input), tail: [] };
+}
+
+/** The verb the progress line shows for what the agent is doing now. */
+export function activityVerb(running?: ToolLine): string {
+  if (!running) return 'Thinking';
+  if (running.label.startsWith('Edit ')) return 'Editing';
+  if (running.label.startsWith('Bash ')) return 'Running ' + running.label.slice(5);
+  return running.label;
+}
+
+const SPIN = ['◐', '◓', '◑', '◒'];
+/** The live progress line while a turn runs: spinner, verb, elapsed seconds, tokens, interrupt hint. */
+export function progressLine(
+  verb: string,
+  startedAt: number,
+  now: number,
+  tokens?: string,
+): string {
+  const seconds = Math.max(0, Math.floor((now - startedAt) / 1000));
+  const elapsed = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  return [
+    SPIN[seconds % SPIN.length] + ' ' + safeText(verb) + '…',
+    elapsed,
+    ...(tokens ? [tokens + ' tokens'] : []),
+    'esc to interrupt',
+  ].join(' · ');
+}

package/src/tui-classifier.ts

@@ -0,0 +1,38 @@
+/** /classifier (operator 2026-10-31): the command reviewer has its own model selection. */
+export interface ClassifierView {
+  configured: boolean;
+  enabled: boolean;
+  choice: string;
+  pinned: boolean;
+  model?: string;
+  on_unavailable?: string;
+  options: { name: string; provider: string; model: string }[];
+}
+
+/** Picker rows: every configured reviewer, then Off. Empty when there is nothing to choose. */
+export function classifierItems(v: ClassifierView) {
+  if (!v.configured || v.pinned) return [];
+  const mark = (on: boolean) => (on ? '● ' : '○ ');
+  return [
+    ...v.options.map((o) => ({
+      value: o.name,
+      label: mark(v.choice === o.name) + o.name,
+      description: `${o.provider} · ${o.model}`,
+    })),
+    { value: 'off', label: mark(v.choice === 'off') + 'Off', description: 'Rules only' },
+  ];
+}
+
+export function classifierNotice(v: ClassifierView): string {
+  if (!v.configured && v.choice === 'off' && !v.pinned)
+    return 'No command reviewer is configured; set --danger-classifier-config on the service.';
+  const what = v.enabled
+    ? `Command reviewer ${v.choice} (${v.model}) is on for this session` +
+      ` (if it does not answer: ${v.on_unavailable === 'ask' ? 'ask' : 'rules only'})`
+    : 'Command reviewer is off for this session';
+  return (
+    what +
+    (v.pinned ? ', pinned by this host' : '') +
+    '. It can only make a command ask, never let one run.'
+  );
+}

package/src/tui-client.ts

@@ -45,7 +45,15 @@ export interface UsageView {
   known_output: number;
   known_cost: number;
   estimated_cost: number;
+  /** Prompt tokens read from or written to the provider's cache; most of a turn's input. */
+  known_cache_read?: number;
+  known_cache_write?: number;
 }
+/** All input tokens, cached or not. `known_input` alone is only the uncached part. */
+export const usageInput = (u: UsageView) =>
+  u.known_input + (u.known_cache_read ?? 0) + (u.known_cache_write ?? 0);
+/** Known and estimated costs come from different observations, so the spend is their sum. */
+export const usageCost = (u: UsageView) => u.known_cost + u.estimated_cost;
 export interface ToolActivity {
   seq: number;
   kind: string;
@@ -57,6 +65,8 @@ export interface ToolActivity {
     input?: string;
     input_truncated?: boolean;
     failed?: boolean;
+    output?: string;
+    output_truncated?: boolean;
   };
 }
 export interface LivePreview {
@@ -66,6 +76,15 @@ export interface LivePreview {
 }
 export type OperatorConnection = 'connecting' | 'connected' | 'reconnecting' | 'offline';
 /** An operator client only: the service owns workers, authority and durable outcomes. */
+/** "AGENTS.md" or "AGENTS.md (2 files)": which instruction files guide this session. */
+export function instructionsLabel(
+  summary: import('./project-instructions.js').InstructionsSummary,
+): string {
+  const names = [...new Set(summary.files.map((f) => f.path.split('/').at(-1)!))].join(' + ');
+  return summary.files.length > 1 ? `${names} (${summary.files.length} files)` : names;
+}
+/** Longest a stale control lease is waited out (the service's lease TTL is 15 s). */
+const CONTROL_LAPSE_MS = 16000;
 export class OperatorClient extends EventEmitter {
   readonly socket: string;
   readonly clientId = randomUUID();
@@ -142,7 +161,13 @@ export class OperatorClient extends EventEmitter {
     policy: import('./autonomy.js').PermissionPolicy;
     configurable: boolean;
     coding: boolean;
-    command_auto_approval: false;
+    command_auto_approval: boolean;
+    /** Phase 2b: whether this host lets a session choose full access. */
+    full_access_allowed?: boolean;
+    /** Whether this desk session may choose YOLO. */
+    yolo_allowed?: boolean;
+    /** Where the next command runs, e.g. "in a Seatbelt sandbox (workspace-write)". */
+    command_sandbox?: string;
   }> {
     if (!this.snapshot) throw new Error('Choose a session first.');
     return call(this.socket, `/v1/sessions/${this.snapshot.id}/permissions`);
@@ -150,7 +175,11 @@ export class OperatorClient extends EventEmitter {
   async setPermissions(
     session: string,
     expected: number,
-    policy: { mode: import('./autonomy.js').PermissionMode; paths: string[] },
+    policy: {
+      mode: import('./autonomy.js').PermissionMode;
+      paths: string[];
+      access?: 'full' | 'yolo';
+    },
   ): Promise<void> {
     if (this.snapshot?.id !== session)
       throw new Error('Session changed; review permissions again.');
@@ -165,6 +194,64 @@ export class OperatorClient extends EventEmitter {
     );
     await this.refresh();
   }
+  /** Desk-session approval rules (phase 2a). */
+  async approvalRules(): Promise<{
+    applies: boolean;
+    rules: import('./approval-rules.js').StoredRule[];
+    problems: string[];
+  }> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    return call(this.socket, `/v1/sessions/${this.snapshot.id}/approval-rules`);
+  }
+  /** Turn a reviewed request into a rule: its exact command words or its exact edited paths. */
+  async ruleFromOperation(operation: string, scope: 'session' | 'repo'): Promise<void> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    await call(this.socket, `/v1/sessions/${this.snapshot.id}/approval-rules`, {
+      ...this.actor(),
+      request_id: randomUUID(),
+      scope,
+      operation_id: operation,
+    });
+  }
+  async addRule(
+    scope: 'session' | 'repo',
+    rule: import('./approval-rules.js').ApprovalRule,
+  ): Promise<void> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    await call(this.socket, `/v1/sessions/${this.snapshot.id}/approval-rules`, {
+      ...this.actor(),
+      request_id: randomUUID(),
+      scope,
+      rule,
+    });
+    this.report('Rule added.');
+  }
+  async removeRule(id: string): Promise<void> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    await call(this.socket, `/v1/sessions/${this.snapshot.id}/approval-rules/${id}/remove`, {
+      ...this.actor(),
+    });
+    this.report('Rule removed.');
+  }
+  /** Your hooks and this workspace's, with their trust state (Phase 4b). */
+  async hooks(): Promise<{ sources: import('./hooks.js').HookSource[] }> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    return call(this.socket, `/v1/sessions/${this.snapshot.id}/hooks`);
+  }
+  /** Trust this workspace's hooks file as reviewed; `digest` binds the content you saw. */
+  async trustHooks(digest: string): Promise<void> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    await call(this.socket, `/v1/sessions/${this.snapshot.id}/hooks/trust`, {
+      ...this.actor(),
+      digest,
+    });
+    this.report('Workspace hooks trusted. They run from the next tool call or prompt.');
+  }
+  async revokeHooks(): Promise<void> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    await call(this.socket, `/v1/sessions/${this.snapshot.id}/hooks/revoke`, { ...this.actor() });
+    this.report('Workspace hooks no longer trusted; they will not run.');
+  }
   async steer(text: string): Promise<void> {
     if (!this.snapshot) throw new Error('Choose a session first.');
     const result = await call<{ state: string }>(
@@ -208,6 +295,99 @@ export class OperatorClient extends EventEmitter {
     await this.refresh();
     this.report('Reverted the reviewed local edit. Conversation history is preserved.');
   }
+  async checkpoints(): Promise<import('./turn-rewind.js').TurnCheckpoint[]> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    return (
+      await call<{ checkpoints: import('./turn-rewind.js').TurnCheckpoint[] }>(
+        this.socket,
+        `/v1/sessions/${this.snapshot.id}/checkpoints`,
+      )
+    ).checkpoints;
+  }
+  async rewindReview(
+    attempt: string,
+    mode: import('./turn-rewind.js').RewindMode,
+  ): Promise<import('./turn-rewind.js').RewindReview> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    return call(
+      this.socket,
+      `/v1/sessions/${this.snapshot.id}/rewind?attempt=${encodeURIComponent(attempt)}&mode=${mode}`,
+    );
+  }
+  /** Returns the rewound turn's instruction so it can be edited and sent again. */
+  async rewind(review: import('./turn-rewind.js').RewindReview): Promise<string> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    const id = this.snapshot.id;
+    const result = await call<{ state: string; session_id: string; text: string }>(
+      this.socket,
+      `/v1/sessions/${id}/rewind`,
+      {
+        ...this.actor(),
+        request_id: randomUUID(),
+        attempt_id: review.attempt_id,
+        mode: review.mode,
+        review_digest: review.digest,
+      },
+    );
+    if (result.state !== 'completed')
+      throw new Error('Rewind outcome is uncertain; inspect files before continuing.');
+    if (result.session_id !== id) await this.open(result.session_id);
+    else await this.refresh();
+    this.report(
+      (review.mode === 'conversation'
+        ? 'Conversation'
+        : review.mode === 'files'
+          ? 'Files'
+          : 'Files and conversation') +
+        ` rewound to before turn ${review.turn}.` +
+        (result.session_id !== id ? ' The earlier conversation stays as its own session.' : ''),
+    );
+    return result.text;
+  }
+  async changeReview(): Promise<import('./turn-rewind.js').ChangeReview | null> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    return (
+      await call<{ review: import('./turn-rewind.js').ChangeReview | null }>(
+        this.socket,
+        `/v1/sessions/${this.snapshot.id}/review`,
+      )
+    ).review;
+  }
+  async changeHunks(
+    review: import('./turn-rewind.js').ChangeReview,
+    path: string,
+  ): Promise<import('./turn-checkpoints.js').CheckpointHunk[]> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    const q = new URLSearchParams({ path, base: review.base, current: review.current });
+    return (
+      await call<{ hunks: import('./turn-checkpoints.js').CheckpointHunk[] }>(
+        this.socket,
+        `/v1/sessions/${this.snapshot.id}/review/hunks?${q}`,
+      )
+    ).hunks;
+  }
+  async changeAct(
+    review: import('./turn-rewind.js').ChangeReview,
+    action: 'accept' | 'revert',
+    path: string,
+    hunk?: import('./turn-checkpoints.js').CheckpointHunk,
+  ): Promise<import('./turn-rewind.js').ChangeReview | null> {
+    if (!this.snapshot) throw new Error('Choose a session first.');
+    return (
+      await call<{ review: import('./turn-rewind.js').ChangeReview | null }>(
+        this.socket,
+        `/v1/sessions/${this.snapshot.id}/review`,
+        {
+          ...this.actor(),
+          action,
+          path,
+          base: review.base,
+          current: review.current,
+          ...(hunk ? { hunk } : {}),
+        },
+      )
+    ).review;
+  }
   async fork(): Promise<void> {
     if (!this.snapshot) throw new Error('Choose a session first.');
     const session = await call<Session>(this.socket, `/v1/sessions/${this.snapshot.id}/fork`, {
@@ -291,15 +471,15 @@ export class OperatorClient extends EventEmitter {
     this.snapshot = await call<SessionSnapshot>(this.socket, `/v1/sessions/${id}/snapshot`);
     if (!options.observe) {
       try {
-        this.lease = await acquireControl(this.socket, id, this.clientId, options.takeover);
+        this.lease = await this.acquireOrWait(id, options.takeover);
       } catch (error) {
         if (
           !(error instanceof ServiceError) ||
-          !['control_conflict', 'control_required'].includes(error.code)
+          !['control_conflict', 'control_required', 'control_busy'].includes(error.code)
         )
           throw error;
         this.notice =
-          'Another client has control. You are observing; use Take control to take over.';
+          'Another terminal is using this session and still renews its control. You are observing; press ctrl+k and choose Take control to take it over.';
       }
     }
     if (this.lease) await call(this.socket, `/v1/sessions/${id}/resume`, this.actor());
@@ -313,7 +493,26 @@ export class OperatorClient extends EventEmitter {
     this.watcher = this.watch(id, generation);
     this.changed();
   }
-  private actor(): { client_id: string; token: string } {
+  /** Acquire control. A lease left by a terminal that was killed lapses within its short TTL, so
+   * wait that out once instead of opening as an observer; a live terminal renews and keeps it. */
+  private async acquireOrWait(id: string, takeover?: boolean): Promise<ControlLease> {
+    try {
+      return await acquireControl(this.socket, id, this.clientId, takeover);
+    } catch (error) {
+      if (takeover || !(error instanceof ServiceError) || error.code !== 'control_busy')
+        throw error;
+      const snapshot = await call<SessionSnapshot>(this.socket, `/v1/sessions/${id}/snapshot`);
+      const wait = snapshot.control.expires_at - Date.now();
+      if (wait <= 0 || wait > CONTROL_LAPSE_MS) throw error;
+      this.notice = `Waiting ${Math.ceil(wait / 1000)} s for the previous terminal's control to lapse…`;
+      this.changed();
+      await new Promise((done) => setTimeout(done, wait + 250));
+      const lease = await acquireControl(this.socket, id, this.clientId);
+      this.notice = 'You have control: the previous terminal had stopped.';
+      return lease;
+    }
+  }
+  actor(): { client_id: string; token: string } {
     if (!this.lease) throw new Error('Take control before sending an instruction.');
     return { client_id: this.clientId, token: this.lease.token };
   }
@@ -358,10 +557,10 @@ export class OperatorClient extends EventEmitter {
     await job;
     this.changed();
   }
-  async submit(text: string, continues?: string): Promise<string> {
+  async submit(text: string, continues?: string, confirmSensitive = false): Promise<string> {
     this.actor();
     if (!this.snapshot || !this.outbox) throw new Error('Open a session first.');
-    const record = this.outbox.enqueue(text, this.snapshot.revision, continues);
+    const record = this.outbox.enqueue(text, this.snapshot.revision, continues, confirmSensitive);
     this.notice = 'Instruction saved locally. Delivering…';
     this.changed();
     try {
@@ -374,6 +573,8 @@ export class OperatorClient extends EventEmitter {
         'Delivery pending. The saved instruction will be retried: ' + (error as Error).message;
     }
     await this.refresh().catch(() => {});
+    // A failed worker cannot take the instruction: say so instead of "accepted".
+    this.notice = sessionFailure(this.snapshot) ?? this.notice;
     this.changed();
     return record.request_id;
   }
@@ -469,6 +670,19 @@ export class OperatorClient extends EventEmitter {
     this.notice = 'Reviewed context admitted. Tool permissions are unchanged.';
     await this.refresh();
   }
+  /** Switch this session's model or thinking level between turns; the conversation carries on. */
+  async switchRoute(route: import('./provider-config.js').ProviderRoute): Promise<void> {
+    if (!this.snapshot) throw new Error('Open a session first.');
+    await call(this.socket, `/v1/sessions/${this.snapshot.id}/route`, {
+      ...this.actor(),
+      route: {
+        provider: route.provider === 'salaam-proof' ? 'offline' : route.provider,
+        ...(route.provider === 'salaam-proof' ? {} : { model: route.model }),
+        ...(route.reasoning === undefined ? {} : { reasoning: route.reasoning }),
+      },
+    });
+    await this.refresh();
+  }
   async decide(approval: Approval, decision: 'approve' | 'deny'): Promise<void> {
     if (!this.outbox) throw new Error('Open a session first.');
     this.outbox.enqueueDecision(
@@ -572,6 +786,13 @@ export class OperatorClient extends EventEmitter {
           optional<ToolActivity[]>(`/v1/sessions/${id}/activity`),
         ]);
         if (generation !== this.generation) return;
+        const before =
+          this.snapshot?.id === snapshot.id ? this.snapshot.project_instructions : null;
+        const after = snapshot.project_instructions;
+        if (before && after && after.revision > before.revision)
+          this.notice = after.files.length
+            ? 'Project instructions changed · reloaded ' + instructionsLabel(after)
+            : 'Project instructions removed';
         this.snapshot = snapshot;
         this.health = health;
         this.commands = commands ?? [];
@@ -616,6 +837,7 @@ export class OperatorClient extends EventEmitter {
         (event: DurableEvent) => {
           if (event.seq <= cursor || generation !== this.generation) return;
           cursor = event.seq;
+          this.emit('durable', event);
           if (
             [
               'attempt.completed',
@@ -692,3 +914,12 @@ export class OperatorClient extends EventEmitter {
     await this.leave();
   }
 }
+
+/** What went wrong when a session's worker has failed, for the status line and the Changes tab. */
+export function sessionFailure(
+  s: { state: string; error: string | null } | undefined,
+): string | undefined {
+  if (!s) return undefined;
+  if (s.state !== 'unhealthy' && !(s.state === 'exited' && s.error)) return undefined;
+  return `Session stopped: ${s.error ?? 'the worker is not healthy'}. Fix it, then /new or ctrl+n for a fresh session.`;
+}