atris 3.47.0 → 3.48.1

package/commands/worktree.js

@@ -160,6 +160,8 @@ function listWorktrees(root = repoRoot()) {
 // Duplicate flight guard. On 2026-08-07 two agents were dispatched onto the
 // same map rewrite 44 seconds apart: fleet dispatch claims a task first, but a
 // direct `worktree start` had no pre-check beyond the target path existing.
+// Refuse only the same task slug. A shared word on an unrelated flight is not
+// a collision (dispatch-cli-900 must not block dispatch-cli-901).
 const AGENT_FLIGHT_NAME_PATTERN = /^codex\/(.+)-(\d{8}-\d{6})$/;
 const FLIGHT_WINDOW_MS = 24 * 60 * 60 * 1000;
 const FLIGHT_STOPWORDS = new Set([
@@ -234,10 +236,10 @@ function inFlightAgentFlights({ root = repoRoot(), now = new Date(), windowMs =
   return [...flights.values()].sort((a, b) => b.stampMs - a.stampMs);
 }
 
-function collidingFlights(flights, tokens) {
-  const wanted = new Set(tokens);
-  if (!wanted.size) return [];
-  return flights.filter((flight) => flight.tokens.some((token) => wanted.has(token)));
+function collidingFlights(flights, taskSlug) {
+  const wanted = String(taskSlug || '').trim().toLowerCase();
+  if (!wanted) return [];
+  return flights.filter((flight) => String(flight.taskSlug || '').toLowerCase() === wanted);
 }
 
 function describeFlightAge(flight, nowMs = Date.now()) {
@@ -511,7 +513,7 @@ function startWorktree(args) {
   const active = flights.filter((flight) => flight.kind === 'worktree');
   const repoName = path.basename(findPrimaryRoot(root));
   console.log(`flights: ${active.length} active agent ${active.length === 1 ? 'worktree' : 'worktrees'} for ${repoName}`);
-  const collisions = collidingFlights(flights, taskTokens(slugify(task, 'task', 36)));
+  const collisions = collidingFlights(flights, slugify(task, 'task', 36));
   if (collisions.length) {
     const label = force ? 'warning' : 'refusing';
     for (const flight of collisions) {

package/commands/youtube.js

@@ -1,8 +1,12 @@
 const { apiRequestJson } = require('../utils/api');
 const { ensureValidCredentials } = require('../utils/auth');
 const { spawnSync } = require('child_process');
+const path = require('path');
 const https = require('https');
 
+const YTNOTES_USAGE = 'usage: ytnotes <youtube-url> [haiku|atris-fast|gemini|grok|codex|cursor]';
+const YTNOTES_HINT = 'zero credits, local captions + a fast engine';
+
 const DEFAULT_QUERY = [
   'Create a timestamped YouTube brief for Atris.',
   'Include: metadata, timestamped outline, core claims with confidence, memorable examples, actionable takeaways, Atris/product implications, and next actions.',
@@ -19,9 +23,11 @@ const ALLOWED_CAPTION_HOST_SUFFIXES = [
 
 function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('');
-  output(`Usage: ${commandName} process <youtube-url> [options]`);
+  output(`Usage: ${commandName} notes <youtube-url> [engine]`);
+  output(`       ${commandName} process <youtube-url> [options]`);
   output(`       ${commandName} <youtube-url> [options]`);
   output('');
+  output('notes = free local notes, process = 5 credits cloud knowledge');
   output('Process a YouTube video through Atris using timestamped transcript-first analysis.');
   output('Falls back to cloud video processing when local captions are unavailable.');
   output('');
@@ -37,6 +43,7 @@ function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('  metadata -> timestamped outline -> claims -> examples -> takeaways -> Atris implications -> next actions');
   output('');
   output('Examples:');
+  output(`  ${commandName} notes https://www.youtube.com/watch?v=VIDEO_ID`);
   output(`  ${commandName} https://www.youtube.com/watch?v=VIDEO_ID`);
   output(`  ${commandName} process https://youtu.be/VIDEO_ID --query "Key takeaways"`);
   output('');
@@ -437,8 +444,31 @@ function formatYoutubeResult(data) {
   return lines.join('\n');
 }
 
+function runYoutubeNotes(args = [], deps = {}) {
+  const output = deps.output || ((line = '') => console.error(line));
+  const url = args[0];
+  const engine = args[1];
+  if (!url) {
+    output(YTNOTES_USAGE);
+    output(YTNOTES_HINT);
+    return 2;
+  }
+
+  const script = path.join(__dirname, '..', 'scripts', 'det', 'ytnotes');
+  const spawn = deps.spawnSync || spawnSync;
+  const childArgs = engine ? [url, engine] : [url];
+  const result = spawn(script, childArgs, { stdio: 'inherit' });
+  if (result.status == null) return 1;
+  return result.status;
+}
+
 async function youtubeCommand(argv = process.argv.slice(3), deps = {}) {
   const output = deps.output || ((line = '') => console.log(line));
+  if (argv[0] === 'notes') {
+    const code = runYoutubeNotes(argv.slice(1), deps);
+    if (!deps.output && !deps.spawnSync) process.exit(code);
+    return code;
+  }
   const options = parseYoutubeArgs(argv);
   if (options.help) {
     showYoutubeHelp(output, deps.commandName || 'atris youtube');

package/lib/engine-ask.js

@@ -9,7 +9,11 @@ const {
   DEFAULT_CLAUDE_RUNNER_MODEL,
   RUNNER_PROFILE_DEFS,
 } = require('./runner-command');
-const { canonicalEngineName } = require('./engine-registry');
+const {
+  canonicalEngineName,
+  engineFailureHealthStatus,
+  setEngineHealth,
+} = require('./engine-registry');
 const {
   appendEngineLiveLogChunk,
   createEngineLiveLog,
@@ -452,6 +456,15 @@ function answerStatus(answer) {
   return engineTerminalStatus(answer);
 }
 
+function recordEngineAskHealth(answers, root) {
+  for (const answer of answers) {
+    const status = answer.ok
+      ? 'ready'
+      : engineFailureHealthStatus({ ...answer, status: 'errored' });
+    if (status) setEngineHealth(answer.engine, status, root);
+  }
+}
+
 function engineAskReceipt(answers, { concurrency, timeoutMs, at = new Date().toISOString() }) {
   const receiptAnswers = answers.map((answer) => ({ ...answer, status: answerStatus(answer) }));
   const answered = receiptAnswers.filter((answer) => answer.status === 'answered').length;
@@ -582,6 +595,7 @@ async function runEngineAskCommand(args, root = process.cwd(), deps = {}) {
       signal: abort.signal,
       onOutputChunk: (chunk, stream) => appendLiveLog(liveLogPath, chunk, stream),
     });
+    recordEngineAskHealth(answers, root);
     const receipt = engineAskReceipt(answers, {
       concurrency: parsed.concurrency,
       timeoutMs: parsed.timeoutMs,

package/lib/engine-registry.js

@@ -16,6 +16,28 @@ const ENGINE_ROLES = Object.freeze(['navigator', 'executor', 'validator']);
 const ENGINE_DUTIES = Object.freeze(['leader', 'errands', 'learning']);
 const ENGINE_HEALTH_STATUSES = Object.freeze(['ready', 'not_installed', 'credit_out', 'error']);
 
+function engineFailureHealthStatus(result) {
+  if (!result || result.status !== 'errored') return null;
+  const signalText = [
+    result.reason,
+    result.model_unavailable,
+    result.report,
+    result.stdout,
+    result.stderr,
+    result.error,
+    result.claude && result.claude.summary,
+    result.claude && result.claude.receipt_text,
+    result.claude && result.claude.stderr,
+    result.rate_limit_info && JSON.stringify(result.rate_limit_info),
+  ].filter(Boolean).join('\n').toLowerCase();
+  if (/usage[ _-]?limit|purchase more credits|insufficient credits|credit(?:s)?[ _-]?(?:out|limit)|rate[ _-]?limit|not authenticated|please log in|login required|auth(?:entication)?[ _-]?expired|payment required|subscription/.test(signalText)) {
+    return 'credit_out';
+  }
+  if (/not installed|command not found|\benoent\b/.test(signalText)) return 'not_installed';
+  if (/timeout|model-unavailable/.test(signalText)) return 'not_installed';
+  return 'error';
+}
+
 const ENGINE_SEED_META = Object.freeze({
   'atris-fast': Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator']), models: Object.freeze(['atris fast']), duty: 'learning', fallback_order: 10 }),
   codex: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), models: Object.freeze(['codex']), fallback_order: 10 }),
@@ -356,6 +378,7 @@ module.exports = {
   resolveEngineForRoleRanked,
   resolveEngineForRole,
   resolveEngineForRoleWithPreference,
+  engineFailureHealthStatus,
   setEngineOverrides,
   setEngineHealth,
 };

package/lib/fleet.js

@@ -23,6 +23,7 @@ const {
   worktreeBaseRef,
 } = require('./brief-ledger');
 const { RUNNER_PROFILE_DEFS, buildRunnerCommand } = require('./runner-command');
+const { engineFailureHealthStatus, setEngineHealth } = require('./engine-registry');
 const { resolveDefaultVerifier } = require('./default-verifier');
 const { rankEnginesDetailed } = require('./router-brain');
 const {
@@ -207,7 +208,7 @@ function buildEngineCommand(engineName, promptFile, { yolo = false, sealed = fal
     if (sealed && engineName === 'codex') {
       cmd = cmd.replace(/\bexec\b/, 'exec --sandbox workspace-write --ephemeral --ignore-user-config --ignore-rules');
     }
-    if (sealed && engineName === 'claude') {
+    if (sealed && (engineName === 'claude' || engineName === 'fable')) {
       cmd = `${cmd} --safe-mode --no-session-persistence --permission-mode acceptEdits --settings '${JSON.stringify({ sandbox: { enabled: true, autoAllowBashIfSandboxed: true } })}'`;
     }
     if (sealed && engineName === 'cursor') cmd = `${cmd} --sandbox enabled`;
@@ -217,7 +218,7 @@ function buildEngineCommand(engineName, promptFile, { yolo = false, sealed = fal
     }
     if (engineName === 'devin') return cmd.replace(/^devin -p /, 'devin -p --permission-mode dangerous ');
     if (yolo && engineName === 'codex') cmd = cmd.replace(/\bexec\b/, `exec ${YOLO_ENGINE_FLAGS.codex}`);
-    if (yolo && engineName === 'claude') cmd = `${cmd} ${YOLO_ENGINE_FLAGS.claude}`;
+    if (yolo && (engineName === 'claude' || engineName === 'fable')) cmd = `${cmd} ${YOLO_ENGINE_FLAGS.claude}`;
     if (engineName === 'codex') cmd = wrapCodexWithWatchdog(cmd, watchdogPath, watchdogReceiptPath);
     return cmd;
   } finally {
@@ -560,6 +561,37 @@ function detectDeadEngineDispatch(result) {
   return { reason: 'nonzero_exit', exitCode };
 }
 
+function plainDispatchFailureCause(result, failure = {}) {
+  const reason = String(failure.reason || failure.stage || '').trim();
+  const output = dispatchResultOutput(result);
+  if (reason === 'no_output') return 'the engine returned no output';
+  if (/not authenticated|please log in|login required|auth(?:entication)?[ _-]?expired/i.test(output)) {
+    return 'the engine login expired';
+  }
+  if (/spawn[^\n]*enoent|enoent[^\n]*spawn|failed to spawn/i.test(output)) {
+    return 'the engine could not start';
+  }
+  if (reason === 'timeout') return 'the engine timed out';
+  if (reason === 'cancelled') return 'the engine run was cancelled';
+  if (reason === 'unknown') return 'the engine exited without a status';
+  if (reason === 'signalled') return `the engine stopped with ${failure.signal || 'a signal'}`;
+  const detail = String(failure.detail || output || '').trim().split('\n')[0].trim();
+  if (detail) return detail.replace(/[.]+$/, '');
+  return (reason || 'the engine failed').replace(/_/g, ' ');
+}
+
+function recordDispatchEngineHealth(result, failure, root) {
+  if (!result || !result.engine) return null;
+  const status = failure
+    ? engineFailureHealthStatus({
+      ...result,
+      status: 'errored',
+      reason: [result.reason, failure.reason].filter(Boolean).join('\n'),
+    })
+    : 'ready';
+  return status ? setEngineHealth(result.engine, status, root) : null;
+}
+
 function normalizeInstalledEngines(engines) {
   return [...new Set((engines || [])
     .map((entry) => (typeof entry === 'string' ? entry : entry && entry.name))
@@ -672,6 +704,7 @@ async function dispatchEntryWithRestaff({
 
   const first = await runOnce(engine);
   const deadEngine = detectDeadEngineDispatch(first);
+  recordDispatchEngineHealth(first, deadEngine, root);
   if (!deadEngine) return first;
   stampDispatchBrief(root, first.brief_id, 'fail', `restaffed from ${engine}: ${deadEngine.reason}`);
 
@@ -687,6 +720,7 @@ async function dispatchEntryWithRestaff({
 
   restaffState.used = true;
   const fallbackResult = await runOnce(fallback);
+  recordDispatchEngineHealth(fallbackResult, detectDeadEngineDispatch(fallbackResult), root);
   return {
     ...fallbackResult,
     restaffed: {
@@ -1066,6 +1100,7 @@ module.exports = {
   shipWithRetry,
   shipFailureDetail,
   get FLEET_CAPABLE() { return FLEET_CAPABLE; },
+  get DISPATCH_CAPABLE() { return DISPATCH_CAPABLE; },
   get runFleetFlight() { return runFleetFlight; },
   get focusedCheck() { return focusedCheck; },
   get dispatchCheck() { return dispatchCheck; },
@@ -1107,6 +1142,7 @@ module.exports = {
 // Engines that can edit a repo headlessly. atris-fast (ax) is a chat lane,
 // not a repo worker — it keeps owning normal mission ticks, not fleet builds.
 const FLEET_CAPABLE = ['claude', 'codex', 'cursor', 'devin', 'grok'];
+const DISPATCH_CAPABLE = [...FLEET_CAPABLE, 'fable'];
 
 let receiptSequence = 0;
 function nowStamp() {
@@ -2643,6 +2679,18 @@ async function runFleetFlight({
 // ---------------------------------------------------------------------------
 // T5 — one-command dispatch: `atris engine dispatch <task-id> --engine <name>`
 
+// A claim taken before the engine starts must not stay held if the flight
+// refuses or errors first. Release through the same task plane the claim used.
+function releaseUnstartedDispatchClaim(cli, { taskId, actor, detail }) {
+  const released = cli(['task', 'release', taskId, '--as', actor]);
+  const releasedOk = Boolean(released && released.status === 0);
+  const suffix = releasedOk
+    ? 'claim released, safe to retry'
+    : `claim release failed: ${String(released && (released.stderr || released.stdout) || 'unknown').trim().slice(0, 80)}`;
+  const base = String(detail || '').trim().slice(0, 200);
+  return { released: releasedOk, detail: base ? `${base}. ${suffix}` : suffix };
+}
+
 // The manual version of this loop took 6 Bash calls per task the night this
 // was written: claim, worktree start, prompt file, engine -p, verify, ship.
 // One or more explicit task ids build in parallel isolated worktrees on ONE
@@ -2678,8 +2726,8 @@ async function runDispatchFlight({
   scoutAsk = null,
 } = {}) {
   if (!engine) throw new Error('runDispatchFlight: engine is required');
-  if (!FLEET_CAPABLE.includes(engine)) {
-    throw new Error(`runDispatchFlight: engine "${engine}" cannot build headlessly (capable: ${FLEET_CAPABLE.join(', ')})`);
+  if (!DISPATCH_CAPABLE.includes(engine)) {
+    throw new Error(`runDispatchFlight: engine "${engine}" cannot build headlessly (capable: ${DISPATCH_CAPABLE.join(', ')})`);
   }
   const ids = [...new Set((taskIds || []).map((id) => String(id).trim()).filter(Boolean))];
   if (!ids.length) throw new Error('runDispatchFlight: at least one task id is required');
@@ -2745,51 +2793,71 @@ async function runDispatchFlight({
       log(`    x ${taskId} claim failed`);
       continue;
     }
-    let landingWorktreePath = '';
-    let remoteBoundary = null;
-    if (enforceRemoteBoundary) {
-      remoteBoundary = prepareReviewSandbox({ root, taskId, engine });
-    } else {
-      const started = cli(['worktree', 'start', '--agent', engine, '--task', `dispatch-${taskId.toLowerCase()}`, ...startBaseArgs]);
-      const wt = (started.stdout.match(/next: cd (.+)/) || [])[1];
-      if (!wt) {
-        flight.paused.push({ task: taskId, stage: 'worktree_start', detail: String(started.stderr || '').slice(0, 200) });
-        log(`    ✗ ${taskId} worktree start failed`);
+    try {
+      let landingWorktreePath = '';
+      let remoteBoundary = null;
+      if (enforceRemoteBoundary) {
+        remoteBoundary = prepareReviewSandbox({ root, taskId, engine });
+      } else {
+        const started = cli(['worktree', 'start', '--agent', engine, '--task', `dispatch-${taskId.toLowerCase()}`, ...startBaseArgs]);
+        const wt = (started.stdout.match(/next: cd (.+)/) || [])[1];
+        if (!wt) {
+          const released = releaseUnstartedDispatchClaim(cli, {
+            taskId,
+            actor: taskActor,
+            detail: String(started.stderr || '').slice(0, 200),
+          });
+          flight.paused.push({ task: taskId, stage: 'worktree_start', detail: released.detail });
+          log(`    ✗ ${taskId} worktree start failed`);
+          continue;
+        }
+        landingWorktreePath = wt.trim();
+      }
+      if (enforceRemoteBoundary && (!remoteBoundary || remoteBoundary.ok !== true)) {
+        const released = releaseUnstartedDispatchClaim(cli, {
+          taskId,
+          actor: taskActor,
+          detail: String(remoteBoundary && remoteBoundary.detail || 'could not prepare a sealed review sandbox').slice(-500),
+        });
+        flight.paused.push({
+          task: taskId,
+          stage: 'remote_quarantine',
+          detail: released.detail,
+          worktree: null,
+        });
+        log(`    paused ${taskId} because its sealed review sandbox could not be prepared`);
         continue;
       }
-      landingWorktreePath = wt.trim();
-    }
-    if (enforceRemoteBoundary && (!remoteBoundary || remoteBoundary.ok !== true)) {
-      flight.paused.push({
-        task: taskId,
-        stage: 'remote_quarantine',
-        detail: String(remoteBoundary && remoteBoundary.detail || 'could not prepare a sealed review sandbox').slice(-500),
-        worktree: null,
+      const worktreePath = enforceRemoteBoundary ? remoteBoundary.worktreePath : landingWorktreePath;
+      const startCommit = yolo ? readStartCommit({ worktreePath }) : '';
+      const basePrompt = promptOverride || buildFleetPrompt(task, { worktreePath, yolo });
+      const safetyPrompt = reviewOnly
+        ? `${basePrompt}\n\nSafety boundary: edit and test this checkout only. Do not push, merge, deploy, publish, send messages, change cloud state, install dependencies, or use credentials.`
+        : basePrompt;
+      const trustedPrompt = trustedVerifier
+        ? `${safetyPrompt}\n\nTrusted verifier (run it bare before reporting done): ${trustedVerifier}`
+        : promptOverride;
+      prepared.push({
+        task,
+        taskId,
+        worktreePath,
+        landingWorktreePath,
+        engine,
+        remoteBoundary,
+        remoteMasterBefore: remoteBoundary ? remoteBoundary.protectedMaster : '',
+        startCommit,
+        ...(trustedPrompt ? { prompt: trustedPrompt } : {}),
       });
-      log(`    paused ${taskId} because its sealed review sandbox could not be prepared`);
-      continue;
+      log(`    building ${taskId} in ${path.basename(worktreePath)}`);
+    } catch (err) {
+      const released = releaseUnstartedDispatchClaim(cli, {
+        taskId,
+        actor: taskActor,
+        detail: String(err && err.message || err).slice(0, 200),
+      });
+      flight.paused.push({ task: taskId, stage: 'prepare', detail: released.detail });
+      log(`    ✗ ${taskId} prepare failed`);
     }
-    const worktreePath = enforceRemoteBoundary ? remoteBoundary.worktreePath : landingWorktreePath;
-    const startCommit = yolo ? readStartCommit({ worktreePath }) : '';
-    const basePrompt = promptOverride || buildFleetPrompt(task, { worktreePath, yolo });
-    const safetyPrompt = reviewOnly
-      ? `${basePrompt}\n\nSafety boundary: edit and test this checkout only. Do not push, merge, deploy, publish, send messages, change cloud state, install dependencies, or use credentials.`
-      : basePrompt;
-    const trustedPrompt = trustedVerifier
-      ? `${safetyPrompt}\n\nTrusted verifier (run it bare before reporting done): ${trustedVerifier}`
-      : promptOverride;
-    prepared.push({
-      task,
-      taskId,
-      worktreePath,
-      landingWorktreePath,
-      engine,
-      remoteBoundary,
-      remoteMasterBefore: remoteBoundary ? remoteBoundary.protectedMaster : '',
-      startCommit,
-      ...(trustedPrompt ? { prompt: trustedPrompt } : {}),
-    });
-    log(`    building ${taskId} in ${path.basename(worktreePath)}`);
   }
 
   const dispatch = dispatcher || ((entry) => new Promise((resolve) => {
@@ -2813,6 +2881,10 @@ async function runDispatchFlight({
   }));
   const restaffState = { used: false };
 
+  if (engine === 'fable' && prepared.length) {
+    log(`  fable handoff started: receipt ${path.relative(root, receiptPath)}`);
+  }
+
   const results = await Promise.all(prepared.map((entry) => {
     const startedAtMs = Date.now();
     return dispatchEntryWithRestaff({
@@ -3328,6 +3400,12 @@ async function runDispatchFlight({
   flight.finished_at = new Date().toISOString();
   writeDispatchReceipt(flight, receiptPath, { ids, reviewOnly, enforceRemoteBoundary });
   log('');
+  if (engine === 'fable' && flight.paused.length) {
+    const paused = flight.paused[0];
+    const failed = results.find(({ entry }) => entry.taskId === paused.task);
+    const cause = plainDispatchFailureCause(failed && failed.result, paused);
+    log(`  fable handoff failed: ${cause}. receipt: ${path.relative(root, receiptPath)}`);
+  }
   const completedLabel = reviewOnly ? `${flight.ready.length} proof ready` : `${flight.landed.length} landed`;
   log(`  dispatch over: ${completedLabel}, ${flight.paused.length} paused - receipt: ${path.relative(root, flight.receipt)}`);
   log('');

package/lib/known-commands.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const knownCommands = ['init', 'log', 'logs', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '_start', 'plan', 'do', 'review', 'release',
+const knownCommands = ['init', 'log', 'logs', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '_start', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',

package/lib/task-db.js

@@ -369,8 +369,8 @@ function withTaskDisplayRefs(rows, refRows = rows) {
     const ids = sorted.map(row => row && row.id);
     sorted.forEach((row, index) => {
       refs.set(row.id, {
-        display_id: taskDisplayRef(row, index),
-        legacy_ref: shortestUniqueTaskRef(row.id, ids, 8),
+        display_id: row.display_id || taskDisplayRef(row, index),
+        legacy_ref: row.legacy_ref || shortestUniqueTaskRef(row.id, ids, 8),
       });
     });
   }