@superjackfruitlabs/salaam 0.0.1 → 0.0.3

package/src/tui.ts

@@ -1,5 +1,6 @@
 import {
   Editor,
+  CombinedAutocompleteProvider,
   ProcessTerminal,
   TuiAltScreen,
   ScrollView,
@@ -28,6 +29,14 @@ import {
 } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { ROOT } from './config.js';
+import {
+  PI_PROVIDERS,
+  REASONING_LEVELS,
+  providerRoute,
+  type ProviderRoute,
+} from './provider-config.js';
+import { SLASH_COMMANDS, SLASH_COMPLETIONS, parseSlashCommand, slashHelp } from './tui-commands.js';
+import { conversationExport, writeConversationExport } from './tui-export.js';
 import { credentialPath } from './credentials.js';
 import { call } from './transport.js';
 import { OperatorClient } from './tui-client.js';
@@ -129,6 +138,7 @@ export class SalaamApp {
   readonly document: DocumentView;
   readonly scroll: ScrollView;
   private rail = true;
+  private selectedRoute?: ProviderRoute;
   private modal?: OverlayHandle;
   private finish!: () => void;
   private readonly done: Promise<void>;
@@ -176,6 +186,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;
+    this.editor.setAutocompleteProvider(
+      new CombinedAutocompleteProvider([...SLASH_COMPLETIONS], options.cwd ?? process.cwd(), null),
+    );
     this.editor.onChange = () => {
       const text = this.editor.getExpandedText(),
         clean = safeText(text);
@@ -211,7 +224,9 @@ export class SalaamApp {
           this.view.continuation
             ? 'Continue interrupted work · ' + shortId(this.view.continuation)
             : this.client.controlling
-              ? 'Ask Salaam to build, fix, or explore…'
+              ? this.client.snapshot?.capabilities.includes('local-workspace-read')
+                ? 'Ask about this project · /model · /help'
+                : 'Ask Salaam to build, fix, or explore…'
               : 'Observing · take control to write',
           this.view.continuation ? 'amber' : 'muted',
         ),
@@ -286,8 +301,24 @@ export class SalaamApp {
       return { consume: true };
     }
     if (this.modal) return;
+    if (
+      this.editor.isShowingAutocomplete() &&
+      (matchesKey(data, 'enter') || matchesKey(data, 'tab') || matchesKey(data, 'escape'))
+    )
+      return;
     if (matchesKey(data, 'enter')) {
-      void this.execute(() => this.submit());
+      const text = this.editor.getExpandedText(),
+        session = this.client.snapshot?.id;
+      const submit = () => {
+        if (
+          !this.modal &&
+          this.editor.getExpandedText() === text &&
+          this.client.snapshot?.id === session
+        )
+          void this.execute(() => this.submit());
+      };
+      if (this.view.busy) this.pendingAction = submit;
+      else submit();
       return { consume: true };
     }
     const keys: [KeyId, () => void][] = [
@@ -314,6 +345,8 @@ export class SalaamApp {
         else action();
         return { consume: true };
       }
+    if (matchesKey(data, 'tab') && this.editor.getExpandedText().trimStart().startsWith('/'))
+      return;
     if (matchesKey(data, 'tab')) {
       const names: ViewTab[] = ['conversation', 'changes', 'commands', 'context'];
       this.setTab(names[(names.indexOf(this.view.tab) + 1) % names.length]!);
@@ -332,7 +365,13 @@ export class SalaamApp {
     return;
   }
   private async execute(work: () => Promise<unknown>): Promise<void> {
-    if (this.view.busy) return;
+    if (this.view.busy) {
+      const session = this.client.snapshot?.id ?? this.options.session;
+      this.pendingAction = () => {
+        if (this.client.snapshot?.id === session) void this.execute(work);
+      };
+      return;
+    }
     this.view.busy = true;
     this.tui.requestRender();
     try {
@@ -410,7 +449,12 @@ export class SalaamApp {
   private async startService(): Promise<void> {
     await this.client.list();
     if (this.client.connection === 'connected') return;
-    const provider = existsSync(credentialPath()) ? 'anthropic' : 'offline';
+    if (
+      !this.selectedRoute &&
+      (existsSync(credentialPath()) || existsSync(credentialPath() + '.json'))
+    )
+      this.selectedRoute = providerRoute('anthropic');
+    const provider = 'offline';
     await promisify(execFile)(
       process.execPath,
       [
@@ -432,20 +476,517 @@ export class SalaamApp {
     if (this.client.connection === 'offline')
       throw new Error('Service did not become available. Inspect sal service status.');
   }
-  private async newSession(): Promise<void> {
+  private modelPicker(): void {
+    this.choice(
+      'Provider · applies to a new session',
+      [
+        {
+          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());
+          return;
+        }
+        const catalog = PI_PROVIDERS.find((p) => p.id === provider)!;
+        this.choice(
+          'Model · ' + catalog.name,
+          catalog.getModels().map((m) => ({
+            value: m.id,
+            label: m.name,
+            description: m.id + ' · ' + m.contextWindow + ' context tokens',
+          })),
+          (model) => {
+            this.selectedRoute = providerRoute(provider, model);
+            void this.execute(() => this.newSession());
+          },
+        );
+      },
+    );
+  }
+  private showText(title: string, text: string): void {
+    this.showModal(
+      new TextModal(
+        title,
+        text,
+        this.view.theme,
+        () => this.terminal.rows,
+        () => this.tui.requestRender(),
+        () => this.closeModal(),
+      ),
+    );
+  }
+  private async runSlashCommand(command: string, args = ''): Promise<void> {
+    const snapshot = this.client.snapshot;
+    const definition = SLASH_COMMANDS.find((c) => c.name === command);
+    if (!definition) throw new Error('Unknown command. Use /help.');
+    if (definition.kind === 'unavailable')
+      throw new Error(definition.description + '. No session or files were changed.');
+    if (command === 'exit') {
+      this.finish();
+      return;
+    }
+    if (command === 'help') {
+      this.showText('Salaam commands', slashHelp(args || undefined));
+      return;
+    }
+    if (command === 'keys') {
+      this.help();
+      return;
+    }
+    if (command === 'model') {
+      if (!args) {
+        this.modelPicker();
+        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();
+      return;
+    }
+    if (command === 'provider') {
+      if (!args) {
+        this.modelPicker();
+        return;
+      }
+      if (args === 'offline') {
+        this.selectedRoute = providerRoute();
+        await this.newSession();
+        return;
+      }
+      const provider = PI_PROVIDERS.find((p) => p.id === args);
+      if (!provider)
+        throw new Error('Unknown provider. Use /provider to browse the pinned catalog.');
+      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());
+        },
+      );
+      return;
+    }
+    if (command === 'new' || command === 'coding') {
+      if (args) {
+        await this.startService();
+        await this.client.create(resolve(args), false, this.selectedRoute, command === 'coding');
+        this.setTab('conversation');
+      } else await this.newSession(command === 'coding');
+      return;
+    }
+    if (command === 'sessions') {
+      if (args) {
+        await this.client.open(args, {
+          observe: this.options.observe,
+          takeover: this.options.takeover,
+        });
+        this.setTab('conversation');
+      } else await this.sessions();
+      return;
+    }
+    if (command === 'settings') {
+      this.choice(
+        'Settings',
+        [
+          { 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: 'theme', label: 'Switch Night / Paper' },
+          { value: 'rail', label: 'Toggle workspace rail' },
+          { value: 'keys', label: 'Keyboard shortcuts' },
+        ],
+        (value) => {
+          if (value === 'theme') {
+            this.view.theme = new SalaamTheme(this.view.theme.name === 'night' ? 'paper' : 'night');
+            this.document.invalidate();
+            this.tui.requestRender(true);
+          } else if (value === 'rail') {
+            this.rail = !this.rail;
+            this.tui.requestRender(true);
+          } else void this.execute(() => this.runSlashCommand(value));
+        },
+      );
+      return;
+    }
+    if (command === 'status') {
+      this.showText(
+        'Session status',
+        JSON.stringify(
+          {
+            connection: this.client.connection,
+            session: snapshot?.id,
+            workspace: snapshot?.cwd,
+            route: snapshot?.provider_route ?? this.client.health?.provider_route,
+            capabilities: snapshot?.capabilities,
+            pending_delivery: this.client.pendingInputs,
+          },
+          null,
+          2,
+        ),
+      );
+      return;
+    }
+    if (!snapshot) throw new Error('Choose a session with /sessions or /new first.');
+    if (command === 'undo') {
+      if (args === 'reconcile') {
+        await this.client.reconcileUndo();
+        return;
+      }
+      if (args) throw new Error('Use /undo or /undo reconcile.');
+      const review = await this.client.undoReview();
+      this.showModal(
+        new TextModal(
+          'Undo local edit · review the inverse',
+          review.edits
+            .map(
+              (e) =>
+                '--- ' +
+                e.path +
+                '\n' +
+                e.after +
+                '\n+++ restored\n' +
+                (e.before ?? '(remove new file)'),
+            )
+            .join('\n\n'),
+          this.view.theme,
+          () => this.terminal.rows,
+          () => this.tui.requestRender(),
+          () => this.closeModal(),
+          undefined,
+          () => {
+            this.closeModal();
+            void this.execute(() => this.client.undo(review));
+          },
+        ),
+      );
+      return;
+    }
+    if (command === 'fork') {
+      this.confirm(
+        'Fork session',
+        'Create an independent conversation from the captured history? Both sessions share the same workspace; files are not cloned. Pending approvals and task authority are not copied.',
+        'Fork conversation',
+        () => this.client.fork(),
+      );
+      return;
+    }
+    if (command === 'compact') {
+      await this.client.compact();
+      return;
+    }
+    if (command === 'history') {
+      await this.history();
+      return;
+    }
+    if (command === 'context') {
+      this.setTab('context');
+      return;
+    }
+    if (command === 'diff') {
+      if (snapshot.capabilities.includes('local-workspace-read')) {
+        const diff = await call<{ text: string }>(
+          this.client.socket,
+          `/v1/sessions/${snapshot.id}/local-diff`,
+        );
+        this.showText('Local Git changes', diff.text);
+      } else this.setTab('changes');
+      return;
+    }
+    if (command === 'approvals') {
+      this.approvals();
+      return;
+    }
+    if (command === 'tasks') {
+      this.taskActions();
+      return;
+    }
+    if (command === 'cancel') {
+      const active = snapshot.attempts.filter((a) =>
+        ['accepted', 'dispatching', 'running'].includes(a.state),
+      );
+      if (!active.length) {
+        this.client.report('No active or queued instruction to cancel.');
+        return;
+      }
+      const cancel = (id: string) =>
+        this.confirm(
+          'Cancel instruction',
+          'Cancel attempt ' + id + '? /exit would leave it running.',
+          'Cancel work',
+          () => this.client.cancel(id),
+        );
+      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) })),
+          cancel,
+        );
+      return;
+    }
+    if (command === 'steer') {
+      if (!args) throw new Error('Use /steer followed by guidance for the active turn.');
+      await this.client.steer(args);
+      return;
+    }
+    if (command === 'queue') {
+      if (args) {
+        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,
+        ),
+      );
+      return;
+    }
+    if (command === 'plan' || command === 'review') {
+      const instruction =
+        command === 'plan'
+          ? 'Produce an implementation plan. Inspect relevant workspace files, explain assumptions, steps and validation. Do not edit files or run mutating commands. '
+          : 'Review the workspace changes. Inspect the actual code and report actionable bugs with file references and verification gaps. Do not edit files. ';
+      this.confirm(
+        command === 'plan' ? 'Request a plan' : 'Request a review',
+        'This submits a model instruction and uses provider credits. It does not change tool permissions; mutations still use existing approval controls.',
+        'Submit instruction',
+        () => this.client.submit(instruction + args).then(() => undefined),
+      );
+      return;
+    }
+    if (command === 'usage') {
+      this.showText(
+        'Provider usage',
+        JSON.stringify(
+          this.client.usage ?? { status: 'No usage observations yet; this is not zero usage.' },
+          null,
+          2,
+        ),
+      );
+      return;
+    }
+    if (command === 'permissions') {
+      await this.permissionControls();
+      return;
+    }
+    if (command === 'progression') {
+      this.choice(
+        'Progression · does not change permissions',
+        [
+          {
+            value: 'manual',
+            label: 'Manual steps',
+            description: 'Pause future task steps; current work can settle',
+          },
+          {
+            value: 'bounded',
+            label: 'Bounded automatic task',
+            description: 'Checked task, step grant and budgets; permission gates still apply',
+          },
+          {
+            value: 'scheduled',
+            label: 'Scheduled tasks',
+            description: 'Reviewed templates and fresh bounded occurrences',
+          },
+        ],
+        (value) => {
+          if (value === 'bounded') this.taskActions(true);
+          else if (value === 'scheduled') void this.execute(() => this.schedules());
+          else {
+            const task = this.client.snapshot?.work_task;
+            if (!task)
+              this.client.report(
+                'Manual instruction mode is active. No task is configured for automatic progression.',
+              );
+            else
+              this.confirm(
+                'Manual progression',
+                'Stop admitting later task steps? Already-running work may settle. Permissions remain unchanged.',
+                'Pause progression',
+                () =>
+                  this.client.taskAction(
+                    'auto',
+                    { max_steps: 0, compact: false },
+                    { id: task.id, revision: task.revision },
+                  ),
+              );
+          }
+        },
+      );
+      return;
+    }
+    if (command === 'tools') {
+      this.showText(
+        command === 'tools' ? 'Tools and activity' : 'Session authority',
+        JSON.stringify(
+          {
+            capabilities: snapshot.capabilities,
+            controller: snapshot.control,
+            pending_approvals: snapshot.approvals.filter((a) => a.state === 'pending'),
+            ...(command === 'tools' ? { activity: this.client.activity } : {}),
+          },
+          null,
+          2,
+        ),
+      );
+      return;
+    }
+    if (command === 'agents') {
+      this.showText(
+        'Agents',
+        JSON.stringify(
+          {
+            profiles: snapshot.agents ?? [],
+            children: snapshot.children,
+            team: snapshot.team ?? null,
+          },
+          null,
+          2,
+        ),
+      );
+      return;
+    }
+    if (command === 'mcp') {
+      this.showText(
+        'Managed MCP',
+        JSON.stringify(
+          {
+            capabilities: snapshot.capabilities.filter((c) => /mcp|toolkit/.test(c)),
+            operations: snapshot.operations.filter((o) => o.kind === 'mcp'),
+          },
+          null,
+          2,
+        ),
+      );
+      return;
+    }
+    if (command === 'skills') {
+      if (args === 'clear' || args.startsWith('review ')) {
+        const paths =
+          args === 'clear' ? [] : args.slice('review '.length).trim().split(/\s+/).filter(Boolean);
+        if (args !== 'clear' && !paths.length)
+          throw Error('Use /skills review AGENTS.md .salaam/skills/sjl-profile');
+        const plan = await this.client.planContext({
+          files: paths.filter((path) => path.endsWith('.md')),
+          bundles: paths.filter((path) => !path.endsWith('.md')),
+        });
+        this.confirm(
+          'Review context and skills',
+          'These exact bytes become model context. No tools or permissions are granted. Editing any reviewed resource blocks future grants until renewed.\n\n' +
+            JSON.stringify(plan, null, 2),
+          args === 'clear' ? 'Clear admission' : 'Admit reviewed context',
+          () => this.client.admitContext(plan),
+        );
+        return;
+      }
+      if (args) throw Error('Use /skills, /skills review <relative paths>, or /skills clear');
+      this.showText(
+        'Skills',
+        JSON.stringify(
+          await call(this.client.socket, `/v1/sessions/${snapshot.id}/context`),
+          null,
+          2,
+        ),
+      );
+      return;
+    }
+    if (command === 'thinking') {
+      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,
+        );
+        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_LEVELS.map((level) => ({ value: level, label: level })),
+          (level) => void this.execute(() => choose(level)),
+        );
+      return;
+    }
+    if (command === 'name') {
+      if (!args || args.length > 120 || /[\x00-\x1f\x7f]/.test(args))
+        throw new Error('Use /name followed by 1–120 printable characters.');
+      await this.client.name(args);
+      this.client.report('Session named ' + args);
+      return;
+    }
+    if (command === 'export') {
+      const path = resolve(args || `salaam-${snapshot.id}.md`);
+      const text = await conversationExport(this.client.socket, snapshot.id);
+      writeConversationExport(path, text);
+      this.client.report('Exported full captured history to ' + path);
+      return;
+    }
+    if (command === 'copy') {
+      const last = [...snapshot.messages].reverse().find((m) => m.role === 'assistant');
+      if (!last) throw new Error('No assistant response to copy.');
+      if (last.truncated)
+        throw new Error(
+          'Response preview is truncated. Use /export for complete captured history.',
+        );
+      if (process.platform !== 'darwin')
+        throw new Error(
+          'Clipboard copying is currently supported on macOS; use /export on this platform.',
+        );
+      await new Promise<void>((resolve, reject) => {
+        const child = spawn('/usr/bin/pbcopy', [], { stdio: ['pipe', 'ignore', 'pipe'] });
+        child.on('error', reject);
+        child.stdin.on('error', reject);
+        child.on('close', (code) =>
+          code === 0 ? resolve() : reject(new Error('Clipboard copy failed.')),
+        );
+        child.stdin.end(last.text);
+      });
+      this.client.report('Copied the last assistant response.');
+      return;
+    }
+    throw new Error('Command has no handler: ' + command);
+  }
+  private async newSession(localCoding = false): Promise<void> {
     await this.startService();
     this.showModal(
       new FormModal(
-        'New Salaam session',
-        this.options.cwd ?? process.cwd(),
+        (localCoding
+          ? 'New coding session · reviewed edits and unsandboxed 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,
-        !!this.client.health?.coding_root,
+        !localCoding && !!this.client.health?.coding_root,
         () => this.tui.requestRender(),
         () => this.closeModal(),
         (cwd, coding) => {
           this.closeModal();
           void this.execute(async () => {
-            await this.client.create(resolve(cwd), coding);
+            await this.client.create(resolve(cwd), coding, this.selectedRoute, localCoding);
             this.setTab('conversation');
           });
         },
@@ -460,12 +1001,16 @@ export class SalaamApp {
         { value: 'new', label: '+ New session', description: 'Start a fresh workspace' },
         ...this.client.sessions.map((session) => ({
           value: session.id,
-          label: basename(session.cwd) + '  ' + shortId(session.id),
+          label:
+            (this.client.names[session.id] ?? basename(session.cwd)) + '  ' + shortId(session.id),
           description: session.state + ' · ' + session.cwd,
         })),
       ],
       (value) => {
-        if (value === 'new') void this.execute(() => this.newSession());
+        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));
+        else if (value === 'new') void this.execute(() => this.newSession());
         else
           void this.execute(async () => {
             await this.client.open(value, {
@@ -482,6 +1027,13 @@ export class SalaamApp {
       session = this.client.snapshot?.id,
       continuation = this.view.continuation;
     if (!text.trim()) return;
+    const command = parseSlashCommand(text);
+    if (command) {
+      await this.runSlashCommand(command.name, command.args);
+      if (this.editor.getExpandedText() === text) this.editor.setText('');
+      if (session) this.drafts.delete(session);
+      return;
+    }
     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.');
@@ -604,7 +1156,90 @@ export class SalaamApp {
       ),
     );
   }
-  private taskActions(): void {
+  private async permissionControls(): Promise<void> {
+    const session = this.client.snapshot!.id;
+    const current = await this.client.permissions();
+    if (!current.configurable) {
+      this.showText(
+        'Managed permissions',
+        'This session uses host-managed authority. Local permission presets cannot change station or specialist grants.',
+      );
+      return;
+    }
+    this.choice(
+      'Permissions · ' + current.policy.mode + ' · revision ' + current.policy.revision,
+      [
+        {
+          value: 'inspect-current',
+          label: 'Inspect current policy',
+          description: current.policy.paths.join(', ') || 'No automatic edit scopes',
+        },
+        {
+          value: 'inspect',
+          label: 'Inspect only',
+          description: 'Deny future local mutations, including manually approved operations',
+        },
+        ...(current.coding
+          ? [
+              {
+                value: 'review',
+                label: 'Review every mutation',
+                description: 'Explicit approval for each edit and unsandboxed shell command',
+              },
+              {
+                value: 'scoped-edit',
+                label: 'Auto-approve scoped edits',
+                description: 'Exact files or directory prefixes; shell commands still ask',
+              },
+            ]
+          : []),
+      ],
+      (mode) => {
+        if (mode === 'inspect-current') {
+          this.showText('Permissions and execution boundary', JSON.stringify(current, null, 2));
+          return;
+        }
+        const apply = (paths: string[]) =>
+          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.`,
+              this.view.theme,
+              () => this.terminal.rows,
+              () => this.tui.requestRender(),
+              () => this.closeModal(),
+              undefined,
+              () => {
+                this.closeModal();
+                void this.execute(() =>
+                  this.client.setPermissions(session, current.policy.revision, {
+                    mode: mode as import('./autonomy.js').PermissionMode,
+                    paths,
+                  }),
+                );
+              },
+              'save permissions',
+            ),
+          );
+        if (mode === 'scoped-edit')
+          this.taskInput(
+            'Auto-edit scopes',
+            current.policy.paths.join(', '),
+            'Comma-separated files or directories ending in /',
+            'Example: src/, test/, README.md. No glob patterns or private paths. Other files still require review.',
+            (text) =>
+              apply(
+                text
+                  .split(',')
+                  .map((p) => p.trim())
+                  .filter(Boolean),
+              ),
+          );
+        else apply([]);
+      },
+    );
+  }
+  private taskActions(progressionOnly = false): void {
     const task = this.client.snapshot?.work_task;
     if (!task) {
       const initial = JSON.stringify({
@@ -701,202 +1336,210 @@ export class SalaamApp {
         description: 'Stop work; uncertain external effects remain recorded',
       },
     ];
-    this.choice('Salaam · task', items, (action) => {
-      if (action === 'inspect')
-        this.showModal(
-          new TextModal(
-            'Task · ' + task.id,
-            JSON.stringify(task, null, 2),
-            this.view.theme,
-            () => this.view.rows() - 8,
-            () => this.tui.requestRender(),
-            () => this.closeModal(),
-          ),
-        );
-      else if (action === 'plan')
-        this.taskInput(
-          'Revise task · plan JSON',
-          JSON.stringify({
-            objective: task.objective,
-            constraints: task.constraints,
-            steps: task.steps.map(({ key, title, instruction, depends_on, checks }) => ({
-              key,
-              title,
-              instruction,
-              depends_on,
-              checks,
-            })),
-            acceptance: task.acceptance,
-            deliverables: task.deliverables,
-            limits: task.limits,
-          }),
-          'Review the complete revised plan',
-          'Revising pauses progression and requires fresh verification.',
-          (value) =>
-            void this.execute(() =>
-              this.client.taskAction('revise', { plan: JSON.parse(value) }, reviewed),
-            ),
-        );
-      else if (action === 'run') {
-        const eligible = task.steps.filter((s) =>
-          ['pending', 'failed', 'cancelled', 'interrupted'].includes(s.state),
-        );
-        if (!eligible.length) {
-          this.client.report('No step is eligible for an explicit run.');
-          return;
-        }
-        this.choice(
-          'Choose a saved step',
-          eligible.map((s) => ({
-            value: s.id,
-            label: s.title,
-            description: s.key + ' · ' + s.state,
-          })),
-          (id) => {
-            const step = eligible.find((s) => s.id === id)!;
-            this.taskInput(
-              'Step instruction',
-              step.state === 'interrupted' ? '' : step.instruction,
-              'Review or enter the instruction',
-              step.state === 'interrupted'
-                ? 'Inspect the interrupted outcome first; this creates a new attempt.'
-                : 'Dependencies and task limits are checked by the service.',
-              (instruction) =>
-                void this.execute(() =>
-                  this.client.taskAction(
-                    `steps/${id}/run`,
-                    {
-                      instruction,
-                      ...(step.state === 'interrupted'
-                        ? { continues_attempt_id: step.attempt_id }
-                        : {}),
-                    },
-                    reviewed,
-                  ),
-                ),
-            );
-          },
-        );
-      } else if (action === 'review') {
-        const steps = task.steps.filter((s) => s.state === 'awaiting_review');
-        if (!steps.length) {
-          this.client.report('No step awaits operator review.');
-          return;
-        }
-        this.choice(
-          'Review a settled step',
-          steps.map((s) => ({ value: s.id, label: s.title, description: s.attempt_id ?? '' })),
-          (id) =>
-            this.taskInput(
-              'Record operator review',
-              '',
-              'What did you inspect?',
-              'This records your decision; fresh command receipts are still required for task success.',
-              (review) =>
-                void this.execute(() =>
-                  this.client.taskAction(`steps/${id}/complete`, { review }, reviewed),
-                ),
+    this.choice(
+      progressionOnly ? 'Bounded progression · permissions unchanged' : 'Salaam · task',
+      progressionOnly
+        ? items.filter((i) => ['inspect', 'plan', 'auto', 'pause'].includes(i.value))
+        : items,
+      (action) => {
+        if (action === 'inspect')
+          this.showModal(
+            new TextModal(
+              'Task · ' + task.id,
+              JSON.stringify(task, null, 2),
+              this.view.theme,
+              () => this.view.rows() - 8,
+              () => this.tui.requestRender(),
+              () => this.closeModal(),
             ),
-        );
-      } else if (action === 'verify') {
-        if (!task.acceptance.length) {
-          this.client.report('Configure acceptance checks in the task plan first.');
-          return;
-        }
-        this.choice(
-          'Choose acceptance check',
-          task.acceptance.map((c) => ({ value: c.key, label: c.key, description: c.command })),
-          (key) =>
-            void this.execute(() => this.client.taskAction('verify', { check_key: key }, reviewed)),
-        );
-      } else if (action === 'finish')
-        this.confirm(
-          'Verify task completion',
-          'The service will recheck every configured command receipt and deliverable against the current workspace.',
-          'Verify completion',
-          () => this.client.taskAction('finish', {}, reviewed),
-        );
-      else if (action === 'auto')
-        this.taskInput(
-          'Bounded progression',
-          String(task.steps.filter((s) => s.state === 'pending').length),
-          'Maximum new steps (1–32)',
-          'Steps advance only after their configured checks pass. Human approvals remain separate.',
-          (value) => {
-            const max_steps = Number(value);
-            this.confirm(
-              'Run this bounded plan',
-              `Task ${shortId(task.id)} · plan revision ${task.plan_revision}\nAt most ${max_steps} new steps; each step needs fresh passing checks.\nLimits: ${task.limits.requests} requests · ${task.limits.runtime_ms} ms · ${task.limits.concurrency} concurrent executions.\n${task.limits.token_units} declared token units · ${task.limits.verification_runs} verification runs.\nChecks: ${task.acceptance.map((c) => c.key).join(', ') || 'none'} · Deliverables: ${task.deliverables.length}.\nDeterministic compaction at idle boundaries. Human approvals remain separate.`,
-              'Run bounded task',
-              () => this.client.taskAction('auto', { max_steps, compact: true }, reviewed),
-            );
-          },
-        );
-      else if (action === 'pause')
-        void this.execute(() =>
-          this.client.taskAction('auto', { max_steps: 0, compact: false }, reviewed),
-        );
-      else if (action === 'checkpoint')
-        void this.execute(() => this.client.taskAction('checkpoint', {}, reviewed));
-      else if (action === 'restore')
-        void this.execute(async () => {
-          const checkpoints = await call<{ id: string; revision: number; digest: string }[]>(
-            this.client.socket,
-            `/v1/tasks/${task.id}/checkpoints`,
           );
-          if (!checkpoints.length) {
-            this.client.report('No checkpoints have been saved.');
+        else if (action === 'plan')
+          this.taskInput(
+            'Revise task · plan JSON',
+            JSON.stringify({
+              objective: task.objective,
+              constraints: task.constraints,
+              steps: task.steps.map(({ key, title, instruction, depends_on, checks }) => ({
+                key,
+                title,
+                instruction,
+                depends_on,
+                checks,
+              })),
+              acceptance: task.acceptance,
+              deliverables: task.deliverables,
+              limits: task.limits,
+            }),
+            'Review the complete revised plan',
+            'Revising pauses progression and requires fresh verification.',
+            (value) =>
+              void this.execute(() =>
+                this.client.taskAction('revise', { plan: JSON.parse(value) }, reviewed),
+              ),
+          );
+        else if (action === 'run') {
+          const eligible = task.steps.filter((s) =>
+            ['pending', 'failed', 'cancelled', 'interrupted'].includes(s.state),
+          );
+          if (!eligible.length) {
+            this.client.report('No step is eligible for an explicit run.');
             return;
           }
           this.choice(
-            'Choose checkpoint',
-            checkpoints.map((c) => ({
-              value: c.id,
-              label: 'Workspace revision ' + c.revision,
-              description: c.digest,
+            'Choose a saved step',
+            eligible.map((s) => ({
+              value: s.id,
+              label: s.title,
+              description: s.key + ' · ' + s.state,
             })),
-            (checkpoint_id) => {
-              const w = this.client.workspace;
-              if (!w?.observed_digest) {
-                this.client.report('Refresh the owned workspace before restoring.');
-                return;
-              }
+            (id) => {
+              const step = eligible.find((s) => s.id === id)!;
+              this.taskInput(
+                'Step instruction',
+                step.state === 'interrupted' ? '' : step.instruction,
+                'Review or enter the instruction',
+                step.state === 'interrupted'
+                  ? 'Inspect the interrupted outcome first; this creates a new attempt.'
+                  : 'Dependencies and task limits are checked by the service.',
+                (instruction) =>
+                  void this.execute(() =>
+                    this.client.taskAction(
+                      `steps/${id}/run`,
+                      {
+                        instruction,
+                        ...(step.state === 'interrupted'
+                          ? { continues_attempt_id: step.attempt_id }
+                          : {}),
+                      },
+                      reviewed,
+                    ),
+                  ),
+              );
+            },
+          );
+        } else if (action === 'review') {
+          const steps = task.steps.filter((s) => s.state === 'awaiting_review');
+          if (!steps.length) {
+            this.client.report('No step awaits operator review.');
+            return;
+          }
+          this.choice(
+            'Review a settled step',
+            steps.map((s) => ({ value: s.id, label: s.title, description: s.attempt_id ?? '' })),
+            (id) =>
+              this.taskInput(
+                'Record operator review',
+                '',
+                'What did you inspect?',
+                'This records your decision; fresh command receipts are still required for task success.',
+                (review) =>
+                  void this.execute(() =>
+                    this.client.taskAction(`steps/${id}/complete`, { review }, reviewed),
+                  ),
+              ),
+          );
+        } else if (action === 'verify') {
+          if (!task.acceptance.length) {
+            this.client.report('Configure acceptance checks in the task plan first.');
+            return;
+          }
+          this.choice(
+            'Choose acceptance check',
+            task.acceptance.map((c) => ({ value: c.key, label: c.key, description: c.command })),
+            (key) =>
+              void this.execute(() =>
+                this.client.taskAction('verify', { check_key: key }, reviewed),
+              ),
+          );
+        } else if (action === 'finish')
+          this.confirm(
+            'Verify task completion',
+            'The service will recheck every configured command receipt and deliverable against the current workspace.',
+            'Verify completion',
+            () => this.client.taskAction('finish', {}, reviewed),
+          );
+        else if (action === 'auto')
+          this.taskInput(
+            'Bounded progression',
+            String(task.steps.filter((s) => s.state === 'pending').length),
+            'Maximum new steps (1–32)',
+            'Steps advance only after their configured checks pass. Human approvals remain separate.',
+            (value) => {
+              const max_steps = Number(value);
               this.confirm(
-                'Restore reviewed task changes',
-                JSON.stringify(
-                  {
-                    checkpoint_id,
-                    current_revision: w.revision,
-                    current_digest: w.observed_digest,
-                    human_edits: 'Preserved; conflicts are reported',
-                    external_effects: 'Not rolled back',
-                  },
-                  null,
-                  2,
-                ),
-                'Restore checkpoint',
-                () =>
-                  this.client.taskAction(
-                    'restore',
+                'Run this bounded plan',
+                `Task ${shortId(task.id)} · plan revision ${task.plan_revision}\nAt most ${max_steps} new steps; each step needs fresh passing checks.\nLimits: ${task.limits.requests} requests · ${task.limits.runtime_ms} ms · ${task.limits.concurrency} concurrent executions.\n${task.limits.token_units === null ? 'Token budget disabled' : task.limits.token_units + ' declared token units'} · ${task.limits.verification_runs} verification runs.\nChecks: ${task.acceptance.map((c) => c.key).join(', ') || 'none'} · Deliverables: ${task.deliverables.length}.\nDeterministic compaction at idle boundaries. Human approvals remain separate.`,
+                'Run bounded task',
+                () => this.client.taskAction('auto', { max_steps, compact: true }, reviewed),
+              );
+            },
+          );
+        else if (action === 'pause')
+          void this.execute(() =>
+            this.client.taskAction('auto', { max_steps: 0, compact: false }, reviewed),
+          );
+        else if (action === 'checkpoint')
+          void this.execute(() => this.client.taskAction('checkpoint', {}, reviewed));
+        else if (action === 'restore')
+          void this.execute(async () => {
+            const checkpoints = await call<{ id: string; revision: number; digest: string }[]>(
+              this.client.socket,
+              `/v1/tasks/${task.id}/checkpoints`,
+            );
+            if (!checkpoints.length) {
+              this.client.report('No checkpoints have been saved.');
+              return;
+            }
+            this.choice(
+              'Choose checkpoint',
+              checkpoints.map((c) => ({
+                value: c.id,
+                label: 'Workspace revision ' + c.revision,
+                description: c.digest,
+              })),
+              (checkpoint_id) => {
+                const w = this.client.workspace;
+                if (!w?.observed_digest) {
+                  this.client.report('Refresh the owned workspace before restoring.');
+                  return;
+                }
+                this.confirm(
+                  'Restore reviewed task changes',
+                  JSON.stringify(
                     {
                       checkpoint_id,
-                      workspace_revision: w.revision,
-                      workspace_digest: w.observed_digest,
+                      current_revision: w.revision,
+                      current_digest: w.observed_digest,
+                      human_edits: 'Preserved; conflicts are reported',
+                      external_effects: 'Not rolled back',
                     },
-                    reviewed,
+                    null,
+                    2,
                   ),
-              );
-            },
+                  'Restore checkpoint',
+                  () =>
+                    this.client.taskAction(
+                      'restore',
+                      {
+                        checkpoint_id,
+                        workspace_revision: w.revision,
+                        workspace_digest: w.observed_digest,
+                      },
+                      reviewed,
+                    ),
+                );
+              },
+            );
+          });
+        else if (action === 'cancel')
+          this.confirm(
+            'Cancel this task',
+            'Current work is cancelled and later steps stop. Inspect any uncertain effects separately.',
+            'Cancel task',
+            () => this.client.taskAction('cancel', {}, reviewed),
           );
-        });
-      else if (action === 'cancel')
-        this.confirm(
-          'Cancel this task',
-          'Current work is cancelled and later steps stop. Inspect any uncertain effects separately.',
-          'Cancel task',
-          () => this.client.taskAction('cancel', {}, reviewed),
-        );
-    });
+      },
+    );
   }
   private jobActions(): void {
     const snapshot = this.client.snapshot,
@@ -1174,6 +1817,11 @@ export class SalaamApp {
   private palette(): void {
     const snapshot = this.client.snapshot;
     const items = [
+      ...SLASH_COMMANDS.filter((c) => c.kind !== 'unavailable').map((c) => ({
+        value: 'slash:' + c.name,
+        label: '/' + c.name,
+        description: c.description,
+      })),
       {
         value: 'schedules',
         label: 'Recurring jobs and schedules',
@@ -1184,7 +1832,14 @@ export class SalaamApp {
         label: 'Operator inbox',
         description: 'Shared durable attention and results',
       },
+      { value: 'model', label: 'Choose model and provider', description: '/model · new session' },
+      { value: 'help', label: 'Slash commands', description: '/help' },
       { value: 'new', label: 'New session', description: 'ctrl+n' },
+      {
+        value: 'coding',
+        label: 'New local coding session',
+        description: '/coding · reviewed edits and local commands',
+      },
       { value: 'sessions', label: 'Switch session', description: 'ctrl+p' },
       { value: 'conversation', label: 'Conversation', description: 'Messages and live progress' },
       {
@@ -1271,11 +1926,23 @@ export class SalaamApp {
       { value: 'stop', label: 'Stop service', description: 'Separate from detach and cancel' },
     ];
     this.choice('Salaam · actions', items, (value) => {
+      if (value.startsWith('slash:')) {
+        const name = value.slice(6);
+        const definition = SLASH_COMMANDS.find((c) => c.name === name)!;
+        if (definition.arguments?.startsWith('<')) {
+          this.editor.setText('/' + name + ' ');
+          this.tui.setFocus(this.editor);
+        } else void this.execute(() => this.runSlashCommand(name));
+        return;
+      }
       if (['conversation', 'changes', 'commands', 'context'].includes(value)) {
         this.setTab(value as ViewTab);
         return;
       }
-      if (value === 'new') void this.execute(() => this.newSession());
+      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));
+      else if (value === 'new') void this.execute(() => this.newSession());
       else if (value === 'task') this.taskActions();
       else if (value === 'jobs') this.jobActions();
       else if (value === 'schedules') void this.execute(() => this.schedules());
@@ -1577,6 +2244,21 @@ export class SalaamApp {
       }
     }
   }
+  private async initialize(): Promise<void> {
+    await this.execute(async () => {
+      await this.client.list();
+      if (this.options.session)
+        await this.client.open(this.options.session, {
+          observe: this.options.observe,
+          takeover: this.options.takeover,
+        });
+      else if (this.client.sessions.length) await this.sessions();
+      else if (this.client.connection === 'offline') {
+        this.client.notice = 'Service is offline. Ctrl+n starts a new workspace.';
+        this.tui.requestRender();
+      }
+    });
+  }
   async run(): Promise<void> {
     this.running = true;
     const close = () => {
@@ -1600,19 +2282,7 @@ export class SalaamApp {
         )
           this.tui.requestRender();
       }, 1000);
-      await this.client.list();
-      if (this.options.session)
-        await this.execute(() =>
-          this.client.open(this.options.session!, {
-            observe: this.options.observe,
-            takeover: this.options.takeover,
-          }),
-        );
-      else if (this.client.sessions.length) await this.sessions();
-      else if (this.client.connection === 'offline') {
-        this.client.notice = 'Service is offline. Ctrl+n starts a new workspace.';
-        this.tui.requestRender();
-      }
+      await this.initialize();
       await this.done;
     } finally {
       this.running = false;
@@ -1627,8 +2297,11 @@ export class SalaamApp {
       process.stdin.pause();
       process.stdin.unref();
       process.stdout.write('\x1b[23;0t');
+      const detachedSession = this.client.snapshot?.id;
       await this.client.close();
       process.stdout.write('Detached from Salaam. Work continues in the service.\n');
+      if (detachedSession)
+        process.stdout.write('Reattach with sal attach ' + detachedSession + '\n');
     }
   }
 }