@superjackfruitlabs/salaam 0.0.4 → 0.0.5

package/dist/src/tui-keymap.js

@@ -0,0 +1,116 @@
+export const GLOBAL_KEYS = [
+    { key: 'ctrl+k', action: 'palette', label: 'all actions' },
+    { key: 'f2', action: 'palette', label: 'all actions' },
+    { key: 'ctrl+p', action: 'sessions', label: 'sessions' },
+    { key: 'ctrl+n', action: 'new', label: 'new session' },
+    { key: 'ctrl+o', action: 'approvals', label: 'approvals' },
+    { key: 'alt+g', action: 'changes', label: 'changes' },
+    { key: 'ctrl+t', action: 'commands', label: 'commands' },
+    { key: 'ctrl+b', action: 'rail', label: 'show or hide the side panel' },
+    { key: 'ctrl+x', action: 'transcript', label: 'full transcript on or off' },
+    { key: 'f5', action: 'refresh', label: 'refresh' },
+    { key: 'ctrl+g', action: 'editor', label: 'external prompt editor' },
+    { key: 'shift+tab', action: 'mode', label: 'next mode' },
+    { key: 'f1', action: 'help', label: 'these keys' },
+];
+/** The per-file review on the Changes tab of a desk session. */
+export const REVIEW_KEYS = {
+    nextFile: { key: 'alt+right', label: 'next file' },
+    previousFile: { key: 'alt+left', label: 'previous file' },
+    nextHunk: { key: 'alt+down', label: 'next hunk' },
+    previousHunk: { key: 'alt+up', label: 'previous hunk' },
+    accept: { key: 'a', label: 'accept the file or hunk' },
+    revert: { key: 'r', label: 'revert it (asks first)' },
+    instruct: { key: 'i', label: 'tell the model about it' },
+};
+/** Keys while a desk turn runs (tui-turn-keys.ts decides them). */
+export const TURN_KEYS = [
+    { key: 'escape', label: 'stop the turn' },
+    { key: 'enter', label: 'steer it' },
+    { key: 'tab', label: 'queue for after' },
+];
+const COMPOSER = [
+    { label: 'Enter · send', description: 'The durable outbox saves it before delivery' },
+    { label: 'Alt+Enter / Ctrl+J · new line' },
+    { label: 'Tab · switch view', description: 'Conversation · Changes · Commands · Context' },
+    { label: 'PageUp / PageDown · scroll', description: 'Ctrl+Home/End jump to the top/bottom' },
+    { label: '@ · attach a file or image' },
+    { label: '/ · slash commands' },
+    {
+        label: 'Ctrl+R · search sent messages',
+        description: 'Ctrl+R for older, Enter keeps, Esc restores',
+    },
+    {
+        label: 'Ctrl+A/E · Ctrl+U/K/W · Ctrl+Y · Ctrl+-',
+        description: 'Line start/end, kill to start/end/word, yank, undo; Alt+B/F words',
+    },
+    {
+        label: '!command · run a shell command',
+        description: 'Same approval, sandbox and danger check',
+    },
+    {
+        label: 'Ctrl+C · stop, clear, then leave',
+        description: 'Stops a running turn, else clears text; twice on empty leaves. Work continues.',
+    },
+];
+const CODING_COMMANDS = [
+    { label: '/rewind · go back to an earlier turn' },
+    { label: '/jobs · background commands' },
+    { label: '/undo · revert the last edit' },
+];
+export function keyLabel(key) {
+    const names = { escape: 'Esc', enter: 'Enter', tab: 'Tab' };
+    if (names[key])
+        return names[key];
+    if (key.length === 1)
+        return key;
+    return key
+        .split('+')
+        .map((part) => part === 'right'
+        ? '→'
+        : part === 'left'
+            ? '←'
+            : part === 'up'
+                ? '↑'
+                : part === 'down'
+                    ? '↓'
+                    : part.length <= 2
+                        ? part.toUpperCase()
+                        : part[0].toUpperCase() + part.slice(1))
+        .join('+');
+}
+export function keySheet(c) {
+    const global = GLOBAL_KEYS.map((k) => ({ label: keyLabel(k.key) + ' · ' + k.label }));
+    const approvals = { label: 'Approvals show their own keys along the bottom' };
+    if (c.tab === 'changes' && c.coding)
+        return {
+            title: 'Keys · Review changes',
+            rows: [
+                ...Object.values(REVIEW_KEYS).map((k) => ({ label: keyLabel(k.key) + ' · ' + k.label })),
+                { label: 'a, r and i work while the composer is empty' },
+                ...global,
+            ],
+        };
+    if (c.coding && c.running)
+        return {
+            title: 'Keys · Turn running',
+            rows: [
+                ...TURN_KEYS.map((k) => ({ label: keyLabel(k.key) + ' · ' + k.label })),
+                ...global,
+                approvals,
+            ],
+        };
+    return {
+        title: 'Keys · Conversation',
+        rows: [
+            ...COMPOSER,
+            ...(c.coding ? CODING_COMMANDS : []),
+            ...(c.custom ?? []).map((k) => ({
+                label: `/${k.name}${k.argumentHint ? ' ' + k.argumentHint : ''} · your command`,
+                description: k.description,
+            })),
+            ...global,
+            approvals,
+        ],
+    };
+}

package/dist/src/tui-mentions.js

@@ -0,0 +1,38 @@
+import { CombinedAutocompleteProvider } from '@earendil-works/pi-tui';
+import { basename } from 'node:path';
+import { listWorkspaceFiles, rankFiles } from './mentions.js';
+/**
+ * `@` completes workspace files from git's own listing (ignored files stay out) instead of
+ * pi-tui's `fd` walk, which is absent on most desks. The listing is cached for 5 s.
+ */
+export class MentionAutocompleteProvider extends CombinedAutocompleteProvider {
+    root;
+    cache;
+    constructor(commands, root) {
+        super(commands, root, null);
+        this.root = root;
+    }
+    files() {
+        if (!this.cache || Date.now() - this.cache.at > 5000)
+            this.cache = { at: Date.now(), files: listWorkspaceFiles(this.root) };
+        return this.cache.files;
+    }
+    async getSuggestions(lines, cursorLine, cursorCol, options) {
+        const before = (lines[cursorLine] ?? '').slice(0, cursorCol);
+        const match = /(?:^|[\s([{])(@"[^"]*|@[^\s"]*)$/.exec(before);
+        if (!match)
+            return super.getSuggestions(lines, cursorLine, cursorCol, options);
+        if (options.signal.aborted)
+            return null;
+        const prefix = match[1];
+        const quoted = prefix.startsWith('@"');
+        const items = rankFiles(this.files(), prefix.slice(quoted ? 2 : 1))
+            .slice(0, 20)
+            .map((file) => ({
+            value: quoted || /\s/.test(file) ? `@"${file}"` : `@${file}`,
+            label: basename(file),
+            description: file,
+        }));
+        return items.length ? { items, prefix } : null;
+    }
+}

package/dist/src/tui-modals.js

@@ -132,11 +132,12 @@ export class FormModal {
             this.theme.ink(this.labels?.field ?? 'Project directory', 'muted'),
             ...this.input.render(Math.max(1, width - 4)).map((line) => this.theme.ink(line)),
             '',
-            this.theme.ink(this.allowCoding
+            // A long hint (the YOLO warning) wraps instead of running past the frame.
+            ...wrapTextWithAnsi(this.theme.ink(this.allowCoding
                 ? this.coding
                     ? '[✓] Coding workspace · guarded tools'
                     : '[ ] Conversation session'
-                : (this.labels?.hint ?? 'Conversation session · coding service is off'), this.coding ? 'jade' : 'muted'),
+                : (this.labels?.hint ?? 'Conversation session · coding service is off'), this.coding ? 'jade' : 'muted'), Math.max(1, width - 4)),
             '',
             this.theme.key('enter', this.labels?.submit ?? 'create') +
                 '   ' +
@@ -168,7 +169,9 @@ export class ConfirmModal {
     confirm;
     focused = false;
     selected = false;
-    constructor(title, description, confirmLabel, theme, renderAgain, close, confirm) {
+    constructor(title, description, confirmLabel, theme, renderAgain, close, confirm, 
+    /** Start on the action rather than on "Keep current state" (cancel a running turn). */
+    confirmByDefault = false) {
         this.title = title;
         this.description = description;
         this.confirmLabel = confirmLabel;
@@ -176,6 +179,7 @@ export class ConfirmModal {
         this.renderAgain = renderAgain;
         this.close = close;
         this.confirm = confirm;
+        this.selected = confirmByDefault;
     }
     invalidate() { }
     render(width) {
@@ -207,6 +211,36 @@ export class ConfirmModal {
         this.renderAgain();
     }
 }
+/**
+ * Why a request asks, in one plain line (trial polish #2): the danger check's verdict when it has
+ * one, otherwise what the session mode leaves to a person.
+ */
+export function approvalReason(value, mode) {
+    const danger = /^Dangerous \(([^)]+)\): (.*)$/m.exec(value);
+    if (danger)
+        return `Asks because this command is dangerous (${danger[1]}): ${danger[2]}`;
+    const outside = /^Outside the sandbox: (.*?)\. This one command/m.exec(value);
+    if (outside)
+        return `Asks because it wants to run outside the sandbox: ${outside[1]}`;
+    const edit = /^(---|\+\+\+) /m.test(value) && !/\nCommand:\n/.test(value);
+    if (mode === 'review')
+        return 'Asks because review mode asks before every edit and command.';
+    if (mode === 'accept-edits' && !edit)
+        return 'Asks because accept edits still asks before commands.';
+    if (mode === 'auto')
+        return edit
+            ? 'Asks because this edit is outside what auto mode approves on its own.'
+            : 'Asks because auto mode approves only sandboxed commands it can read.';
+    return 'Asks because nothing approves this request on its own.';
+}
+/**
+ * The approval prompt (phase 2a): what will run, in plain words, with the exact binding (approval
+ * id, digest, revision, expiry) one key away rather than in the way. Desk sessions can also approve
+ * for the rest of the session or always for this repo; strict work only ever approves once. A
+ * request longer than the screen must be read to the end before anything but Deny is possible, and
+ * a request that changed or expired cannot be approved at all.
+ */
+export { onceOnlyReason } from './approval-rules.js';
 export class ApprovalModal {
     approval;
     operation;
@@ -216,14 +250,25 @@ export class ApprovalModal {
     renderAgain;
     close;
     decide;
+    offerRules;
+    onceOnly;
+    options;
     focused = false;
     offset = 0;
     reviewed = false;
-    approve = false;
+    showDetails = false;
+    choice = 0;
     total = 0;
     pageSize = 1;
     stale = false;
-    constructor(approval, operation, theme, rows, current, renderAgain, close, decide) {
+    constructor(approval, operation, theme, rows, current, renderAgain, close, decide, offerRules = false, 
+    /** Why only Approve once and Deny are offered, shown above the choices. */
+    onceOnly, 
+    /**
+     * Desk sessions (trial polish #1) see the change and decide; there is no read-to-the-end gate
+     * there, since the person chose the session and its mode. Strict work keeps the gate.
+     */
+    options = {}) {
         this.approval = approval;
         this.operation = operation;
         this.theme = theme;
@@ -232,21 +277,70 @@ export class ApprovalModal {
         this.renderAgain = renderAgain;
         this.close = close;
         this.decide = decide;
+        this.offerRules = offerRules;
+        this.onceOnly = onceOnly;
+        this.options = options;
+        this.choice = 1;
+    }
+    choices() {
+        return [
+            { decision: 'deny', key: 'n', label: 'Deny', colour: 'amber' },
+            { decision: 'approve', key: 'y', label: 'Approve once', colour: 'jade' },
+            ...(this.options.desk
+                ? [
+                    {
+                        decision: 'deny-feedback',
+                        key: 'f',
+                        label: 'Deny and tell it why',
+                        colour: 'amber',
+                    },
+                ]
+                : []),
+            ...(this.offerRules
+                ? [
+                    {
+                        decision: 'approve-session',
+                        key: 's',
+                        label: 'Approve for this session',
+                        colour: 'jade',
+                    },
+                    {
+                        decision: 'always',
+                        key: 'a',
+                        label: 'Always allow in this repo',
+                        colour: 'jade',
+                    },
+                ]
+                : []),
+        ];
     }
     invalidate() { }
     render(width) {
         const a = this.approval, op = this.operation, t = this.theme, inner = Math.max(1, width - 4);
-        const details = [
-            `Operation: ${op.kind}`,
-            `Target: ${safeText(op.target)}`,
-            'Value:',
-            safeText(op.value),
-            `Expected target version: ${safeText(op.target_version)}`,
-            `Approval: ${a.id}`,
-            `Digest: ${a.operation_digest}`,
-            `Revision: ${a.revision} · worker epoch: ${a.worker_epoch}`,
-            `Expires: ${new Date(a.expires_at).toISOString()}`,
-        ].flatMap((line) => wrapTextWithAnsi(t.ink(line), inner));
+        // A diff reads as a diff: added lines jade, removed lines red, hunk headers muted.
+        const diffInk = (line) => /^(\+\+\+|---) /.test(line) || line.startsWith('@@')
+            ? t.ink(line, 'muted')
+            : line.startsWith('+')
+                ? t.ink(line, 'jade')
+                : line.startsWith('-')
+                    ? t.ink(line, 'red')
+                    : t.ink(line);
+        const body = [
+            ...[safeText(op.target), ''].flatMap((line) => wrapTextWithAnsi(t.ink(line), inner)),
+            ...safeText(op.value)
+                .split('\n')
+                .flatMap((line) => wrapTextWithAnsi(diffInk(line), inner)),
+            ...[
+                ...(this.showDetails
+                    ? [
+                        '',
+                        `Approval ${a.id} · revision ${a.revision} · worker epoch ${a.worker_epoch}`,
+                        `Digest ${a.operation_digest}`,
+                        `Target version ${safeText(op.target_version)} · expires ${new Date(a.expires_at).toISOString()}`,
+                    ]
+                    : []),
+            ].flatMap((line) => wrapTextWithAnsi(t.ink(line), inner)),
+        ];
         const current = this.current();
         this.stale =
             !current ||
@@ -254,33 +348,54 @@ export class ApprovalModal {
                 current.operation_digest !== a.operation_digest ||
                 current.revision !== a.revision ||
                 Date.now() >= a.expires_at;
-        this.total = details.length;
+        this.total = body.length;
         this.pageSize = Math.max(1, Math.min(18, this.rows() - 11));
         this.offset = Math.max(0, Math.min(this.offset, Math.max(0, this.total - this.pageSize)));
-        if (this.rows() >= 12 && this.offset + this.pageSize >= this.total)
+        if (this.options.desk || (this.rows() >= 12 && this.offset + this.pageSize >= this.total))
             this.reviewed = true;
+        const below = this.total - (this.offset + this.pageSize);
         const disabled = !this.reviewed || this.stale;
-        return framed(t, 'Review approval', [
-            ...details.slice(this.offset, this.offset + this.pageSize),
+        const choices = this.choices();
+        this.choice = Math.max(0, Math.min(this.choice, choices.length - 1));
+        return framed(t, 'Approve?', [
+            ...body.slice(this.offset, this.offset + this.pageSize),
             '',
-            t.ink(this.stale
-                ? 'This request changed or expired. Close and refresh.'
+            ...(this.stale
+                ? [t.ink('This request changed or expired. Close and refresh.', 'red')]
                 : this.reviewed
-                    ? 'Exact request binding reviewed.'
-                    : `Scroll to the end to enable approval · ${this.offset + 1}–${Math.min(this.total, this.offset + this.pageSize)} of ${this.total}`, this.stale ? 'red' : 'muted'),
-            t.ink((this.approve ? '  ' : '› ') + 'Deny', this.approve ? 'muted' : 'amber') +
-                '     ' +
-                t.ink((this.approve ? '› ' : '  ') + 'Approve once', disabled ? 'muted' : 'jade'),
+                    ? []
+                    : [
+                        t.ink(`Read to the end to approve · ${this.offset + 1}–${Math.min(this.total, this.offset + this.pageSize)} of ${this.total}`, 'muted'),
+                    ]),
+            ...(this.options.desk && below > 0
+                ? [t.ink(`${below} more lines · ↓ to scroll`, 'muted')]
+                : []),
+            ...(this.options.reason
+                ? wrapTextWithAnsi(t.ink(this.options.reason, 'amber'), inner)
+                : []),
+            ...(this.onceOnly ? wrapTextWithAnsi(t.ink(this.onceOnly, 'muted'), inner) : []),
+            ...choices.map((c, i) => t.ink((i === this.choice ? '› ' : '  ') + `${c.key}  ${c.label}`, !c.decision.startsWith('deny') && disabled
+                ? 'muted'
+                : i === this.choice
+                    ? c.colour
+                    : 'muted')),
             '',
-            t.key('↑↓', 'scroll') +
-                '   ' +
-                t.key('←→', 'choose') +
+            t.key('←→', 'choose') +
                 '   ' +
                 t.key('enter', 'decide') +
                 '   ' +
+                t.key('d', this.showDetails ? 'hide details' : 'details') +
+                '   ' +
+                t.key('↑↓', 'scroll') +
+                '   ' +
                 t.key('esc', 'back'),
         ], width);
     }
+    pick(decision) {
+        if (decision !== 'deny' && decision !== 'deny-feedback' && (this.stale || !this.reviewed))
+            return;
+        this.decide(decision);
+    }
     handleInput(data) {
         const current = this.current(), a = this.approval;
         this.stale =
@@ -290,8 +405,14 @@ export class ApprovalModal {
                 current.revision !== a.revision ||
                 current.worker_epoch !== a.worker_epoch ||
                 Date.now() >= a.expires_at;
+        const choices = this.choices();
+        const byKey = choices.find((c) => c.key === data);
         if (matchesKey(data, 'escape'))
             this.close();
+        else if (byKey)
+            this.pick(byKey.decision);
+        else if (data === 'd')
+            this.showDetails = !this.showDetails;
         else if (matchesKey(data, 'down'))
             this.offset++;
         else if (matchesKey(data, 'up'))
@@ -304,10 +425,12 @@ export class ApprovalModal {
             this.offset = this.total;
         else if (matchesKey(data, 'home'))
             this.offset = 0;
-        else if (matchesKey(data, 'left') || matchesKey(data, 'right') || matchesKey(data, 'tab'))
-            this.approve = !this.approve;
-        else if (matchesKey(data, 'enter') && !this.stale && (!this.approve || this.reviewed))
-            this.decide(this.approve ? 'approve' : 'deny');
+        else if (matchesKey(data, 'right') || matchesKey(data, 'tab'))
+            this.choice = (this.choice + 1) % choices.length;
+        else if (matchesKey(data, 'left'))
+            this.choice = (this.choice + choices.length - 1) % choices.length;
+        else if (matchesKey(data, 'enter'))
+            this.pick(choices[this.choice].decision);
         this.renderAgain();
     }
 }

package/dist/src/tui-notify.js

@@ -0,0 +1,62 @@
+import { spawn } from 'node:child_process';
+export function notifyMode(env = process.env) {
+    const v = env.SALAAM_NOTIFY;
+    return v === 'off' || v === 'desktop' ? v : 'bell';
+}
+/** The events worth interrupting someone for, in plain words; everything else stays quiet. */
+export function notificationFor(event) {
+    const p = (event.payload ?? {});
+    if (event.kind === 'approval.requested')
+        return 'Salaam is waiting for your approval';
+    if (event.kind === 'attempt.completed')
+        return 'Salaam finished the turn';
+    if (event.kind === 'attempt.failed')
+        return 'Salaam’s turn failed';
+    if (event.kind === 'local.task_finished') {
+        const how = p.state === 'exited'
+            ? p.exit_code === 0
+                ? 'finished'
+                : `exited with ${String(p.exit_code)}`
+            : String(p.state).replace('_', ' ');
+        return `Background command ${how}: ${String(p.command ?? '').slice(0, 80)}`;
+    }
+    return null;
+}
+export function notify(message, mode, platform = process.platform, run = detached, bell = (s) => void process.stdout.write(s)) {
+    if (mode === 'off')
+        return;
+    bell('\x07');
+    if (mode !== 'desktop')
+        return;
+    // Passed as an argument, never interpolated into the script: a command name cannot inject.
+    if (platform === 'darwin')
+        run('osascript', [
+            '-e',
+            'on run argv\ndisplay notification (item 1 of argv) with title "Salaam"\nend run',
+            message,
+        ]);
+    else if (platform === 'linux')
+        run('notify-send', ['Salaam', message]);
+}
+function detached(cmd, args) {
+    try {
+        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+    }
+    catch {
+        /* the bell already rang */
+    }
+}
+export function jobsText(tasks, outputs) {
+    if (!tasks.length)
+        return 'No background commands in this session.\nThe model starts one with salaam_local background: true.';
+    return tasks
+        .map((t, i) => {
+        const state = t.state === 'exited' ? `exited ${String(t.exit_code)}` : t.state;
+        const tail = outputs[i]?.output.split('\n').slice(-12).join('\n').trimEnd();
+        return `${t.id}  ${state}  ${t.command}${tail ? '\n' + tail.replace(/^/gm, '  │ ') : ''}`;
+    })
+        .join('\n\n')
+        .concat('\n\n/jobs stop <id> stops one.');
+}

package/dist/src/tui-review.js

@@ -0,0 +1,55 @@
+import { relativeTime } from './session-pick.js';
+const SHOWN = 12;
+/** Background commands may keep writing while a review or rewind is open (operator ruling). */
+export function backgroundNote(running) {
+    if (!running)
+        return null;
+    return running === 1
+        ? '1 background task running; its writes may change files. /jobs shows it.'
+        : `${running} background tasks running; their writes may change files. /jobs shows them.`;
+}
+export function changeCounts(change) {
+    return change.added === null ? 'binary' : `+${change.added} −${change.removed}`;
+}
+/** What one confirm of a rewind does, in words. `changes` are from the folder now to the
+ * checkpoint, so a file the checkpoint has and the folder lacks is brought back. */
+export function rewindSummary(review) {
+    const lines = [];
+    if (review.mode === 'conversation')
+        lines.push('Files are not changed.');
+    else if (!review.changes.length)
+        lines.push('Files already match the checkpoint.');
+    else {
+        lines.push(`Files: ${review.changes.length} to put back as they were before turn ${review.turn}.`);
+        for (const change of review.changes.slice(0, SHOWN))
+            lines.push('  ' +
+                (change.status === 'modified'
+                    ? 'restore '
+                    : change.status === 'added'
+                        ? 'bring back '
+                        : 'remove ') +
+                change.path +
+                ` (${changeCounts(change)})`);
+        if (review.changes.length > SHOWN)
+            lines.push(`  … and ${review.changes.length - SHOWN} more files`);
+    }
+    lines.push(review.mode === 'files'
+        ? 'The conversation is kept as it is.'
+        : `The conversation continues in a new session from before turn ${review.turn}; this session stays as it is, and its instruction comes back to edit.`);
+    lines.push('Commands and anything outside this folder are not undone.');
+    const note = backgroundNote(review.background_running);
+    if (note)
+        lines.push(note);
+    return lines.join('\n');
+}
+/** /rewind's turn list: newest first, with how long ago each turn started. */
+export function rewindItems(points, now = Date.now()) {
+    return points
+        .slice()
+        .reverse()
+        .map((p) => ({
+        value: p.attempt_id,
+        label: `Turn ${p.turn} · ${p.text.split('\n')[0].slice(0, 80)}`,
+        description: relativeTime(p.at, now),
+    }));
+}

package/dist/src/tui-turn-keys.js

@@ -0,0 +1,52 @@
+import { matchesKey } from '@earendil-works/pi-tui';
+/** Interactive local coding: the desk-side mode, not admitted or strict work. */
+export function interactiveCoding(snapshot) {
+    return !!snapshot?.capabilities.includes('local-coding-reviewed');
+}
+/** The turn the model is working on now, if any. */
+export function runningAttempt(snapshot) {
+    return snapshot?.attempts.find((a) => a.state === 'running')?.id;
+}
+export function turnKeyAction(input) {
+    const { key, text, snapshot } = input;
+    if (input.modal || input.autocomplete)
+        return key === 'enter' ? 'submit' : null;
+    const live = interactiveCoding(snapshot) && runningAttempt(snapshot) !== undefined;
+    const words = text.trim() !== '' && !text.trimStart().startsWith('/');
+    if (key === 'escape')
+        return live ? 'interrupt' : null;
+    if (key === 'tab')
+        return live && words ? 'queue' : null;
+    return live && words ? 'steer' : 'submit';
+}
+/** The key the TUI saw, as one of the three this module decides, or undefined for any other. */
+export function turnKey(data) {
+    return matchesKey(data, 'escape')
+        ? 'escape'
+        : matchesKey(data, 'enter')
+            ? 'enter'
+            : matchesKey(data, 'tab')
+                ? 'tab'
+                : undefined;
+}
+/** What /cancel offers, the running turn first, then work queued behind it. */
+export function cancelChoices(snapshot) {
+    const order = ['running', 'dispatching', 'accepted'];
+    return snapshot.attempts
+        .filter((a) => order.includes(a.state))
+        .sort((a, b) => order.indexOf(a.state) - order.indexOf(b.state))
+        .map((a) => ({
+        id: a.id,
+        label: (a.state === 'accepted' ? 'queued' : a.state) + ' · ' + a.id.slice(0, 8),
+    }));
+}
+/** Instructions waiting behind the running turn, with their text, so they can be edited or removed. */
+export function queuedItems(snapshot) {
+    return snapshot.attempts
+        .filter((a) => a.state === 'accepted')
+        .map((a) => ({
+        attempt: a.id,
+        submission: a.submission_id,
+        text: snapshot.submissions.find((s) => s.id === a.submission_id)?.text ?? '',
+    }));
+}