atris 3.32.0 → 3.33.3

package/README.md

@@ -12,6 +12,14 @@ Computer = workspace + files + tools + secrets + memory + agents + validation lo
 
 A computer can be personal or shared by a business. It can run a job like code, research, CRM, reporting, event ops, support, or business ops.
 
+## Quick Start
+
+```bash
+npm install -g atris
+cd your-project
+atris init && atris
+```
+
 ## For Coding Agents
 
 **Read [`FOR_AGENTS.md`](FOR_AGENTS.md) first** — why agents adopt Atris, 60-second start, spread-it instructions.
@@ -47,6 +55,7 @@ Then read the workspace's `atris/atris.md` and follow it exactly. `atris.md` is
 | `atris/features/` | Feature packs with `idea.md`, `build.md`, `validate.md` |
 | `atris/skills/` | Reusable skills for agents |
 | `atris/team/` | Team member specs and local context |
+| `atris/wiki/` | Repo memory, briefs, concepts, and wiki health |
 
 ```text
 atris/
@@ -56,7 +65,8 @@ atris/
 ├── logs/
 ├── features/
 ├── skills/
-└── team/
+├── team/
+└── wiki/
 ```
 
 ## Install
@@ -232,6 +242,38 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 - `atris pull` and `atris push` sync cloud workspaces and journals
 - `atris live` keeps a business brain fresh by checking/fixing the workspace, pushing local state, pulling cloud state, and pushing again after local changes go quiet
 
+## Engines
+
+An engine is the intelligence that builds a mission. Every installed headless coding CLI is a swappable worker behind one contract: a bounded prompt goes in, verified proof comes out, and engines never self-certify their own work. The house default is `atris-fast` (`ax`); the roster also covers `claude`, `codex`, `cursor`, and `devin` when their CLIs are installed.
+
+Show the roster and the current default:
+
+```bash
+atris engine
+```
+
+Flip the default for this workspace (persists to `.atris/engine.json`):
+
+```bash
+atris engine cursor
+atris engine reset   # back to the house default (atris-fast)
+```
+
+Ride a different engine for one run only, without changing the default. `--engine <name>` works on `mission run`, `autopilot`, and `run`. Per-run flags and `ATRIS_RUNNER_PROFILE` always beat the saved file.
+
+```bash
+atris mission run "fix the flaky login test" --engine codex
+```
+
+### Fleet Flight
+
+`atris mission run --fleet` staffs every idle installed engine on the board's claimable safe-lane tasks — one mission per task, one worktree per engine. Builds run in parallel; arrivals land serially with rebase-before-ship, so a rebase conflict pauses that landing (never auto-resolved) and keeps its worktree instead of orphaning work. Each flight writes a receipt to `atris/runs/fleet-<stamp>.json`.
+
+```bash
+atris mission run --fleet --slots 3          # staff up to 3 engines
+atris mission run --fleet --dry-run          # preview the staffing only
+```
+
 ## Verifiable Feedback Loop
 
 Under the hood, Atris can keep score on real repo work.

package/ax

@@ -862,6 +862,19 @@ function formatAtrisGoal(goal) {
   ].filter(Boolean).join('\n');
 }
 
+function formatGoalStatusLine(goal, options = {}) {
+  if (!goal || !goal.objective) return '';
+  const status = String(goal.mission_status || '').toLowerCase();
+  if (!['active', 'running', 'planning', 'in_progress', 'ready'].includes(status)) return '';
+  const elapsed = goalElapsedSeconds(goal);
+  const objective = String(goal.objective).length > 64
+    ? `${String(goal.objective).slice(0, 61)}...`
+    : String(goal.objective);
+  const parts = [`goal: ${objective}`, status];
+  if (elapsed !== null) parts.push(`${formatSeconds(elapsed)} in`);
+  return paint(`· ${parts.join(' · ')}`, [ANSI.muted], options);
+}
+
 function writeAtrisGoalBanner(output, cwd = process.cwd()) {
   const text = formatAtrisGoal(currentAtrisGoal(cwd));
   if (!text) return false;
@@ -937,28 +950,176 @@ function resetMarkdownState(state) {
   state.markdownMode = 'normal';
   state.markdownBuffer = '';
   state.markdownCarry = '';
+  state.markdownFence = false;
+  state.markdownTable = [];
+  state.markdownLine = '';
+  state.markdownLineMode = 'start';
 }
 
 function ensureMarkdownState(state) {
   if (!state.markdownMode) state.markdownMode = 'normal';
   if (typeof state.markdownBuffer !== 'string') state.markdownBuffer = '';
   if (typeof state.markdownCarry !== 'string') state.markdownCarry = '';
+  if (typeof state.markdownFence !== 'boolean') state.markdownFence = false;
+  if (!Array.isArray(state.markdownTable)) state.markdownTable = [];
+  if (typeof state.markdownLine !== 'string') state.markdownLine = '';
+  if (!state.markdownLineMode) state.markdownLineMode = 'start';
+}
+
+function renderInlineMarkdown(text, options = {}) {
+  let rendered = String(text || '');
+  const codeSpans = [];
+  rendered = rendered.replace(/`([^`\n]+)`/g, (_, code) => {
+    const token = `\u0000CODE${codeSpans.length}\u0000`;
+    codeSpans.push(code);
+    return token;
+  });
+  rendered = rendered.replace(/\*\*([^*\n]+)\*\*/g, (_, value) => paint(value, [ANSI.bold], options));
+  rendered = rendered.replace(/__([^_\n]+)__/g, (_, value) => paint(value, [ANSI.bold], options));
+  rendered = rendered.replace(/\u0000CODE(\d+)\u0000/g, (_, index) => paint(codeSpans[Number(index)] || '', [ANSI.accent], options));
+  return rendered;
 }
 
+function renderMarkdownTable(lines, options = {}) {
+  const rows = [];
+  for (const line of lines) {
+    const trimmed = String(line || '').trim().replace(/^\|/, '').replace(/\|$/, '');
+    const cells = trimmed.split('|').map(cell => cell.trim());
+    if (cells.length && cells.every(cell => /^:?-{2,}:?$/.test(cell))) continue;
+    rows.push(cells);
+  }
+  if (!rows.length) return '';
+  const width = Math.max(...rows.map(row => row.length));
+  const plain = value => String(value || '').replace(/\x1b\[[0-9;]*m/g, '');
+  const rendered = rows.map(row => row.map(cell => renderInlineMarkdown(cell, options)));
+  const colWidths = Array.from({ length: width }, (_, col) => (
+    Math.max(...rendered.map(row => plain(row[col] || '').length))
+  ));
+  const sep = paint('│', [ANSI.muted], options);
+  return rendered.map((row, rowIndex) => {
+    const cells = Array.from({ length: width }, (_, col) => {
+      const cell = row[col] || '';
+      const pad = ' '.repeat(Math.max(0, colWidths[col] - plain(cell).length));
+      const value = `${cell}${pad}`;
+      return rowIndex === 0 ? paint(plain(value), [ANSI.bold], options) : value;
+    });
+    return `  ${cells.join(` ${sep} `)}`;
+  }).join('\n') + '\n';
+}
+
+function flushMarkdownTable(state, options = {}) {
+  if (!state.markdownTable.length) return '';
+  const table = renderMarkdownTable(state.markdownTable, options);
+  state.markdownTable = [];
+  return table;
+}
+
+function renderMarkdownLine(state, line, options = {}) {
+  const fenceMatch = /^\s*```/.test(line);
+  if (fenceMatch) {
+    state.markdownFence = !state.markdownFence;
+    const label = line.trim().slice(3).trim();
+    if (state.markdownFence && label) return `${paint(label, [ANSI.muted], options)}\n`;
+    return '';
+  }
+  if (state.markdownFence) {
+    return `  ${paint(line, [ANSI.accent], options)}\n`;
+  }
+  if (/^\s*\|/.test(line)) {
+    state.markdownTable.push(line);
+    return '';
+  }
+  let out = flushMarkdownTable(state, options);
+  const header = line.match(/^(#{1,6})\s+(.*)$/);
+  if (header) {
+    const codes = header[1].length <= 2 ? [ANSI.bold, ANSI.accent] : [ANSI.bold];
+    return `${out}${paint(renderInlineMarkdown(header[2], options).replace(/\x1b\[[0-9;]*m/g, ''), codes, options)}\n`;
+  }
+  if (/^\s*(?:-{3,}|_{3,}|\*{3,})\s*$/.test(line)) {
+    return `${out}${paint('─'.repeat(36), [ANSI.muted], options)}\n`;
+  }
+  const bullet = line.match(/^(\s*)[-*]\s+(.*)$/);
+  if (bullet) {
+    return `${out}${bullet[1]}${paint('•', [ANSI.bold], options)} ${renderInlineMarkdown(bullet[2], options)}\n`;
+  }
+  const quote = line.match(/^\s*>\s?(.*)$/);
+  if (quote) {
+    return `${out}${paint('│', [ANSI.muted], options)} ${paint(renderInlineMarkdown(quote[1], options).replace(/\x1b\[[0-9;]*m/g, ''), [ANSI.muted], options)}\n`;
+  }
+  return `${out}${renderInlineMarkdown(line, options)}\n`;
+}
+
+// Hybrid streaming renderer. Prose streams character-live through the inline
+// state machine (bold/code style as delimiters close), so chat feels
+// immediate. Structure-shaped lines (tables, fences, headers, bullets,
+// quotes) buffer to the line boundary and render as blocks, because they
+// cannot be styled until the whole line exists. The first character of each
+// line decides which lane the line takes.
+const MARKDOWN_BLOCK_LINE_START = new Set(['|', '#', '`', '>', '-', '*']);
+
 function renderStreamingMarkdown(state, text, options = {}) {
   ensureMarkdownState(state);
-  const input = `${state.markdownCarry || ''}${String(text || '')}`;
-  state.markdownCarry = '';
+  const input = String(text || '');
   let out = '';
 
   for (let i = 0; i < input.length;) {
     const char = input[i];
-    const next = input[i + 1];
 
+    // Structure lane: buffer the whole line, render at the newline.
+    if (state.markdownFence || state.markdownLineMode === 'block') {
+      if (char === '\n') {
+        out += renderMarkdownLine(state, state.markdownLine, options);
+        state.markdownLine = '';
+        state.markdownLineMode = 'start';
+      } else {
+        state.markdownLine += char;
+      }
+      i += 1;
+      continue;
+    }
+
+    // Line start: decide which lane this line takes.
+    if (state.markdownLineMode === 'start') {
+      if (char === '\n') {
+        out += flushMarkdownTable(state, options);
+        out += '\n';
+        i += 1;
+        continue;
+      }
+      if (MARKDOWN_BLOCK_LINE_START.has(char)) {
+        state.markdownLineMode = 'block';
+        state.markdownLine = char;
+        i += 1;
+        continue;
+      }
+      out += flushMarkdownTable(state, options);
+      state.markdownLineMode = 'prose';
+      continue;
+    }
+
+    // Prose lane: the inline state machine, character-live.
+    const next = input[i + 1];
     if (state.markdownMode === 'normal') {
+      if (state.markdownCarry === '*') {
+        state.markdownCarry = '';
+        if (char === '*') {
+          state.markdownMode = 'bold';
+          state.markdownBuffer = '';
+          i += 1;
+          continue;
+        }
+        out += '*';
+      }
+      if (char === '\n') {
+        out += '\n';
+        state.markdownLineMode = 'start';
+        i += 1;
+        continue;
+      }
       if (char === '*' && next === undefined) {
         state.markdownCarry = '*';
-        break;
+        i += 1;
+        continue;
       }
       if (char === '*' && next === '*') {
         state.markdownMode = 'bold';
@@ -978,23 +1139,52 @@ function renderStreamingMarkdown(state, text, options = {}) {
     }
 
     if (state.markdownMode === 'bold') {
+      if (char === '\n') {
+        out += `**${state.markdownBuffer}\n`;
+        state.markdownMode = 'normal';
+        state.markdownBuffer = '';
+        state.markdownLineMode = 'start';
+        i += 1;
+        continue;
+      }
       if (char === '*' && next === undefined) {
         state.markdownCarry = '*';
-        break;
+        i += 1;
+        continue;
       }
-      if (char === '*' && next === '*') {
+      if (char === '*' && (next === '*' || state.markdownCarry === '*')) {
         out += paint(state.markdownBuffer, [ANSI.bold], options);
         state.markdownMode = 'normal';
         state.markdownBuffer = '';
-        i += 2;
+        state.markdownCarry = '';
+        i += next === '*' ? 2 : 1;
         continue;
       }
+      if (state.markdownCarry === '*') {
+        state.markdownCarry = '';
+        if (char === '*') {
+          out += paint(state.markdownBuffer, [ANSI.bold], options);
+          state.markdownMode = 'normal';
+          state.markdownBuffer = '';
+          i += 1;
+          continue;
+        }
+        state.markdownBuffer += '*';
+      }
       state.markdownBuffer += char;
       i += 1;
       continue;
     }
 
     if (state.markdownMode === 'code') {
+      if (char === '\n') {
+        out += `\`${state.markdownBuffer}\n`;
+        state.markdownMode = 'normal';
+        state.markdownBuffer = '';
+        state.markdownLineMode = 'start';
+        i += 1;
+        continue;
+      }
       if (char === '`') {
         out += paint(state.markdownBuffer, [ANSI.accent], options);
         state.markdownMode = 'normal';
@@ -1013,12 +1203,27 @@ function renderStreamingMarkdown(state, text, options = {}) {
 
 function flushStreamingMarkdown(state, output) {
   ensureMarkdownState(state);
-  let out = state.markdownCarry || '';
+  let out = '';
+  if (state.markdownLine) {
+    if (/^\s*```/.test(state.markdownLine)) {
+      // A fence marker with no trailing newline is a block boundary, not code.
+      state.markdownFence = !state.markdownFence;
+    } else if (state.markdownFence) {
+      out += `  ${paint(state.markdownLine, [ANSI.accent], output)}`;
+    } else {
+      out += renderMarkdownLine(state, state.markdownLine, output).replace(/\n$/, '');
+    }
+    state.markdownLine = '';
+  }
+  if (state.markdownCarry) {
+    out += state.markdownCarry;
+  }
   if (state.markdownMode === 'bold' && state.markdownBuffer) {
     out += paint(state.markdownBuffer, [ANSI.bold], output);
   } else if (state.markdownMode === 'code' && state.markdownBuffer) {
     out += paint(state.markdownBuffer, [ANSI.accent], output);
   }
+  out += flushMarkdownTable(state, output);
   resetMarkdownState(state);
   if (out) output.write(out);
   return out;
@@ -1476,6 +1681,99 @@ function removeStoredApproval(ref, options = {}) {
   return record;
 }
 
+// Local turns stage side effects as signed artifacts in the workspace's
+// atris/approvals/ (atris.local_approval.v1), a different store from
+// ~/.atris/ax-approvals.json. ax --approve redeems them through the local
+// backend's approvals/execute endpoint, which re-signs with explicit user
+// approval and runs the gated executor.
+function workspaceApprovalsDir(cwd) {
+  return path.join(cwd || process.cwd(), 'atris', 'approvals');
+}
+
+function listWorkspaceApprovals(cwd) {
+  const dir = workspaceApprovalsDir(cwd);
+  let names = [];
+  try {
+    names = fs.readdirSync(dir).filter(name => name.endsWith('.json'));
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const name of names) {
+    const filePath = path.join(dir, name);
+    try {
+      const record = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      if (record && record.schema === 'atris.local_approval.v1') {
+        records.push({ path: filePath, record, mtimeMs: fs.statSync(filePath).mtimeMs });
+      }
+    } catch {
+      // Unreadable artifact: skip, never block the turn.
+    }
+  }
+  return records;
+}
+
+function findWorkspaceApproval(ref, cwd) {
+  const target = String(ref || '').trim();
+  if (!target) return null;
+  const matches = listWorkspaceApprovals(cwd)
+    .filter(item => String(item.record.approval_id || '').startsWith(target));
+  if (matches.length !== 1) return null;
+  return matches[0];
+}
+
+function pendingWorkspaceApprovalsSince(cwd, sinceMs) {
+  return listWorkspaceApprovals(cwd).filter(item => (
+    item.mtimeMs >= sinceMs
+    && String(item.record.status || '') === 'pending'
+    && !(item.record.decision && item.record.decision.approved)
+  ));
+}
+
+async function approveWorkspaceApproval(ref, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const found = findWorkspaceApproval(ref, cwd);
+  if (!found) throw new Error(`Pending approval not found: ${ref}`);
+  const output = options.output || process.stdout;
+  const { record } = found;
+  const startedAt = Date.now();
+  const payload = record.payload && typeof record.payload === 'object' ? record.payload : {};
+  output.write(`${formatAuxRow('id', record.approval_id, output)}\n`);
+  if (record.summary) output.write(`${formatAuxRow('action', record.summary, output)}\n`);
+  if (payload.command) output.write(`${formatAuxRow('command', payload.command, output)}\n`);
+  output.write('Accepted.\n');
+  const response = await postJson(APPROVAL_EXECUTE_PATH, {
+    model: modelForMode(options.mode || 'fast'),
+    approval_request: {
+      action_type: record.action_type,
+      approval_id: record.approval_id,
+      summary: record.summary,
+      payload: { ...payload, workspace: payload.workspace || cwd },
+    },
+  }, { route: 'local' });
+  const execution = response && response.data && typeof response.data === 'object' ? response.data : {};
+  const executed = Boolean(execution.execution && execution.execution.executed) || execution.status === 'executed';
+  const statusText = executed
+    ? 'Done.'
+    : `Not executed: ${String(execution.status || response.error || `HTTP ${response.status || 0}`)}`;
+  output.write(`${formatAuxRow(executed ? 'done' : 'wait', statusText, output)}\n`);
+  try {
+    const spent = { ...record, status: executed ? 'executed' : record.status, executed_at: executed ? new Date().toISOString() : undefined };
+    fs.writeFileSync(found.path, `${JSON.stringify(spent, null, 2)}\n`);
+  } catch {
+    // Bookkeeping only; the backend holds replay protection.
+  }
+  output.write(`${formatDoneLine(Date.now() - startedAt)}\n`);
+  if (!response.ok && !executed) process.exitCode = 1;
+  return { response, executed };
+}
+
+function writeWorkspaceApprovalHints(cwd, sinceMs, output) {
+  for (const item of pendingWorkspaceApprovalsSince(cwd, sinceMs)) {
+    output.write(`${formatAuxRow('approve', formatApprovalCommand(item.record.approval_id), output)}\n`);
+  }
+}
+
 function formatStoredApprovals(store, options = {}) {
   const approvals = Array.isArray(store && store.approvals) ? store.approvals : [];
   if (!approvals.length) return 'No pending approvals.';
@@ -1762,8 +2060,30 @@ function writeAuxLine(state, output, line) {
   state.needsBullet = true;
 }
 
+// Turns beyond the recent window used to fall off a cliff: turn 9 of a chat
+// silently forgot turn 1 and never said so. Evicted turns now compress into
+// a digest that rides as the first previous message, so long chats keep the
+// thread of the whole conversation. AX_NO_COMPACT=1 restores the bare window.
+const HISTORY_DIGEST_MAX_CHARS = 2400;
+
+function compactedHistoryDigest(evicted) {
+  const lines = [];
+  for (const turn of evicted) {
+    const who = turn && turn.role === 'assistant' ? 'atris' : 'user';
+    const text = String((turn && turn.content) || '').replace(/\s+/g, ' ').trim().slice(0, 160);
+    if (text) lines.push(`${who}: ${text}`);
+  }
+  let digest = lines.join('\n');
+  if (digest.length > HISTORY_DIGEST_MAX_CHARS) {
+    digest = digest.slice(digest.length - HISTORY_DIGEST_MAX_CHARS);
+    digest = digest.slice(digest.indexOf('\n') + 1);
+  }
+  return digest;
+}
+
 function structuredHistory(history, limit = 8) {
-  return (Array.isArray(history) ? history : [])
+  const rows = Array.isArray(history) ? history : [];
+  const recent = rows
     .slice(-limit)
     .map(turn => {
       const message = {
@@ -1776,6 +2096,16 @@ function structuredHistory(history, limit = 8) {
       return message;
     })
     .filter(turn => turn.content.trim());
+  if (rows.length <= limit || process.env.AX_NO_COMPACT === '1') return recent;
+  const digest = compactedHistoryDigest(rows.slice(0, rows.length - limit));
+  if (!digest) return recent;
+  return [
+    {
+      role: 'user',
+      content: `[conversation so far, compacted from ${rows.length - limit} earlier turns]\n${digest}`,
+    },
+    ...recent,
+  ];
 }
 
 function latestPendingTaskPreview(history = []) {
@@ -2300,6 +2630,7 @@ async function chat(options = {}) {
   const logger = createRunLogger({ cwd, mode, kind: 'play', output: baseOutput });
   const output = logger ? logger.output : baseOutput;
   const history = [];
+  let lastCompactionNotice = 0;
   const conversationId = options.conversationId || `ax-${process.pid}-${Date.now().toString(36)}`;
 
   output.write(`${formatHeader({ mode, cwd, chat: true }, output)}\n\n`);
@@ -2444,6 +2775,12 @@ async function chat(options = {}) {
     if (!(await ensureRuntimeReady(turnRoute))) return false;
     const turnFunction = options.turnFunction || turnFunctionForMode(mode);
     const turnId = options.turnId || createTurnId();
+    const turnStartedAt = Date.now();
+    const compactedTurns = process.env.AX_NO_COMPACT === '1' ? 0 : Math.max(0, history.length - 8);
+    if (compactedTurns > 0 && compactedTurns !== lastCompactionNotice) {
+      lastCompactionNotice = compactedTurns;
+      output.write(`${paint(`· context: ${compactedTurns} earlier turn${compactedTurns === 1 ? '' : 's'} compacted into a digest`, [ANSI.muted], output)}\n`);
+    }
     const result = await turnFunction(trimmed, { mode, cwd, history, output, route, business: options.business, verify: options.verify, conversationId, turnId });
     if (result.output && !result.output.endsWith('\n')) output.write('\n');
     const approvalExecution = normalizeMode(mode) === 'code-fast'
@@ -2453,7 +2790,11 @@ async function chat(options = {}) {
         output,
         ...(options.postApproval ? { postApproval: options.postApproval } : {}),
       });
-    output.write(`${formatDoneLine(result.durationMs, creditsFromState(result))}\n\n`);
+    if (!options.turnFunction) writeWorkspaceApprovalHints(cwd, turnStartedAt, output);
+    output.write(`${formatDoneLine(result.durationMs, creditsFromState(result))}\n`);
+    const goalLine = options.turnFunction ? '' : formatGoalStatusLine(currentAtrisGoal(cwd), output);
+    if (goalLine) output.write(`${goalLine}\n`);
+    output.write('\n');
     const receipt = receiptFromState(result);
     const approvalRequest = approvalExecution
       ? (
@@ -3365,7 +3706,11 @@ async function main() {
     }
 
     if (approveId) {
-      await approveStoredApproval(approveId, { mode, output: process.stdout });
+      if (findStoredApproval(approveId)) {
+        await approveStoredApproval(approveId, { mode, output: process.stdout });
+      } else {
+        await approveWorkspaceApproval(approveId, { cwd: process.cwd(), mode, output: process.stdout });
+      }
       return;
     }
 
@@ -3383,6 +3728,7 @@ async function main() {
     console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }, process.stdout));
     console.log('');
     maybeWriteAtrisGoalBanner(process.stdout, process.cwd());
+    const turnStartedAt = Date.now();
     const result = await turnFunctionForMode(mode)(prompt, { mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify });
     const receipt = receiptFromState(result);
     const approvalRequest = normalizeMode(mode) === 'code-fast' ? null : approvalRequestFromReceipt(receipt);
@@ -3390,6 +3736,9 @@ async function main() {
       ? persistPendingApproval(receipt, approvalRequest, { cwd: process.cwd(), mode })
       : null;
     if (approvalRecord) console.log(formatAuxRow('approve', formatApprovalCommand(approvalRecord.id), process.stdout));
+    // A one-shot has no next turn, so "reply yes to approve" is a dead end;
+    // surface the exact redeem command for anything the turn staged on disk.
+    writeWorkspaceApprovalHints(process.cwd(), turnStartedAt, process.stdout);
     console.log('');
     console.log(formatDoneLine(result.durationMs, creditsFromState(result)));
   } catch (error) {
@@ -3417,6 +3766,10 @@ module.exports = {
   approvalRequestFromReceipt,
   approvalStorePath,
   approveStoredApproval,
+  approveWorkspaceApproval,
+  findWorkspaceApproval,
+  listWorkspaceApprovals,
+  pendingWorkspaceApprovalsSince,
   backendBaseUrl,
   backendStartCommand,
   backendUrl,