@superjackfruitlabs/salaam 0.0.4 → 0.0.5

package/src/tui.ts

@@ -11,9 +11,19 @@ import {
   type OverlayHandle,
   type KeyId,
 } from '@earendil-works/pi-tui';
+import { extractMentions, isSensitivePath } from './mentions.js';
+import { MentionAutocompleteProvider } from './tui-mentions.js';
 import { execFile, spawn, type ChildProcess } from 'node:child_process';
 import { promisify } from 'node:util';
 import { homedir } from 'node:os';
+import {
+  cancelChoices,
+  interactiveCoding,
+  queuedItems,
+  runningAttempt,
+  turnKey,
+  turnKeyAction,
+} from './tui-turn-keys.js';
 import { randomUUID } from 'node:crypto';
 import { join, resolve, basename } from 'node:path';
 import {
@@ -35,26 +45,75 @@ import {
   providerRoute,
   type ProviderRoute,
 } from './provider-config.js';
-import { SLASH_COMMANDS, SLASH_COMPLETIONS, parseSlashCommand, slashHelp } from './tui-commands.js';
+import {
+  INIT_INSTRUCTION,
+  SLASH_COMMANDS,
+  SLASH_COMPLETIONS,
+  parseSlashCommand,
+  slashHelp,
+} from './tui-commands.js';
+import {
+  branchInstruction,
+  commitInstruction,
+  currentBranch,
+  defaultBase,
+  forgeTool,
+  loadGitPrefs,
+  prInstruction,
+  validBranchName,
+} from './git-helpers.js';
 import { conversationExport, writeConversationExport } from './tui-export.js';
+import { describeHooks } from './hooks.js';
+import {
+  expandCustomCommand,
+  loadCustomCommands,
+  matchCustomCommand,
+  type CustomCommand,
+} from './custom-commands.js';
 import { credentialPath } from './credentials.js';
 import { call } from './transport.js';
+import { notificationFor, notify, notifyMode, jobsText, type JobRow } from './tui-notify.js';
+import type { DurableEvent } from './protocol.js';
 import { OperatorClient } from './tui-client.js';
 import { SalaamTheme, safeText, shortId, type ThemeName } from './tui-theme.js';
 import {
   Dynamic,
   DocumentView,
   header,
+  modelLabel,
   tabs,
   status,
   sidebar,
   type ViewModel,
   type ViewTab,
   type DiffPage,
+  modeLabel,
 } from './tui-view.js';
-import { ChoiceModal, FormModal, ConfirmModal, ApprovalModal, TextModal } from './tui-modals.js';
+import { nextMode } from './autonomy.js';
+import {
+  ChoiceModal,
+  FormModal,
+  ConfirmModal,
+  ApprovalModal,
+  approvalReason,
+  onceOnlyReason,
+  TextModal,
+} from './tui-modals.js';
 import type { Approval } from './protocol.js';
 import { commandTerminal } from './coding.js';
+import { rewindItems, rewindSummary } from './tui-review.js';
+import { classifierItems, classifierNotice, type ClassifierView } from './tui-classifier.js';
+import { GLOBAL_KEYS, REVIEW_KEYS, keySheet, type GlobalAction } from './tui-keymap.js';
+import { HerdrReporter, statusEnabled, terminalState, titleFor } from './terminal-status.js';
+import {
+  ComposerHistory,
+  ctrlCAction,
+  historyPath,
+  searchHistory,
+  searchPrompt,
+  shellPassthrough,
+} from './tui-composer.js';
+import type { RewindMode } from './turn-rewind.js';
 
 export interface TuiOptions {
   state: string;
@@ -65,6 +124,10 @@ export interface TuiOptions {
   cwd?: string;
   codingRoot?: string;
   codingSocket?: string;
+  /** Your own custom commands folder; defaults to ~/.config/salaam/commands. */
+  commandsDir?: string;
+  /** `salaam code`: open this folder directly (step 0, 2026-10-31). */
+  start?: import('./session-pick.js').CodeStart;
 }
 /** Frames are atomic. A slow terminal gets one fresh full redraw after drain. */
 export class SalaamTerminal extends ProcessTerminal {
@@ -153,6 +216,12 @@ export class SalaamApp {
   private lastSession?: string;
   private lastRevision?: number;
   private readonly historyKeys = new Set<string>();
+  /** Messages this user sent, kept across sessions without secret-looking lines (Ctrl+R searches it). */
+  private readonly sent = new ComposerHistory(historyPath());
+  /** When Ctrl+C was last pressed on an empty composer; a second press within 2 s leaves. */
+  private ctrlCArmed?: number;
+  /** Reverse history search in progress: the query, the matching entry and the draft it replaces. */
+  private search?: { query: string; index: number; draft: string };
   private readonly removeInput: () => void;
   constructor(readonly options: TuiOptions) {
     this.client = new OperatorClient(options.state);
@@ -186,8 +255,9 @@ export class SalaamApp {
     );
     // The app journals the exact expanded input before clearing it. The library's submit path trims and clears first.
     this.editor.disableSubmit = true;
+    for (const entry of this.sent.entries) this.editor.addToHistory(entry);
     this.editor.setAutocompleteProvider(
-      new CombinedAutocompleteProvider([...SLASH_COMPLETIONS], options.cwd ?? process.cwd(), null),
+      new MentionAutocompleteProvider([...SLASH_COMPLETIONS], options.cwd ?? process.cwd()),
     );
     this.editor.onChange = () => {
       const text = this.editor.getExpandedText(),
@@ -197,6 +267,8 @@ export class SalaamApp {
         return;
       }
       if (this.client.snapshot) this.drafts.set(this.client.snapshot.id, clean);
+      // Starting a command reloads this workspace's custom commands into the completion list.
+      if (clean === '/') this.refreshCommandCompletions();
       this.tui.requestRender();
     };
     this.document = new DocumentView(this.view);
@@ -255,6 +327,10 @@ export class SalaamApp {
     this.done = new Promise((resolve) => (this.finish = resolve));
     this.removeInput = this.tui.addInputListener((data) => this.input(data));
     this.client.on('change', () => this.changed());
+    this.client.on('durable', (event: DurableEvent) => {
+      const message = notificationFor(event);
+      if (message) notify(message, notifyMode());
+    });
   }
   private contentWidth(): number {
     return Math.max(
@@ -262,8 +338,27 @@ export class SalaamApp {
       this.terminal.columns - (this.rail && this.terminal.columns >= 104 ? 31 : 0),
     );
   }
+  // Trial polish C: the window title and Herdr say working / needs you / idle.
+  private readonly statusOn = statusEnabled();
+  private herdr = new HerdrReporter();
+  private lastTitle?: string;
+  private reportStatus(): void {
+    if (!this.statusOn) return;
+    const snapshot = this.client.snapshot;
+    const state = terminalState(snapshot);
+    const name = snapshot
+      ? (this.client.names[snapshot.id] ?? (snapshot.cwd ? basename(snapshot.cwd) : undefined))
+      : undefined;
+    const title = titleFor(state, name);
+    if (title !== this.lastTitle) {
+      this.lastTitle = title;
+      this.terminal.setTitle(title);
+    }
+    this.herdr.report(state, snapshot?.id);
+  }
   private changed(): void {
     const snapshot = this.client.snapshot;
+    this.reportStatus();
     if (snapshot) {
       if (snapshot.id !== this.lastSession) {
         if (this.lastSession) this.drafts.set(this.lastSession, this.editor.getExpandedText());
@@ -282,6 +377,11 @@ export class SalaamApp {
           this.historyKeys.add(submission.id);
           this.editor.addToHistory(submission.text);
         }
+      // Phase 2b: the status line shows this session's mode; reload it when the session changes.
+      if (this.client.snapshot?.id !== this.modeSession) {
+        this.modeSession = this.client.snapshot?.id;
+        void this.loadMode().catch(() => {});
+      }
       if (this.client.workspace?.revision !== this.lastRevision) {
         this.lastRevision = this.client.workspace?.revision;
         this.view.diff = undefined;
@@ -293,19 +393,73 @@ export class SalaamApp {
     this.tui.requestRender();
   }
   private input(data: string): { consume: true } | undefined {
-    if (
-      matchesKey(data, 'ctrl+c') ||
-      (matchesKey(data, 'ctrl+d') && !this.editor.getExpandedText())
-    ) {
+    if (this.search) return this.searchKey(data);
+    if (matchesKey(data, 'ctrl+c')) {
+      this.ctrlC();
+      return { consume: true };
+    }
+    this.ctrlCArmed = undefined;
+    if (matchesKey(data, 'ctrl+d') && !this.editor.getExpandedText()) {
       this.finish();
       return { consume: true };
     }
     if (this.modal) return;
+    if (matchesKey(data, 'ctrl+r')) {
+      this.startSearch();
+      return { consume: true };
+    }
     if (
       this.editor.isShowingAutocomplete() &&
       (matchesKey(data, 'enter') || matchesKey(data, 'tab') || matchesKey(data, 'escape'))
     )
       return;
+    if (data === '?' && this.editor.getExpandedText() === '') {
+      this.help();
+      return { consume: true };
+    }
+    // Esc stops the running turn, Enter steers it, Tab queues behind it (interactive coding only).
+    const key = turnKey(data);
+    const action = key
+      ? turnKeyAction({
+          key,
+          text: this.editor.getExpandedText(),
+          snapshot: this.client.snapshot,
+          modal: false,
+          autocomplete: false,
+        })
+      : null;
+    if (action === 'interrupt') {
+      const attempt = runningAttempt(this.client.snapshot);
+      if (attempt)
+        void this.execute(async () => {
+          await this.client.cancel(attempt);
+          this.client.report(
+            'Stopped the turn. Edits already made stay; /undo reverts the last one. Your typed text is kept.',
+          );
+        });
+      return { consume: true };
+    }
+    if (action === 'steer' || action === 'queue') {
+      const text = this.editor.getExpandedText(),
+        session = this.client.snapshot?.id;
+      void this.execute(async () => {
+        if (action === 'steer') await this.client.steer(text);
+        else {
+          await this.client.submit(text);
+          const waiting = this.client.snapshot ? queuedItems(this.client.snapshot).length : 0;
+          this.client.report(
+            'Queued for after this turn (' + waiting + ' waiting). /queue edits or removes them.',
+          );
+        }
+        this.editor.addToHistory(text);
+        this.sent.add(text);
+        if (this.client.snapshot?.id === session && this.editor.getExpandedText() === text) {
+          this.editor.setText('');
+          if (session) this.drafts.delete(session);
+        }
+      });
+      return { consume: true };
+    }
     if (matchesKey(data, 'enter')) {
       const text = this.editor.getExpandedText(),
         session = this.client.snapshot?.id;
@@ -321,24 +475,11 @@ export class SalaamApp {
       else submit();
       return { consume: true };
     }
-    const keys: [KeyId, () => void][] = [
-      ['ctrl+k', () => this.palette()],
-      ['ctrl+p', () => void this.execute(() => this.sessions())],
-      ['ctrl+n', () => void this.execute(() => this.newSession())],
-      ['ctrl+o', () => this.approvals()],
-      ['ctrl+g', () => this.setTab('changes')],
-      ['ctrl+t', () => this.setTab('commands')],
-      [
-        'ctrl+b',
-        () => {
-          this.rail = !this.rail;
-          this.tui.requestRender(true);
-        },
-      ],
-      ['ctrl+r', () => void this.execute(() => this.refresh())],
-      ['ctrl+e', () => void this.execute(() => this.editPrompt())],
-      ['f1', () => this.help()],
-    ];
+    // Ctrl+K kills to the end of the line while the composer has text (readline); on an empty
+    // composer it opens the actions palette. F2 always opens it.
+    if (matchesKey(data, 'ctrl+k') && this.editor.getExpandedText() !== '') return;
+    const actions = this.globalActions();
+    const keys: [KeyId, () => void][] = GLOBAL_KEYS.map((k) => [k.key, () => actions[k.action]()]);
     for (const [key, action] of keys)
       if (matchesKey(data, key)) {
         if (this.view.busy) this.pendingAction = action;
@@ -352,6 +493,10 @@ export class SalaamApp {
       this.setTab(names[(names.indexOf(this.view.tab) + 1) % names.length]!);
       return { consume: true };
     }
+    if (this.view.tab === 'changes' && interactiveCoding(this.client.snapshot)) {
+      const handled = this.reviewKey(data);
+      if (handled) return handled;
+    }
     if (
       this.view.tab === 'changes' &&
       (matchesKey(data, 'alt+right') || matchesKey(data, 'alt+left'))
@@ -364,6 +509,30 @@ export class SalaamApp {
     }
     return;
   }
+  /** What each key in GLOBAL_KEYS does; the table owns the keys, this owns the actions. */
+  private globalActions(): Record<GlobalAction, () => void> {
+    return (this.actionTable ??= {
+      palette: () => this.palette(),
+      sessions: () => void this.execute(() => this.sessions()),
+      new: () => void this.execute(() => this.newSession()),
+      approvals: () => this.approvals(),
+      changes: () => this.setTab('changes'),
+      commands: () => this.setTab('commands'),
+      rail: () => {
+        this.rail = !this.rail;
+        this.tui.requestRender(true);
+      },
+      transcript: () => {
+        this.view.transcript = !this.view.transcript;
+        this.setTab('conversation');
+      },
+      refresh: () => void this.execute(() => this.refresh()),
+      editor: () => void this.execute(() => this.editPrompt()),
+      mode: () => void this.execute(() => this.cycleMode()),
+      help: () => this.help(),
+    });
+  }
+  private actionTable?: Record<GlobalAction, () => void>;
   private async execute(work: () => Promise<unknown>): Promise<void> {
     if (this.view.busy) {
       const session = this.client.snapshot?.id ?? this.options.session;
@@ -426,6 +595,7 @@ export class SalaamApp {
     description: string,
     label: string,
     confirm: () => Promise<unknown>,
+    confirmByDefault = false,
   ): void {
     if (this.terminal.rows < 18) {
       this.client.report('Expand the terminal to at least 18 rows to review this action.');
@@ -443,6 +613,7 @@ export class SalaamApp {
           this.closeModal();
           void this.execute(confirm);
         },
+        confirmByDefault,
       ),
     );
   }
@@ -476,25 +647,51 @@ export class SalaamApp {
     if (this.client.connection === 'offline')
       throw new Error('Service did not become available. Inspect sal service status.');
   }
+  /** Interactive sessions switch in place between turns; otherwise the choice opens a new session. */
+  private async applyRoute(route: import('./provider-config.js').ProviderRoute): Promise<void> {
+    if (this.client.snapshot?.provider_route && this.client.controlling) {
+      try {
+        await this.client.switchRoute(route);
+        this.client.notice = 'Now using ' + modelLabel(this.client) + ' in this session.';
+        return;
+      } catch (error) {
+        // A route that limits output differently cannot join this session. Keep the choice and
+        // open the new session with it, rather than leaving the old model selected.
+        if ((error as { code?: string }).code !== 'provider_output_cap_changed') throw error;
+        this.selectedRoute = route;
+        this.client.notice = `${route.model ?? route.provider} limits output differently from this session's model, so it starts in a new session. This session stays as it is.`;
+        await this.newSession();
+        return;
+      }
+    }
+    this.selectedRoute = route;
+    await this.newSession();
+  }
   private modelPicker(): void {
+    const configured = (this.client.snapshot?.provider_route ?? this.client.health?.provider_route)
+      ?.provider;
+    const live = PI_PROVIDERS.filter((p) => p.getModels().length);
     this.choice(
-      'Provider · applies to a new session',
+      this.client.snapshot ? 'Provider · switches this session' : 'Provider',
       [
+        // The configured provider first; the scripted demo last, never the default.
+        ...[
+          ...live.filter((p) => p.id === configured),
+          ...live.filter((p) => p.id !== configured),
+        ].map((p) => ({
+          value: p.id,
+          label: p.name,
+          description: p.id + (p.id === configured ? ' · current' : ''),
+        })),
         {
           value: 'offline',
           label: 'Offline demo',
           description: 'Scripted fixture, not an AI model',
         },
-        ...PI_PROVIDERS.filter((p) => p.getModels().length).map((p) => ({
-          value: p.id,
-          label: p.name,
-          description: p.id,
-        })),
       ],
       (provider) => {
         if (provider === 'offline') {
-          this.selectedRoute = providerRoute();
-          void this.execute(() => this.newSession());
+          void this.execute(() => this.applyRoute(providerRoute()));
           return;
         }
         const catalog = PI_PROVIDERS.find((p) => p.id === provider)!;
@@ -505,14 +702,100 @@ export class SalaamApp {
             label: m.name,
             description: m.id + ' · ' + m.contextWindow + ' context tokens',
           })),
-          (model) => {
-            this.selectedRoute = providerRoute(provider, model);
-            void this.execute(() => this.newSession());
-          },
+          (model) => void this.execute(() => this.applyRoute(providerRoute(provider, model))),
         );
       },
     );
   }
+  private modeSession: string | undefined;
+  /** Phase 2b: the session's mode and full access, for the status line. */
+  private async loadMode(): Promise<void> {
+    if (!this.client.snapshot) {
+      this.view.mode = undefined;
+      return;
+    }
+    const current = await this.client.permissions();
+    this.view.mode =
+      current.configurable && current.coding
+        ? {
+            mode: current.policy.mode,
+            ...(current.policy.access ? { access: current.policy.access } : {}),
+            ...(current.command_sandbox ? { sandbox: current.command_sandbox } : {}),
+          }
+        : undefined;
+    this.tui.requestRender();
+  }
+  /** Shift+Tab: review → accept edits → auto. Full access and YOLO are kept as they are; each has
+   * its own command. */
+  private async cycleMode(): Promise<void> {
+    const session = this.client.snapshot?.id;
+    if (!session) throw new Error('Open a session first.');
+    const current = await this.client.permissions();
+    if (!current.configurable || !current.coding)
+      throw new Error('Modes are for local coding sessions. No session or files were changed.');
+    await this.client.setPermissions(session, current.policy.revision, {
+      mode: nextMode(current.policy.mode),
+      paths: [],
+      ...(current.policy.access ? { access: current.policy.access } : {}),
+    });
+    await this.loadMode();
+  }
+  private async setAccess(access: 'full' | 'yolo' | undefined): Promise<void> {
+    const session = this.client.snapshot!.id;
+    const current = await this.client.permissions();
+    await this.client.setPermissions(session, current.policy.revision, {
+      mode: current.policy.mode,
+      paths: current.policy.paths,
+      ...(access ? { access } : {}),
+    });
+    await this.loadMode();
+  }
+  /** Full access on (with a warning and a confirm) or off (at once). From YOLO it steps down at once. */
+  private async fullAccess(): Promise<void> {
+    const session = this.client.snapshot?.id;
+    if (!session) throw new Error('Open a session first.');
+    const current = await this.client.permissions();
+    if (!current.configurable || !current.coding)
+      throw new Error('Full access is for local coding sessions. Nothing was changed.');
+    if (current.policy.access === 'full') return this.setAccess(undefined);
+    if (current.full_access_allowed === false)
+      throw new Error(
+        'The operator does not allow full access on this host. Commands stay in the OS sandbox.',
+      );
+    if (current.policy.access === 'yolo') return this.setAccess('full');
+    this.confirm(
+      'Turn on full access?',
+      'Later commands in this session run WITHOUT the OS sandbox: they can read and change any file your user can, and reach the network directly. They run without asking, except commands the danger check calls dangerous (force pushes, deletes, publishing, credentials, anything it cannot read), which still ask and say why. Run /full-access again to turn it off.',
+      'turn on full access',
+      () => this.setAccess('full'),
+    );
+  }
+  /** YOLO on only after the person types "yolo"; off at once. Never in the Shift+Tab cycle. */
+  private async yolo(): Promise<void> {
+    const session = this.client.snapshot?.id;
+    if (!session) throw new Error('Open a session first.');
+    const current = await this.client.permissions();
+    if (!current.configurable || !current.coding)
+      throw new Error('YOLO is for local coding sessions. Nothing was changed.');
+    if (current.policy.access === 'yolo') return this.setAccess(undefined);
+    if (current.yolo_allowed === false)
+      throw new Error(
+        'YOLO is not allowed for this session: it is only for your own desk sessions on a host whose operator allows it.',
+      );
+    this.taskInput(
+      'Turn on YOLO? Type yolo to confirm',
+      '',
+      'Type yolo',
+      'NO approvals at all: every edit and command runs at once, without the OS sandbox, including force pushes, deletes and publishing. Each one is recorded. /yolo again turns it off.',
+      (value) => {
+        if (value.trim() !== 'yolo') {
+          this.client.report('YOLO stays off: the confirmation was not "yolo".');
+          return;
+        }
+        void this.execute(() => this.setAccess('yolo'));
+      },
+    );
+  }
   private showText(title: string, text: string): void {
     this.showModal(
       new TextModal(
@@ -536,7 +819,48 @@ export class SalaamApp {
       return;
     }
     if (command === 'help') {
-      this.showText('Salaam commands', slashHelp(args || undefined));
+      const custom = args ? [] : this.customCommands();
+      const problems = args ? [] : this.customCommandProblems;
+      this.showText(
+        'Salaam commands',
+        slashHelp(args || undefined) +
+          (custom.length
+            ? '\n\nCustom commands (write a prompt only):\n' +
+              custom
+                .map(
+                  (c) =>
+                    `/${c.name}${c.argumentHint ? ' ' + c.argumentHint : ''} — ${c.description} [${c.scope}]`,
+                )
+                .join('\n')
+            : '') +
+          (problems.length ? '\n\nSkipped command files:\n' + problems.join('\n') : ''),
+      );
+      return;
+    }
+    if (command === 'hooks') {
+      if (args === 'revoke') {
+        await this.client.revokeHooks();
+        return;
+      }
+      const { sources } = await this.client.hooks();
+      if (args === 'trust') {
+        const repo = sources.find((s) => s.scope === 'repo');
+        if (!repo?.digest) throw new Error('This workspace has no readable .salaam/hooks.json.');
+        if (repo.trusted) {
+          this.showText('Hooks', 'This workspace’s hooks are already trusted as they are.');
+          return;
+        }
+        this.confirm(
+          'Trust this workspace’s hooks?',
+          describeHooks([repo]) +
+            '\n\nThese commands will run on your machine, in this session’s sandbox, whenever their event happens. Trust covers this exact content; any change needs trusting again.',
+          'Trust these hooks',
+          () => this.client.trustHooks(repo.digest!),
+        );
+        return;
+      }
+      if (args) throw new Error('Use /hooks, /hooks trust or /hooks revoke.');
+      this.showText('Hooks', describeHooks(sources));
       return;
     }
     if (command === 'keys') {
@@ -549,10 +873,8 @@ export class SalaamApp {
         return;
       }
       const slash = args.indexOf('/');
-      if (slash <= 0)
-        throw new Error('Use /model provider/model. The choice creates a new session.');
-      this.selectedRoute = providerRoute(args.slice(0, slash), args.slice(slash + 1));
-      await this.newSession();
+      if (slash <= 0) throw new Error('Use /model provider/model.');
+      await this.applyRoute(providerRoute(args.slice(0, slash), args.slice(slash + 1)));
       return;
     }
     if (command === 'provider') {
@@ -561,8 +883,7 @@ export class SalaamApp {
         return;
       }
       if (args === 'offline') {
-        this.selectedRoute = providerRoute();
-        await this.newSession();
+        await this.applyRoute(providerRoute());
         return;
       }
       const provider = PI_PROVIDERS.find((p) => p.id === args);
@@ -571,10 +892,7 @@ export class SalaamApp {
       this.choice(
         'Model · ' + provider.name,
         provider.getModels().map((m) => ({ value: m.id, label: m.name, description: m.id })),
-        (model) => {
-          this.selectedRoute = providerRoute(args, model);
-          void this.execute(() => this.newSession());
-        },
+        (model) => void this.execute(() => this.applyRoute(providerRoute(args, model))),
       );
       return;
     }
@@ -602,7 +920,7 @@ export class SalaamApp {
         [
           { value: 'permissions', label: 'Permissions · inspect, review or scoped edits' },
           { value: 'progression', label: 'Progression · manual, bounded tasks or schedules' },
-          { value: 'model', label: 'Provider and model (new session)' },
+          { value: 'model', label: 'Provider and model' },
           { value: 'theme', label: 'Switch Night / Paper' },
           { value: 'rail', label: 'Toggle workspace rail' },
           { value: 'keys', label: 'Keyboard shortcuts' },
@@ -639,6 +957,10 @@ export class SalaamApp {
       return;
     }
     if (!snapshot) throw new Error('Choose a session with /sessions or /new first.');
+    if (command === 'rewind') {
+      await this.rewind(args);
+      return;
+    }
     if (command === 'undo') {
       if (args === 'reconcile') {
         await this.client.reconcileUndo();
@@ -682,6 +1004,36 @@ export class SalaamApp {
       );
       return;
     }
+    if (command === 'commit' || command === 'branch' || command === 'pr') {
+      if (!snapshot.capabilities.includes('local-coding-reviewed'))
+        throw new Error(`/${command} runs git. Start a coding session with /coding first.`);
+      const root = snapshot.cwd;
+      let instruction: string;
+      if (command === 'commit')
+        instruction = commitInstruction({ ...loadGitPrefs(), session: snapshot.id });
+      else if (command === 'branch') {
+        if (!args) throw new Error('Usage: /branch <name>');
+        instruction = branchInstruction(args);
+      } else {
+        const branch = currentBranch(root),
+          base = args || defaultBase(root);
+        if (!branch) throw new Error('/pr needs a checked-out branch, not a detached HEAD.');
+        if (branch === base)
+          throw new Error(`You are on ${base}. Create a branch first with /branch <name>.`);
+        if (!validBranchName(base)) throw new Error(`"${base}" is not a valid branch name.`);
+        instruction = prInstruction({ tool: forgeTool(root), branch, base });
+      }
+      await this.client.submit(instruction);
+      this.setTab('conversation');
+      return;
+    }
+    if (command === 'init') {
+      if (!snapshot.capabilities.includes('local-coding-reviewed'))
+        throw new Error('/init writes a file. Start a coding session with /coding first.');
+      await this.client.submit(INIT_INSTRUCTION);
+      this.setTab('conversation');
+      return;
+    }
     if (command === 'compact') {
       await this.client.compact();
       return;
@@ -695,7 +1047,9 @@ export class SalaamApp {
       return;
     }
     if (command === 'diff') {
-      if (snapshot.capabilities.includes('local-workspace-read')) {
+      // Coding sessions review their diff file by file in Changes (Phase 3a).
+      if (snapshot.capabilities.includes('local-coding-reviewed')) this.setTab('changes');
+      else if (snapshot.capabilities.includes('local-workspace-read')) {
         const diff = await call<{ text: string }>(
           this.client.socket,
           `/v1/sessions/${snapshot.id}/local-diff`,
@@ -712,10 +1066,59 @@ export class SalaamApp {
       this.taskActions();
       return;
     }
-    if (command === 'cancel') {
-      const active = snapshot.attempts.filter((a) =>
-        ['accepted', 'dispatching', 'running'].includes(a.state),
+    if (command === 'classifier') {
+      const path = `/v1/sessions/${snapshot.id}/danger-classifier`;
+      const set = async (choice: string) => {
+        const v = await call<ClassifierView>(this.client.socket, path, {
+          ...this.client.actor(),
+          choice,
+        });
+        this.client.notice = classifierNotice(v);
+        this.tui.requestRender();
+      };
+      const want = args.trim();
+      if (want === 'on') {
+        const v = await call<ClassifierView>(this.client.socket, path, {
+          ...this.client.actor(),
+          enabled: true,
+        });
+        this.client.notice = classifierNotice(v);
+        return;
+      }
+      if (want) {
+        await set(want);
+        return;
+      }
+      const v = await call<ClassifierView>(this.client.socket, path);
+      const items = classifierItems(v);
+      if (!items.length) {
+        this.client.notice = classifierNotice(v);
+        return;
+      }
+      this.choice('Command reviewer · ' + classifierNotice(v).split('.')[0], items, (choice) => {
+        void this.execute(() => set(choice));
+      });
+      return;
+    }
+    if (command === 'jobs') {
+      const base = `/v1/sessions/${snapshot.id}/local-tasks`;
+      const stop = /^stop\s+(\S+)$/.exec(args.trim());
+      if (stop) {
+        await call(this.client.socket, `${base}/${stop[1]}/stop`, {});
+        this.client.notice = 'Stopping background command ' + stop[1];
+        return;
+      }
+      const { tasks } = await call<{ tasks: JobRow[] }>(this.client.socket, base);
+      const outputs = await Promise.all(
+        tasks
+          .slice(0, 4)
+          .map((t) => call<{ output: string }>(this.client.socket, `${base}/${t.id}`)),
       );
+      this.showText('Background commands', jobsText(tasks, outputs));
+      return;
+    }
+    if (command === 'cancel') {
+      const active = cancelChoices(snapshot);
       if (!active.length) {
         this.client.report('No active or queued instruction to cancel.');
         return;
@@ -723,15 +1126,18 @@ export class SalaamApp {
       const cancel = (id: string) =>
         this.confirm(
           'Cancel instruction',
-          'Cancel attempt ' + id + '? /exit would leave it running.',
+          'Cancel attempt ' +
+            shortId(id) +
+            '? Your typed text is kept. /exit would leave it running.',
           'Cancel work',
           () => this.client.cancel(id),
+          true,
         );
       if (active.length === 1) cancel(active[0]!.id);
       else
         this.choice(
           'Cancel an instruction',
-          active.map((a) => ({ value: a.id, label: a.state + ' · ' + shortId(a.id) })),
+          active.map((a) => ({ value: a.id, label: a.label })),
           cancel,
         );
       return;
@@ -746,15 +1152,29 @@ export class SalaamApp {
         await this.client.submit(args);
         return;
       }
-      this.showText(
-        'Durable instruction queue',
-        JSON.stringify(
-          snapshot.submissions.filter((s) =>
-            ['accepted', 'dispatching', 'running'].includes(s.state),
-          ),
-          null,
-          2,
-        ),
+      const queued = queuedItems(snapshot);
+      if (!queued.length) {
+        this.client.report('Nothing is queued. Tab queues text for after the running turn.');
+        return;
+      }
+      this.choice(
+        'Queued instructions',
+        queued.map((q) => ({ value: q.attempt, label: q.text.slice(0, 80) })),
+        (attempt) => {
+          const item = queued.find((q) => q.attempt === attempt)!;
+          this.choice(
+            'Queued instruction',
+            [
+              { value: 'edit', label: 'Edit', description: 'Move it back into the input' },
+              { value: 'remove', label: 'Remove', description: 'Cancel it before it runs' },
+            ],
+            (choice) =>
+              void this.execute(async () => {
+                await this.client.cancel(item.attempt);
+                if (choice === 'edit') this.editor.setText(item.text);
+              }),
+          );
+        },
       );
       return;
     }
@@ -782,6 +1202,18 @@ export class SalaamApp {
       );
       return;
     }
+    if (command === 'mode') {
+      await this.cycleMode();
+      return;
+    }
+    if (command === 'full-access') {
+      await this.fullAccess();
+      return;
+    }
+    if (command === 'yolo') {
+      await this.yolo();
+      return;
+    }
     if (command === 'permissions') {
       await this.permissionControls();
       return;
@@ -911,21 +1343,21 @@ export class SalaamApp {
       const current = snapshot.provider_route;
       if (!current || current.provider === 'salaam-proof')
         throw new Error('Choose a live provider/model first with /model.');
-      const choose = (level: string) => {
-        this.selectedRoute = providerRoute(
-          current.provider,
-          current.model,
-          current.max_tokens,
-          current.workspace_id,
-          current.connection,
-          level as import('./provider-config.js').ReasoningLevel,
+      const choose = (level: string) =>
+        this.applyRoute(
+          providerRoute(
+            current.provider,
+            current.model,
+            current.max_tokens,
+            current.workspace_id,
+            current.connection,
+            level as import('./provider-config.js').ReasoningLevel,
+          ),
         );
-        return this.newSession(snapshot.capabilities.includes('local-coding-reviewed'));
-      };
       if (args) await choose(args);
       else
         this.choice(
-          'Reasoning · new session · current ' + (current.reasoning ?? 'automatic low'),
+          'Reasoning · current ' + (current.reasoning ?? 'automatic low'),
           REASONING_LEVELS.map((level) => ({ value: level, label: level })),
           (level) => void this.execute(() => choose(level)),
         );
@@ -974,9 +1406,7 @@ export class SalaamApp {
     await this.startService();
     this.showModal(
       new FormModal(
-        (localCoding
-          ? 'New coding session · reviewed edits and unsandboxed commands · '
-          : 'New session · ') +
+        (localCoding ? 'New coding session · reviewed edits and commands · ' : 'New session · ') +
           (this.selectedRoute?.model ?? this.client.health?.provider_route.model ?? 'default'),
         this.options.cwd ?? this.client.snapshot?.cwd ?? process.cwd(),
         this.view.theme,
@@ -994,19 +1424,28 @@ export class SalaamApp {
     );
   }
   private async sessions(): Promise<void> {
+    const { pickerOrder, sessionDescription } = await import('./session-pick.js');
     await this.client.list();
+    const now = Date.now();
     this.choice(
       'Your Salaam sessions',
       [
         { value: 'new', label: '+ New session', description: 'Start a fresh workspace' },
-        ...this.client.sessions.map((session) => ({
-          value: session.id,
-          label:
-            (this.client.names[session.id] ?? basename(session.cwd)) + '  ' + shortId(session.id),
-          description: session.state + ' · ' + session.cwd,
-        })),
+        ...pickerOrder(this.client.sessions, resolve(this.options.cwd ?? process.cwd())).map(
+          (session) => ({
+            value: session.id,
+            label:
+              (this.client.names[session.id] ?? basename(session.cwd)) + '  ' + shortId(session.id),
+            description: sessionDescription(session, now),
+          }),
+        ),
       ],
       (value) => {
+        if (value === 'transcript') {
+          this.view.transcript = !this.view.transcript;
+          this.setTab('conversation');
+          return;
+        }
         if (value === 'model') this.modelPicker();
         else if (value === 'help') void this.execute(() => this.runSlashCommand('help'));
         else if (value === 'coding') void this.execute(() => this.newSession(true));
@@ -1022,11 +1461,71 @@ export class SalaamApp {
       },
     );
   }
+  private commandCache?: { root: string; at: number; commands: CustomCommand[] };
+  private customCommandProblems: string[] = [];
+  /** This workspace's and your own custom commands, reread at most every two seconds. */
+  customCommands(): CustomCommand[] {
+    const root = this.client.snapshot?.cwd ?? this.options.cwd ?? process.cwd();
+    const cached = this.commandCache;
+    if (cached && cached.root === root && Date.now() - cached.at < 2000) return cached.commands;
+    const { commands, problems } = loadCustomCommands(root, this.options.commandsDir);
+    this.customCommandProblems = problems;
+    this.commandCache = { root, at: Date.now(), commands };
+    return commands;
+  }
+  private refreshCommandCompletions(): void {
+    const root = this.client.snapshot?.cwd ?? this.options.cwd ?? process.cwd();
+    this.editor.setAutocompleteProvider(
+      new MentionAutocompleteProvider(
+        [
+          ...SLASH_COMPLETIONS,
+          ...this.customCommands().map((c) => ({
+            name: c.name,
+            description: `${c.description} [${c.scope}]`,
+          })),
+        ],
+        root,
+      ),
+    );
+  }
   private async submit(): Promise<void> {
     const text = this.editor.getExpandedText(),
       session = this.client.snapshot?.id,
       continuation = this.view.continuation;
     if (!text.trim()) return;
+    const shell = shellPassthrough(text);
+    if (shell) {
+      if (!session) throw new Error('Create or choose a session with ctrl+n or ctrl+p first.');
+      if (!interactiveCoding(this.client.snapshot))
+        throw new Error('!command works in local coding sessions (salaam code).');
+      await this.deliver(shell, session, continuation, false, text);
+      return;
+    }
+    // A custom command only writes a prompt; built-in names never reach here (they are refused at
+    // load), and the expanded prompt goes through every check an ordinary message does.
+    const custom = text.trim().startsWith('/')
+      ? matchCustomCommand(text, this.customCommands())
+      : null;
+    if (custom) {
+      if (!session) throw new Error('Create or choose a session with ctrl+n or ctrl+p first.');
+      const prompt = expandCustomCommand(custom.command, custom.args);
+      if (Buffer.byteLength(prompt) > 65536)
+        throw new Error(`/${custom.command.name} expands past 64 KiB. Shorten the command file.`);
+      const secrets = extractMentions(prompt).filter(isSensitivePath);
+      const send = (sensitive: boolean) =>
+        this.deliver(prompt, session, continuation, sensitive, text);
+      if (secrets.length) {
+        this.confirm(
+          'Attach secret-looking files?',
+          `/${custom.command.name} mentions ${secrets.map((s) => '@' + s).join(', ')}, which will be sent to the model in full.`,
+          'Attach and send',
+          () => send(true),
+        );
+        return;
+      }
+      await send(false);
+      return;
+    }
     const command = parseSlashCommand(text);
     if (command) {
       await this.runSlashCommand(command.name, command.args);
@@ -1037,9 +1536,30 @@ export class SalaamApp {
     if (!session) throw new Error('Create or choose a session with ctrl+n or ctrl+p first.');
     if (Buffer.byteLength(text) > 65536)
       throw new Error('The composer accepts at most 64 KiB. Use an artifact for longer input.');
-    await this.client.submit(text, continuation);
-    this.editor.addToHistory(text);
-    if (this.client.snapshot?.id === session && this.editor.getExpandedText() === text) {
+    const secrets = extractMentions(text).filter(isSensitivePath);
+    if (secrets.length) {
+      this.confirm(
+        'Attach secret-looking files?',
+        `${secrets.map((s) => '@' + s).join(', ')} will be sent to the model in full.`,
+        'Attach and send',
+        () => this.deliver(text, session, continuation, true),
+      );
+      return;
+    }
+    await this.deliver(text, session, continuation, false);
+  }
+  private async deliver(
+    text: string,
+    session: string,
+    continuation: string | undefined,
+    confirmSensitive: boolean,
+    /** What was typed, when it differs from what is sent (a custom command). */
+    typed = text,
+  ): Promise<void> {
+    await this.client.submit(text, continuation, confirmSensitive);
+    this.editor.addToHistory(typed);
+    this.sent.add(typed);
+    if (this.client.snapshot?.id === session && this.editor.getExpandedText() === typed) {
       this.editor.setText('');
       this.drafts.delete(session);
     }
@@ -1050,16 +1570,143 @@ export class SalaamApp {
   setTab(tab: ViewTab): void {
     this.view.tab = tab;
     this.resetScroll();
-    if (tab === 'changes') void this.execute(() => this.loadDiff(this.view.diffOffset));
+    if (tab === 'changes') void this.execute(() => this.loadChanges());
+    this.tui.requestRender();
+  }
+  /** A local coding session reviews its folder against the review base; a coding workspace
+   * keeps its guarded diff. */
+  private loadChanges(): Promise<void> {
+    return interactiveCoding(this.client.snapshot)
+      ? this.loadReview()
+      : this.loadDiff(this.view.diffOffset);
+  }
+  private async loadReview(file = this.view.review?.file ?? 0): Promise<void> {
+    const id = this.client.snapshot?.id;
+    const data = await this.client.changeReview();
+    if (this.client.snapshot?.id !== id) return;
+    const index = data?.files.length ? Math.min(Math.max(0, file), data.files.length - 1) : 0;
+    const path = data?.files[index]?.path;
+    const hunks = data && path ? await this.client.changeHunks(data, path) : undefined;
+    this.view.review = { data, file: index, hunks, hunk: -1 };
+    this.document.invalidate();
     this.tui.requestRender();
   }
+  /** Changes-tab keys: alt+left/right file, alt+up/down hunk; with an empty editor, a accepts,
+   * r reverts and i starts a follow-up instruction about the selection. */
+  private reviewKey(data: string): { consume: true } | undefined {
+    const review = this.view.review;
+    if (!review?.data?.files.length) return;
+    const file = review.data.files[review.file]!;
+    if (
+      matchesKey(data, REVIEW_KEYS.nextFile.key) ||
+      matchesKey(data, REVIEW_KEYS.previousFile.key)
+    ) {
+      const next = review.file + (matchesKey(data, REVIEW_KEYS.nextFile.key) ? 1 : -1);
+      if (next >= 0 && next < review.data.files.length)
+        void this.execute(() => this.loadReview(next));
+      return { consume: true };
+    }
+    if (
+      matchesKey(data, REVIEW_KEYS.nextHunk.key) ||
+      matchesKey(data, REVIEW_KEYS.previousHunk.key)
+    ) {
+      const count = review.hunks?.length ?? 0;
+      review.hunk = Math.max(
+        -1,
+        Math.min(count - 1, review.hunk + (matchesKey(data, REVIEW_KEYS.nextHunk.key) ? 1 : -1)),
+      );
+      this.document.invalidate();
+      this.tui.requestRender();
+      return { consume: true };
+    }
+    if (this.editor.getExpandedText() !== '') return;
+    const hunk = review.hunk >= 0 ? review.hunks?.[review.hunk] : undefined;
+    const what = file.path + (hunk ? ` (hunk ${review.hunk + 1})` : '');
+    const act = (action: 'accept' | 'revert') => async () => {
+      const data = await this.client.changeAct(review.data!, action, file.path, hunk);
+      this.view.review = { data, file: review.file, hunk: -1 };
+      await this.loadReview(review.file);
+      this.client.report((action === 'accept' ? 'Accepted ' : 'Reverted ') + what + '.');
+    };
+    if (data === REVIEW_KEYS.accept.key) {
+      void this.execute(act('accept'));
+      return { consume: true };
+    }
+    if (data === REVIEW_KEYS.revert.key) {
+      this.confirm(
+        'Revert ' + what,
+        (hunk ? 'Puts this hunk back' : 'Puts this file back') +
+          ' the way it was at the review base. Only the reviewed version is written; if the file changed since, nothing is written and you review again.',
+        'Revert',
+        act('revert'),
+      );
+      return { consume: true };
+    }
+    if (data === REVIEW_KEYS.instruct.key) {
+      this.setTab('conversation');
+      this.editor.setText(
+        `In ${file.path}${hunk ? ` (the change at ${hunk.text.split('\n')[0]})` : ''}: `,
+      );
+      return { consume: true };
+    }
+    return;
+  }
+  /** /rewind [turn]: choose a turn and what to restore, review, then confirm once. */
+  private async rewind(args: string): Promise<void> {
+    const points = await this.client.checkpoints();
+    if (!points.length)
+      throw new Error(
+        'No turn has been checkpointed in this session yet. A checkpoint is taken as each turn starts.',
+      );
+    const choose = (attempt: string) =>
+      this.choice(
+        'Rewind · what to restore',
+        [
+          {
+            value: 'both',
+            label: 'Files and conversation',
+            description: 'Restore files and continue from before this turn in a new session',
+          },
+          {
+            value: 'files',
+            label: 'Files only',
+            description: 'Restore files; keep the conversation',
+          },
+          {
+            value: 'conversation',
+            label: 'Conversation only',
+            description: 'Continue from before this turn in a new session; files stay',
+          },
+        ],
+        (mode) =>
+          void this.execute(async () => {
+            const review = await this.client.rewindReview(attempt, mode as RewindMode);
+            this.confirm(
+              `Rewind to before turn ${review.turn}`,
+              rewindSummary(review),
+              'Rewind',
+              async () => {
+                const text = await this.client.rewind(review);
+                if (review.mode !== 'files') this.editor.setText(text);
+              },
+            );
+          }),
+      );
+    if (args) {
+      const found = points.find((p) => String(p.turn) === args.trim());
+      if (!found) throw new Error(`No checkpoint for turn ${args.trim()}. /rewind lists them.`);
+      choose(found.attempt_id);
+      return;
+    }
+    this.choice('Rewind to before which turn?', rewindItems(points), choose);
+  }
   private resetScroll(): void {
     if (this.view.tab === 'conversation' || this.view.tab === 'commands') this.scroll.scrollToEnd();
     else this.scroll.scrollTo(0, { disableFollow: true });
   }
   private async refresh(): Promise<void> {
     await this.client.refresh();
-    if (this.view.tab === 'changes') await this.loadDiff(this.view.diffOffset);
+    if (this.view.tab === 'changes') await this.loadChanges();
   }
   private async loadDiff(offset: number): Promise<void> {
     if (this.diffBusy) return;
@@ -1099,7 +1746,18 @@ export class SalaamApp {
       void this.execute(async () => {
         const approval = approvals.find((a) => a.id === id)!;
         const reviewed = await this.client.review(approval);
-        this.showApproval(reviewed.approval, reviewed.operation);
+        // Desk sessions can approve for the session or always; strict work only ever approves once.
+        const rules = await this.client.approvalRules().catch(() => ({ applies: false }));
+        const onceOnly = rules.applies
+          ? onceOnlyReason(String(reviewed.operation.value))
+          : undefined;
+        this.showApproval(
+          reviewed.approval,
+          reviewed.operation,
+          rules.applies && !onceOnly,
+          onceOnly,
+          rules.applies,
+        );
       });
     if (approvals.length === 1) open(approvals[0]!.id);
     else
@@ -1115,7 +1773,103 @@ export class SalaamApp {
         open,
       );
   }
-  private showApproval(approval: Approval, operation: import('./protocol.js').Operation): void {
+  /** /permissions → Approval rules: list them, remove one, or add one in plain words. */
+  private async approvalRules(): Promise<void> {
+    const { applies, rules, problems } = await this.client.approvalRules();
+    if (!applies) {
+      this.client.report('Approval rules apply only to desk coding sessions.');
+      return;
+    }
+    const describe = (r: import('./approval-rules.js').StoredRule) =>
+      `${r.effect} ${r.tool} ${r.command ?? (r.paths ?? []).join(', ')}`.trim();
+    this.choice(
+      'Approval rules · deny beats ask beats allow · unmatched requests ask',
+      [
+        {
+          value: 'add',
+          label: 'Add a rule',
+          description: 'e.g. allow command npm test *  ·  deny edit src/secrets/**',
+        },
+        ...rules.map((r) => ({
+          value: 'rule:' + r.id,
+          label: describe(r),
+          description:
+            r.source === 'user'
+              ? 'From your permissions.json; edit that file to change it'
+              : r.source === 'repo'
+                ? 'Always, in this repo · choose to remove'
+                : 'This session · choose to remove',
+        })),
+        ...problems.map((p, i) => ({ value: 'problem:' + i, label: 'Problem', description: p })),
+      ],
+      (value) => {
+        if (value === 'add') {
+          this.taskInput(
+            'New approval rule',
+            '',
+            'effect tool words-or-paths',
+            'allow|ask|deny, then command or edit, then command words (a final * takes any further words) or comma-separated path globs. Example: allow command git status',
+            (text) => {
+              const [effect, tool, ...rest] = text.trim().split(/\s+/);
+              const target = rest.join(' ');
+              const rule =
+                tool === 'edit'
+                  ? {
+                      effect,
+                      tool,
+                      paths: target
+                        .split(',')
+                        .map((p) => p.trim())
+                        .filter(Boolean),
+                    }
+                  : { effect, tool, command: target };
+              this.choice(
+                'Keep this rule for…',
+                [
+                  {
+                    value: 'session',
+                    label: 'This session',
+                    description: 'Gone when the session ends',
+                  },
+                  {
+                    value: 'repo',
+                    label: 'This repo',
+                    description: "Every desk session here; kept in Salaam's state",
+                  },
+                ],
+                (scope) =>
+                  void this.execute(() =>
+                    this.client.addRule(
+                      scope as 'session' | 'repo',
+                      rule as import('./approval-rules.js').ApprovalRule,
+                    ),
+                  ),
+              );
+            },
+          );
+          return;
+        }
+        if (!value.startsWith('rule:')) return;
+        const rule = rules.find((r) => 'rule:' + r.id === value)!;
+        if (rule.source === 'user') {
+          this.client.report(
+            'This rule comes from your permissions.json; edit that file to change it.',
+          );
+          return;
+        }
+        this.confirm('Remove this rule?', describe(rule), 'remove', () =>
+          this.client.removeRule(rule.id),
+        );
+      },
+    );
+  }
+  private showApproval(
+    approval: Approval,
+    operation: import('./protocol.js').Operation,
+    offerRules = false,
+    onceOnly?: string,
+    desk = false,
+  ): void {
     this.showModal(
       new ApprovalModal(
         approval,
@@ -1127,8 +1881,72 @@ export class SalaamApp {
         () => this.closeModal(),
         (decision) => {
           this.closeModal();
-          void this.execute(() => this.client.decide(approval, decision));
+          if (decision === 'approve' || decision === 'deny') {
+            void this.execute(() => this.client.decide(approval, decision));
+            return;
+          }
+          if (decision === 'deny-feedback') {
+            // Deny, then tell the agent why in its own turn, the way steering reaches it.
+            this.taskInput(
+              'Deny and tell it why',
+              '',
+              'Why not, or what to do instead',
+              'One line. The request is denied and this reaches the agent as feedback.',
+              (why) =>
+                void this.execute(async () => {
+                  await this.client.decide(approval, 'deny');
+                  const text = why.trim();
+                  if (!text) return;
+                  // The turn has usually moved on by now; if it ended, put the reason in the
+                  // composer instead of losing it.
+                  const feedback = `I denied that request (${safeText(operation.target)}). ${text}`;
+                  try {
+                    await this.client.steer(feedback);
+                  } catch {
+                    this.editor.setText(feedback);
+                    this.client.report(
+                      'Denied. The turn had ended, so your reason is in the composer; press enter to send it.',
+                    );
+                  }
+                }),
+            );
+            return;
+          }
+          // The rule is the exact request just reviewed: its command words or its edited paths.
+          // If it cannot become a rule (shell features, odd words), nothing is approved; say why.
+          const approveWith = (scope: 'session' | 'repo') => async () => {
+            // While the approval is pending the status line shows it, not a notice, so a
+            // refused rule is shown where it cannot be missed.
+            try {
+              await this.client.ruleFromOperation(operation.id, scope);
+            } catch (error) {
+              this.showText(
+                'Not saved as a rule',
+                `${error instanceof Error ? error.message : String(error)}\n\nNothing was approved. Press ctrl+o to approve it once instead.`,
+              );
+              return;
+            }
+            await this.client.decide(approval, 'approve');
+            this.client.report(
+              scope === 'session'
+                ? 'Approved, and the same request will be approved for the rest of this session.'
+                : 'Approved, and the same request will always be approved in this repo. Remove it in /permissions.',
+            );
+          };
+          if (decision === 'approve-session') void this.execute(approveWith('session'));
+          else
+            this.confirm(
+              'Always allow in this repo?',
+              `${safeText(operation.target)}
+
+This exact request will be approved without asking in every desk session on this repository, until you remove it in /permissions. It is kept in Salaam's state, not in the repository.`,
+              'always allow',
+              approveWith('repo'),
+            );
         },
+        offerRules,
+        onceOnly,
+        { desk, reason: approvalReason(String(operation.value), this.view.mode?.mode) },
       ),
       86,
     );
@@ -1181,10 +1999,15 @@ export class SalaamApp {
         },
         ...(current.coding
           ? [
+              {
+                value: 'rules',
+                label: 'Approval rules',
+                description: 'Allow, ask or deny by command words and path globs',
+              },
               {
                 value: 'review',
                 label: 'Review every mutation',
-                description: 'Explicit approval for each edit and unsandboxed shell command',
+                description: 'Explicit approval for each edit and shell command',
               },
               {
                 value: 'scoped-edit',
@@ -1195,6 +2018,10 @@ export class SalaamApp {
           : []),
       ],
       (mode) => {
+        if (mode === 'rules') {
+          void this.execute(() => this.approvalRules());
+          return;
+        }
         if (mode === 'inspect-current') {
           this.showText('Permissions and execution boundary', JSON.stringify(current, null, 2));
           return;
@@ -1203,7 +2030,7 @@ export class SalaamApp {
           this.showModal(
             new TextModal(
               'Review permission policy',
-              `Session ${session}\nWorkspace ${current.policy.root}\nMode ${mode}\nAuto-edit paths: ${paths.join(', ') || '(none)'}\nAll shell commands still require approval. This is not an OS sandbox. Progression and budgets remain unchanged. Already-running commands are not stopped.`,
+              `Session ${session}\nWorkspace ${current.policy.root}\nMode ${mode}\nAuto-edit paths: ${paths.join(', ') || '(none)'}\nCommands ask unless an approval rule or the session mode allows them (auto allows only sandboxed commands; full access allows all but dangerous ones; YOLO allows everything). Commands run in the host OS sandbox unless full access or YOLO is on. Progression and budgets remain unchanged. Already-running commands are not stopped.`,
               this.view.theme,
               () => this.terminal.rows,
               () => this.tui.requestRender(),
@@ -1832,7 +2659,11 @@ export class SalaamApp {
         label: 'Operator inbox',
         description: 'Shared durable attention and results',
       },
-      { value: 'model', label: 'Choose model and provider', description: '/model · new session' },
+      {
+        value: 'model',
+        label: 'Choose model and provider',
+        description: '/model · switches this session',
+      },
       { value: 'help', label: 'Slash commands', description: '/help' },
       { value: 'new', label: 'New session', description: 'ctrl+n' },
       {
@@ -1852,8 +2683,13 @@ export class SalaamApp {
         label: 'Job actions',
         description: 'Bound one-shot admission and durable occurrence recovery',
       },
-      { value: 'changes', label: 'Review changes', description: 'ctrl+g · guarded workspace diff' },
+      { value: 'changes', label: 'Review changes', description: 'alt+g · guarded workspace diff' },
       { value: 'commands', label: 'Commands and output', description: 'ctrl+t' },
+      {
+        value: 'transcript',
+        label: 'Full transcript',
+        description: 'ctrl+x · every tool call and its output',
+      },
       {
         value: 'context',
         label: 'Session context',
@@ -1905,11 +2741,11 @@ export class SalaamApp {
         label: 'Cancel current work',
         description: 'Explicitly cancel a running instruction',
       },
-      { value: 'refresh', label: 'Refresh connection', description: 'ctrl+r' },
+      { value: 'refresh', label: 'Refresh connection', description: 'f5' },
       {
         value: 'editor',
         label: 'Edit prompt externally',
-        description: 'ctrl+e · VISUAL or EDITOR',
+        description: 'ctrl+g · VISUAL or EDITOR',
       },
       {
         value: 'theme',
@@ -2163,46 +2999,18 @@ export class SalaamApp {
       },
     );
   }
+  /** The keys for where you are: `?` on an empty composer, or F1. Built from tui-keymap.ts. */
   private help(): void {
+    const snapshot = this.client.snapshot;
+    const sheet = keySheet({
+      tab: this.view.tab,
+      coding: interactiveCoding(snapshot),
+      running: interactiveCoding(snapshot) && runningAttempt(snapshot) !== undefined,
+      custom: this.customCommands(),
+    });
     this.choice(
-      'Salaam · keyboard',
-      [
-        {
-          value: 'close',
-          label: 'Enter · send the exact prompt',
-          description: 'The durable outbox saves it before delivery',
-        },
-        {
-          value: 'close',
-          label: 'Alt+Enter / Ctrl+J · new line',
-          description: 'Shift+Enter also works with supported keyboard protocols',
-        },
-        {
-          value: 'close',
-          label: 'Ctrl+K · all actions',
-          description: 'Ctrl+P sessions · Ctrl+N new session · Ctrl+O approvals',
-        },
-        {
-          value: 'close',
-          label: 'Tab · switch view',
-          description: 'Conversation · Changes · Commands · Context',
-        },
-        {
-          value: 'close',
-          label: 'PageUp / PageDown · scroll',
-          description: 'Mouse wheel also scrolls; Ctrl+Home/End jump to the top/bottom',
-        },
-        {
-          value: 'close',
-          label: 'Ctrl+E · external prompt editor',
-          description: 'Runs VISUAL or EDITOR with terminal modes restored',
-        },
-        {
-          value: 'close',
-          label: 'Ctrl+C · detach',
-          description: 'Work continues. Cancel and stop service are separate actions.',
-        },
-      ],
+      sheet.title,
+      sheet.rows.map((row) => ({ value: 'close', ...row })),
       () => {},
     );
   }
@@ -2244,8 +3052,77 @@ export class SalaamApp {
       }
     }
   }
+  /** Ctrl+C: stop a running coding turn, else clear the composer, else arm; twice within 2 s leaves. */
+  private ctrlC(): void {
+    const attempt = interactiveCoding(this.client.snapshot)
+      ? runningAttempt(this.client.snapshot)
+      : undefined;
+    const action = this.modal
+      ? 'exit'
+      : ctrlCAction({
+          running: attempt !== undefined,
+          text: this.editor.getExpandedText(),
+          armedAt: this.ctrlCArmed,
+          now: Date.now(),
+        });
+    this.ctrlCArmed = undefined;
+    if (action === 'exit') this.finish();
+    else if (action === 'interrupt')
+      void this.execute(async () => {
+        await this.client.cancel(attempt!);
+        this.client.report('Stopped the turn. Press ctrl+c twice to leave.');
+      });
+    else if (action === 'clear') {
+      this.editor.setText('');
+      this.client.report('Cleared. Press ctrl+c again to leave, or ctrl+- to undo.');
+    } else {
+      this.ctrlCArmed = Date.now();
+      this.client.report('Press ctrl+c again to leave. Work continues in the service.');
+    }
+  }
+  private startSearch(): void {
+    this.search = { query: '', index: this.sent.entries.length, draft: this.editor.getText() };
+    this.client.report(searchPrompt('', undefined));
+  }
+  /** Keys while Ctrl+R search is open: type to narrow, ctrl+r for older, enter keeps, esc restores. */
+  private searchKey(data: string): { consume: true } {
+    const s = this.search!,
+      entries = this.sent.entries;
+    const show = () => {
+      const match = s.index < entries.length ? entries[s.index] : undefined;
+      if (match !== undefined) this.editor.setText(match);
+      this.client.report(searchPrompt(s.query, match));
+    };
+    if (matchesKey(data, 'escape') || matchesKey(data, 'ctrl+c') || matchesKey(data, 'ctrl+g')) {
+      this.editor.setText(s.draft);
+      this.search = undefined;
+      this.client.report('');
+    } else if (matchesKey(data, 'enter') || matchesKey(data, 'right') || matchesKey(data, 'left')) {
+      this.search = undefined;
+      this.client.report('');
+    } else if (matchesKey(data, 'ctrl+r')) {
+      const found = searchHistory(entries, s.query, s.index);
+      if (found >= 0) s.index = found;
+      show();
+    } else if (matchesKey(data, 'backspace')) {
+      s.query = s.query.slice(0, -1);
+      s.index = searchHistory(entries, s.query, entries.length);
+      if (s.index < 0) s.index = entries.length;
+      if (s.query === '') this.editor.setText(s.draft);
+      show();
+    } else if (data.length === 1 && data >= ' ' && data !== '\x7f') {
+      s.query += data;
+      const found = searchHistory(entries, s.query, Math.min(s.index + 1, entries.length));
+      s.index = found >= 0 ? found : entries.length;
+      if (found < 0) this.editor.setText(s.draft);
+      show();
+    }
+    this.tui.requestRender();
+    return { consume: true };
+  }
   private async initialize(): Promise<void> {
     await this.execute(async () => {
+      if (this.options.start) return this.openHere(this.options.start);
       await this.client.list();
       if (this.options.session)
         await this.client.open(this.options.session, {
@@ -2259,6 +3136,34 @@ export class SalaamApp {
       }
     });
   }
+  /** One command for this folder: start the service if needed, then continue the folder's
+   * latest session, start a new coding session in it, or show the session list. */
+  private async openHere(start: import('./session-pick.js').CodeStart): Promise<void> {
+    const { latestSessionFor, deskUsesAnthropic } = await import('./session-pick.js');
+    await this.startService();
+    if (
+      deskUsesAnthropic(
+        !!this.selectedRoute,
+        this.client.health?.provider_route.provider,
+        existsSync(credentialPath()) || existsSync(credentialPath() + '.json'),
+      )
+    )
+      this.selectedRoute = providerRoute('anthropic');
+    if (start === 'resume') return this.sessions();
+    const cwd = resolve(this.options.cwd ?? process.cwd());
+    const existing = start === 'continue' ? latestSessionFor(this.client.sessions, cwd) : undefined;
+    if (existing)
+      await this.client.open(existing, {
+        observe: this.options.observe,
+        takeover: this.options.takeover,
+      });
+    else {
+      await this.client.create(cwd, false, this.selectedRoute, true);
+      if (start === 'continue')
+        this.client.notice = 'No earlier session in this folder, so this is a new one.';
+    }
+    this.setTab('conversation');
+  }
   async run(): Promise<void> {
     this.running = true;
     const close = () => {
@@ -2278,7 +3183,11 @@ export class SalaamApp {
         if (
           this.client.preview ||
           this.client.snapshot?.approvals.some((a) => a.state === 'pending') ||
-          this.client.commands.some((run) => !commandTerminal(run.state))
+          this.client.commands.some((run) => !commandTerminal(run.state)) ||
+          // The progress line counts seconds while a turn runs, so it never shows a stale state.
+          this.client.snapshot?.attempts.some((a) =>
+            ['accepted', 'dispatching', 'running'].includes(a.state),
+          )
         )
           this.tui.requestRender();
       }, 1000);
@@ -2293,6 +3202,7 @@ export class SalaamApp {
       for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP'] as const) process.off(signal, close);
       process.stdin.off('end', close);
       process.stdout.off('error', close);
+      if (this.statusOn) this.herdr.release();
       await this.terminal.drainInput(150, 25);
       process.stdin.pause();
       process.stdin.unref();