atris 3.15.36 → 3.15.38

package/README.md

@@ -106,7 +106,7 @@ AgentXP is the proof-backed game loop for getting better with agents. Start it
 inside any project folder:
 
 ```bash
-npm exec --yes --package github:atrislabs/atris#v3.15.28 -- atris play --as <player>
+npm exec --yes --package atris@latest -- atris play
 ```
 
 The first run creates a local starter mission if one does not exist. The loop is:
@@ -118,13 +118,13 @@ start -> proof -> accept -> login -> sync
 The player path:
 
 ```bash
-atris play --as justin
+atris play
 atris task claim <mission-ref> --as game-manager
 atris task ready <mission-ref> --as game-manager --proof "<artifact path + verifier result>"
 atris task accept <mission-ref> --as justin --proof "<human review>"
 atris xp card --local
 atris login
-atris xp sync --local --as justin
+atris xp sync --local
 ```
 
 The manager path:

package/ax

@@ -107,6 +107,54 @@ function formatUsage() {
   ].join('\n');
 }
 
+function timestampForFile(date = new Date()) {
+  return date.toISOString().replace(/[:.]/g, '-');
+}
+
+function stripAnsi(value) {
+  return String(value || '').replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
+}
+
+function createRunLogger({ cwd = process.cwd(), mode = 'pro', kind = 'play', output = process.stdout } = {}) {
+  if (process.env.AX_AUTO_LOG === '0') return null;
+  if (output !== process.stdout && output !== process.stderr && !output.isTTY) return null;
+
+  const baseDir = fs.existsSync(path.join(cwd, 'atris'))
+    ? path.join(cwd, 'atris', 'runs')
+    : path.join(os.homedir(), '.atris', 'runs');
+  fs.mkdirSync(baseDir, { recursive: true });
+  const logPath = path.join(baseDir, `ax-${kind}-${timestampForFile()}.log`);
+  fs.appendFileSync(logPath, [
+    `command: ${process.argv.join(' ')}`,
+    `cwd: ${cwd}`,
+    `mode: ${mode}`,
+    `started_at: ${new Date().toISOString()}`,
+    '',
+  ].join('\n'));
+
+  const writeLog = (chunk) => {
+    fs.appendFileSync(logPath, stripAnsi(chunk));
+  };
+  const teeOutput = {
+    isTTY: Boolean(output && output.isTTY),
+    write(chunk) {
+      const text = String(chunk || '');
+      if (output && typeof output.write === 'function') output.write(text);
+      writeLog(text);
+      return true;
+    }
+  };
+
+  return {
+    path: logPath,
+    output: teeOutput,
+    write: writeLog,
+    close(exitCode = 0) {
+      writeLog(`\nexit_code: ${exitCode}\nfinished_at: ${new Date().toISOString()}\n`);
+    }
+  };
+}
+
 function backendBaseUrl() {
   return (process.env.AX_BACKEND_URL
     || process.env.OBELISK_LOCAL_ATRIS2_BACKEND_URL
@@ -339,9 +387,16 @@ function workspaceIntent(message) {
   return /\b(files?|folders?|repo|workspace|project|directory|tree|read|open|inspect|search|grep|find|locate|where|edit|write|change|modify|patch|fix|test|tests?|build|src|source|code|diff|git|backend|frontend|atris task|atris xp|xp game|career xp|agentxp|todo|map)\b/i.test(message || '');
 }
 
+function githubWorkspaceIntent(message) {
+  const text = String(message || '');
+  if (!/\bgithub\b/i.test(text)) return false;
+  return /\b(push|commit|commits?|branch|branches|checkout|merge|rebase|tag|release|pr|pull request|pull-request|repo change|code change|small change)\b/i.test(text);
+}
+
 function resolveRoute(message, options = {}) {
   if (options.route === 'local' || options.forceLocal) return 'local';
   if (options.route === 'cloud' || options.forceCloud) return 'cloud';
+  if (githubWorkspaceIntent(message)) return 'local';
   if (mentionsConnector(message) && !workspaceIntent(message)) return 'cloud';
   return 'local';
 }
@@ -370,6 +425,112 @@ function paint(text, codes, options = {}) {
   return `${codes.join('')}${text}${ANSI.reset}`;
 }
 
+function renderTerminalMarkdown(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(/^#{1,6}\s+(.+)$/gm, (_, title) => paint(title, [ANSI.bold], options));
+  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 resetMarkdownState(state) {
+  state.markdownMode = 'normal';
+  state.markdownBuffer = '';
+  state.markdownCarry = '';
+}
+
+function ensureMarkdownState(state) {
+  if (!state.markdownMode) state.markdownMode = 'normal';
+  if (typeof state.markdownBuffer !== 'string') state.markdownBuffer = '';
+  if (typeof state.markdownCarry !== 'string') state.markdownCarry = '';
+}
+
+function renderStreamingMarkdown(state, text, options = {}) {
+  ensureMarkdownState(state);
+  const input = `${state.markdownCarry || ''}${String(text || '')}`;
+  state.markdownCarry = '';
+  let out = '';
+
+  for (let i = 0; i < input.length;) {
+    const char = input[i];
+    const next = input[i + 1];
+
+    if (state.markdownMode === 'normal') {
+      if (char === '*' && next === undefined) {
+        state.markdownCarry = '*';
+        break;
+      }
+      if (char === '*' && next === '*') {
+        state.markdownMode = 'bold';
+        state.markdownBuffer = '';
+        i += 2;
+        continue;
+      }
+      if (char === '`') {
+        state.markdownMode = 'code';
+        state.markdownBuffer = '';
+        i += 1;
+        continue;
+      }
+      out += char;
+      i += 1;
+      continue;
+    }
+
+    if (state.markdownMode === 'bold') {
+      if (char === '*' && next === undefined) {
+        state.markdownCarry = '*';
+        break;
+      }
+      if (char === '*' && next === '*') {
+        out += paint(state.markdownBuffer, [ANSI.bold], options);
+        state.markdownMode = 'normal';
+        state.markdownBuffer = '';
+        i += 2;
+        continue;
+      }
+      state.markdownBuffer += char;
+      i += 1;
+      continue;
+    }
+
+    if (state.markdownMode === 'code') {
+      if (char === '`') {
+        out += paint(state.markdownBuffer, [ANSI.accent], options);
+        state.markdownMode = 'normal';
+        state.markdownBuffer = '';
+        i += 1;
+        continue;
+      }
+      state.markdownBuffer += char;
+      i += 1;
+      continue;
+    }
+  }
+
+  return out;
+}
+
+function flushStreamingMarkdown(state, output) {
+  ensureMarkdownState(state);
+  let 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);
+  }
+  resetMarkdownState(state);
+  if (out) output.write(out);
+  return out;
+}
+
 function truncateMiddle(value, limit = 120) {
   const text = String(value || '');
   if (text.length <= limit) return text;
@@ -523,6 +684,7 @@ function clearRetriedText(state) {
   state.wroteText = false;
   state.lastChar = '\n';
   state.inAuxBlock = false;
+  resetMarkdownState(state);
 }
 
 function stopProgress(state) {
@@ -532,13 +694,20 @@ function stopProgress(state) {
 }
 
 function flushPendingText(state, output) {
-  if (!state.pendingText) return;
+  const hasMarkdownRemainder = output && output.isTTY && (
+    state.markdownCarry
+    || state.markdownBuffer
+    || (state.markdownMode && state.markdownMode !== 'normal')
+  );
+  if (!state.pendingText && !hasMarkdownRemainder) return;
   stopProgress(state);
   if (state.inAuxBlock && state.lastChar === '\n') output.write('\n');
-  output.write(state.pendingText);
+  if (state.pendingText) output.write(output && output.isTTY ? renderTerminalMarkdown(state.pendingText, output) : state.pendingText);
+  const flushedMarkdown = hasMarkdownRemainder ? flushStreamingMarkdown(state, output) : '';
   state.wroteText = true;
   state.wroteActivity = true;
-  state.lastChar = state.pendingText.slice(-1);
+  const written = `${state.pendingText || ''}${flushedMarkdown || ''}`;
+  state.lastChar = written.slice(-1);
   state.pendingText = '';
   state.inAuxBlock = false;
 }
@@ -547,10 +716,11 @@ function writeStreamingText(state, output, content) {
   if (!content) return;
   stopProgress(state);
   if (state.inAuxBlock && state.lastChar === '\n') output.write('\n');
-  output.write(content);
+  const rendered = renderStreamingMarkdown(state, content, output);
+  if (rendered) output.write(rendered);
   state.wroteText = true;
   state.wroteActivity = true;
-  state.lastChar = String(content).slice(-1);
+  state.lastChar = String(rendered || content).slice(-1);
   state.inAuxBlock = false;
 }
 
@@ -691,7 +861,10 @@ async function postTurn(message, options = {}) {
     durationMs: 0,
     lastChar: '\n',
     progress: null,
-    inAuxBlock: false
+    inAuxBlock: false,
+    markdownMode: 'normal',
+    markdownBuffer: '',
+    markdownCarry: ''
   };
 
   return new Promise((resolve, reject) => {
@@ -789,16 +962,20 @@ async function chat(options = {}) {
   const mode = options.mode === 'fast' ? 'fast' : 'pro';
   const cwd = options.cwd || process.cwd();
   const input = options.input || process.stdin;
-  const output = options.output || process.stdout;
+  const baseOutput = options.output || process.stdout;
+  const logger = createRunLogger({ cwd, mode, kind: 'play', output: baseOutput });
+  const output = logger ? logger.output : baseOutput;
   const history = [];
 
   output.write(`${formatHeader({ mode, cwd, chat: true })}\n\n`);
+  if (logger) output.write(`${formatAuxRow('log', formatPathSubject(logger.path, output), output)}\n\n`);
 
   const runLine = async (line) => {
     const trimmed = String(line || '').trim();
     if (!trimmed) return false;
     if (EXIT_WORDS.has(trimmed.toLowerCase())) return true;
 
+    if (logger) logger.write(`${formatPrompt(mode)}${trimmed}\n`);
     output.write('\n');
     const result = await postTurn(trimmed, { mode, cwd, history, output });
     if (result.output && !result.output.endsWith('\n')) output.write('\n');
@@ -813,10 +990,11 @@ async function chat(options = {}) {
     for await (const line of rl) {
       if (await runLine(line)) break;
     }
+    if (logger) logger.close(0);
     return;
   }
 
-  const rl = readline.createInterface({ input, output });
+  const rl = readline.createInterface({ input, output: baseOutput });
   const ask = () => new Promise(resolve => rl.question(formatPrompt(mode), resolve));
   while (true) {
     const line = await ask();
@@ -825,6 +1003,7 @@ async function chat(options = {}) {
       break;
     }
   }
+  if (logger) logger.close(0);
 }
 
 function printBackendHint() {
@@ -1061,6 +1240,7 @@ module.exports = {
   buildConnectionContext,
   buildRunProfile,
   chat,
+  createRunLogger,
   createProgressReporter,
   formatDoneLine,
   formatDuration,
@@ -1076,6 +1256,8 @@ module.exports = {
   modelForMode,
   parseSseBlock,
   postTurn,
+  renderStreamingMarkdown,
+  renderTerminalMarkdown,
   resolveRoute,
   runBenchmark,
   summarizeToolInput,

package/commands/gm.js

@@ -267,8 +267,8 @@ function compactTask(task) {
 function globalSyncCommands(player) {
   return [
     'atris login',
-    `atris xp sync --local --as ${player}`,
-    `atris xp sync --local --as ${player} --token <owner-provided-token>`,
+    'atris xp sync --local',
+    'atris xp sync --local --token <owner-provided-token>',
   ];
 }
 

package/commands/mission.js

@@ -747,9 +747,17 @@ function secondsUntilMissionDue(mission, now = new Date()) {
   return Math.max(0, Math.ceil((dueAt - now.getTime()) / 1000));
 }
 
+function missionIsRunnable(mission) {
+  return mission && !TERMINAL_STATUSES.has(mission.status) && mission.status !== 'paused';
+}
+
+function missionSortTime(mission) {
+  return Date.parse(mission?.updated_at || mission?.created_at || '') || 0;
+}
+
 function selectDueMission(root = process.cwd(), now = new Date()) {
   const candidates = listMissions(root)
-    .filter((mission) => !TERMINAL_STATUSES.has(mission.status))
+    .filter(missionIsRunnable)
     .filter((mission) => mission.verifier)
     .filter((mission) => mission.always_on || !missionVerifierPassed(mission))
     .filter((mission) => missionDueAt(mission, now));
@@ -763,11 +771,8 @@ function selectDueMission(root = process.cwd(), now = new Date()) {
 }
 
 function selectCodexGoalMission(root = process.cwd(), now = new Date()) {
-  const due = selectDueMission(root, now);
-  if (due) return { mission: due, reason: 'due' };
-
   const candidates = listMissions(root)
-    .filter((mission) => !TERMINAL_STATUSES.has(mission.status));
+    .filter(missionIsRunnable);
 
   candidates.sort((a, b) => {
     const aCaller = runnerUsesCallerSession(a.runner) ? 1 : 0;
@@ -778,14 +783,15 @@ function selectCodexGoalMission(root = process.cwd(), now = new Date()) {
     const bVerifier = b.verifier ? 1 : 0;
     if (aVerifier !== bVerifier) return bVerifier - aVerifier;
 
-    const aTime = Date.parse(a.updated_at || a.created_at || '') || 0;
-    const bTime = Date.parse(b.updated_at || b.created_at || '') || 0;
+    const aTime = missionSortTime(a);
+    const bTime = missionSortTime(b);
     return bTime - aTime;
   });
 
   const mission = candidates[0] || null;
   if (!mission) return null;
-  return { mission, reason: 'active' };
+  const due = mission.verifier && missionDueAt(mission, now);
+  return { mission, reason: due ? 'due' : 'active' };
 }
 
 function codexGoalObjective(mission) {

package/commands/play.js

@@ -258,8 +258,8 @@ function starterMissionPrompt(player) {
 function globalSyncCommands(player) {
   return [
     'atris login',
-    `atris xp sync --local --as ${player}`,
-    `atris xp sync --local --as ${player} --token <owner-provided-token>`,
+    'atris xp sync --local',
+    'atris xp sync --local --token <owner-provided-token>',
   ];
 }
 

package/commands/pull.js

@@ -933,12 +933,12 @@ async function pullBusiness(slug) {
           const relativePath = path.relative(path.dirname(symlinkPath), fullPath);
 
           // Business skills override init skills (remove existing symlink if present)
-          if (fs.existsSync(symlinkPath)) {
-            try {
-              const stat = fs.lstatSync(symlinkPath);
-              if (stat.isSymbolicLink()) fs.unlinkSync(symlinkPath);
-              else continue; // Don't overwrite real directories
-            } catch { continue; }
+          try {
+            const stat = fs.lstatSync(symlinkPath);
+            if (stat.isSymbolicLink()) fs.unlinkSync(symlinkPath);
+            else continue; // Don't overwrite real directories
+          } catch (err) {
+            if (err && err.code !== 'ENOENT') continue;
           }
           try {
             fs.symlinkSync(relativePath, symlinkPath);
@@ -959,7 +959,11 @@ async function pullBusiness(slug) {
     // Count wired skills
     const wiredSkills = fs.readdirSync(claudeSkillsDir).filter(f => {
       const p = path.join(claudeSkillsDir, f);
-      return fs.statSync(p).isDirectory();
+      try {
+        return fs.statSync(p).isDirectory();
+      } catch {
+        return false;
+      }
     });
     if (wiredSkills.length > 0) {
       console.log(`  Wired ${wiredSkills.length} skills → .claude/skills/`);

package/commands/task.js

@@ -795,6 +795,15 @@ function taskStatusSummary(projection, { history = false } = {}) {
     done: tasks.filter(task => taskColumn(task) === 'done'),
   };
   const active = [...columns.do, ...columns.review, ...columns.plan];
+  const reviewNeedingAgentAction = columns.review.filter(task => {
+    const handoff = reviewHandoffForTask(task);
+    return handoff && handoff.next_action === 'agent_review_again';
+  });
+  const reviewAgentCertified = columns.review.filter(task => {
+    const handoff = reviewHandoffForTask(task);
+    return handoff && handoff.next_action === 'continue_work';
+  }).length;
+  const blocked = columns.review.filter(task => taskColumn(task) === 'blocked').length;
   const lastUpdated = tasks.reduce((max, task) => Math.max(max, Number(task.updated_at || 0)), 0);
   const swarloFeed = history ? tasks
     .flatMap(task => (task.events || []).map(event => ({
@@ -830,14 +839,17 @@ function taskStatusSummary(projection, { history = false } = {}) {
     goals: projection.goals || { source_path: null, items: [] },
     counts: {
       total: fullTaskCount,
-      active: columns.plan.length + columns.do.length + columns.review.length,
+      active: columns.plan.length + columns.do.length + reviewNeedingAgentAction.length,
       backlog: columns.backlog.length,
       plan: columns.plan.length,
       do: columns.do.length,
       review: columns.review.length,
+      review_blocking: reviewNeedingAgentAction.length,
+      review_certified: reviewAgentCertified,
+      blocked,
       done: tasks.filter(task => task.status === 'done' || (task.status === 'failed' && taskHasReview(task))).length + hiddenDoneCount,
     },
-    current: compactTaskForStatus(columns.do[0] || columns.review[0] || null),
+    current: compactTaskForStatus(columns.do[0] || reviewNeedingAgentAction[0] || null),
     next: compactTaskForStatus(columns.plan[0] || null),
     needs_review: columns.review.slice(0, 5).map(compactTaskForStatus),
     streams: (projection.streams || []).slice(0, 8).map(stream => ({
@@ -1299,25 +1311,6 @@ function cmdNext(args) {
   const reviewTasks = (reviewProjection.projection.tasks || [])
     .map(compactTaskForStatus)
     .filter(task => task && task.review && task.review.handoff);
-  const secondReviewTask = reviewTasks.find(task => task.review.handoff.next_action === 'agent_review_again');
-  if (secondReviewTask) {
-    const handoff = secondReviewTask.review.handoff;
-    if (wantsJson(args)) {
-      printJson({
-        ok: true,
-        action: handoff.next_action,
-        task_id: secondReviewTask.id,
-        owner: String(owner),
-        projection_path: reviewProjection.outPath,
-        handoff,
-        review_task: secondReviewTask,
-      });
-      return;
-    }
-    console.log(`${taskRef(secondReviewTask)} needs one more agent review before continuation.`);
-    console.log('Review this task again before claiming new work.');
-    return;
-  }
   const open = taskDb.listTasks(db, {
     workspaceRoot: taskDb.workspaceRoot(),
     status: 'open',
@@ -1325,7 +1318,8 @@ function cmdNext(args) {
   });
   if (!open.length) {
     const { projection, outPath } = reviewProjection;
-    const reviewTask = reviewTasks.find(task => task.review.handoff.next_action === 'continue_work');
+    const reviewTask = reviewTasks.find(task => task.review.handoff.next_action === 'agent_review_again')
+      || reviewTasks.find(task => task.review.handoff.next_action === 'continue_work');
     if (reviewTask) {
       const handoff = reviewTask.review.handoff;
       if (wantsJson(args)) {
@@ -2013,11 +2007,34 @@ function extractTodoSectionMarkdown(content, sectionName) {
   return match ? match[1].trimEnd() : null;
 }
 
+function normalizeRenderedTaskRef(value) {
+  return String(value || '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+}
+
+function renderedTaskRefSet(taskDb, rows, refRows) {
+  const byId = new Map();
+  for (const row of [...(Array.isArray(rows) ? rows : []), ...(Array.isArray(refRows) ? refRows : [])]) {
+    if (row && row.id && !byId.has(row.id)) byId.set(row.id, row);
+  }
+  const displayRows = taskDb.withTaskDisplayRefs([...byId.values()]);
+  const refs = new Set();
+  for (const row of displayRows) {
+    for (const value of [row.id, row.display_id, row.legacy_ref]) {
+      const ref = normalizeRenderedTaskRef(value);
+      if (ref) refs.add(ref);
+    }
+  }
+  return refs;
+}
+
 function markdownRowsForRender(taskDb, existingTodoPath, rows, refRows) {
   if (!existingTodoPath || !fs.existsSync(existingTodoPath)) return [];
   const { parseTodoFile } = require('../lib/todo-fallback');
+  const existingTodo = fs.readFileSync(existingTodoPath, 'utf8');
+  const generatedTodo = existingTodo.includes('Regenerated from durable Atris task state');
   const parsed = parseTodoFile(existingTodoPath);
   const ws = taskDb.workspaceRoot();
+  const existingRefs = renderedTaskRefSet(taskDb, rows, refRows);
   const existingSourceKeys = new Set(
     (Array.isArray(refRows) ? refRows : [])
       .map(row => row && row.source_key)
@@ -2041,7 +2058,13 @@ function markdownRowsForRender(taskDb, existingTodoPath, rows, refRows) {
       if (!task.title) continue;
       const sk = taskDb.sourceKey(existingTodoPath, task.title);
       const normalizedTitle = taskDb.normalizeTitle(task.title);
-      if ((sk && existingSourceKeys.has(sk)) || existingTitles.has(normalizedTitle)) continue;
+      const renderedRef = normalizeRenderedTaskRef(task.id);
+      if (
+        (renderedRef && existingRefs.has(renderedRef)) ||
+        (sk && existingSourceKeys.has(sk)) ||
+        existingTitles.has(normalizedTitle) ||
+        generatedTodo
+      ) continue;
       out.push({
         id: `markdown:${status}:${task.id || index}:${sk ? sk.slice(0, 10) : index}`,
         title: task.title,

package/commands/xp.js

@@ -1,4 +1,4 @@
-const { ensureValidCredentials } = require('../utils/auth');
+const { ensureValidCredentials, getSessionProfile, loadCredentials, profileNameFromEmail } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 const fs = require('fs');
 const os = require('os');
@@ -1740,18 +1740,54 @@ function projectionWorkspaceSummaries(projection) {
   }];
 }
 
+function credentialHandle(credentials) {
+  return slugify(
+    credentials?.username
+    || credentials?.handle
+    || credentials?.display_name
+    || credentials?.name
+    || profileNameFromEmail(credentials?.email)
+    || credentials?.user_id
+  );
+}
+
+function activeAccountHandle() {
+  const envPlayer = slugify(process.env.ATRIS_PLAYER || process.env.ATRIS_USERNAME);
+  if (envPlayer) return envPlayer;
+
+  const envProfile = slugify(process.env.ATRIS_PROFILE);
+  if (envProfile) return envProfile;
+
+  try {
+    const sessionProfile = slugify(getSessionProfile());
+    if (sessionProfile) return sessionProfile;
+  } catch {}
+
+  try {
+    const credentials = loadCredentials();
+    const handle = credentialHandle(credentials);
+    if (handle) return handle;
+  } catch {}
+
+  return null;
+}
+
+function projectionHandle(projection) {
+  return slugify(
+    projection?.operator
+    || projection?.latest_accepted_proof?.actor
+    || projection?.latest_accepted_proof?.assignee
+    || projection?.latest_accepted_proof?.assigned_to
+  );
+}
+
 function syncPlayer(args, projection) {
   const explicit = readFirstFlag(args, ['--as', '--player', '--user', '--operator'], null);
-  return slugify(
-    explicit
-    || process.env.ATRIS_PLAYER
-    || process.env.ATRIS_USERNAME
-    || process.env.ATRIS_PROFILE
-    || process.env.USER
-    || os.userInfo().username
-    || projection?.operator
-    || 'player'
-  ) || 'player';
+  return slugify(explicit)
+    || activeAccountHandle()
+    || projectionHandle(projection)
+    || slugify(process.env.USER || os.userInfo().username)
+    || 'player';
 }
 
 function buildAgentXpSyncPacket(args = []) {
@@ -1899,7 +1935,7 @@ function renderSync(payload) {
   console.log(`Player ${payload.player || entry.username || 'player'} | AgentXP ${formatNumber(entry.agent_xp)} | receipts ${formatNumber(entry.verified_receipts)}`);
   if (payload.dry_run) {
     console.log(`Packet ${payload.packet?.packet_hash || 'unhashed'} ready; no network upload ran.`);
-    console.log(`Run atris login, then atris xp sync --local --as ${payload.player || entry.username || '<player>'} to publish to the hosted leaderboard.`);
+    console.log('Run atris login, then atris xp sync --local to publish to the hosted leaderboard.');
     console.log('Guided demos can pass --token <owner-provided-token>.');
     console.log(`Leaderboard: ${AGENTXP_LEADERBOARD_URL}`);
     return;

package/lib/todo-fallback.js

@@ -21,7 +21,7 @@ function parseTodoFile(todoPath) {
 }
 
 function tagsFromText(text) {
-  const allTags = [...String(text || '').matchAll(/\[(\w+)\]/g)].map(m => m[1]);
+  const allTags = [...String(text || '').matchAll(/\[([\w-]+)\]/g)].map(m => m[1]);
   return {
     allTags,
     tag: allTags.includes('endgame') ? 'endgame' : (allTags[0] || null),
@@ -30,7 +30,7 @@ function tagsFromText(text) {
 
 function cleanTaskTitle(text) {
   const raw = String(text || '').trim();
-  const withoutTags = raw.replace(/\s*\[\w+\]/g, '').trim();
+  const withoutTags = raw.replace(/\s*\[[\w-]+\]/g, '').trim();
   const bold = withoutTags.match(/^\*\*(.+?)\*\*\s*(?:[—-]\s*)?(.*)$/);
   if (!bold) return withoutTags;
   return [bold[1], bold[2]].filter(Boolean).join(' — ').trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.15.36",
+  "version": "3.15.38",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",