atris 3.30.8 → 3.31.0

package/commands/codex-goal.js

@@ -32,7 +32,50 @@ function sqlString(value) {
 }
 
 function resolveStatePath(args = []) {
-  return path.resolve(expandHome(readFlag(args, '--state', process.env.CODEX_STATE_DB || path.join(os.homedir(), '.codex', 'state_5.sqlite'))));
+  const explicit = readFlag(args, '--state', process.env.CODEX_STATE_DB || '');
+  if (explicit) return path.resolve(expandHome(explicit));
+  // Codex moved native goals into ~/.codex/goals_1.sqlite; older builds kept them in state_5.sqlite.
+  // Prefer the live goals DB so the bridge sees real goal activity, fall back to the legacy state DB.
+  const goalsDb = path.join(os.homedir(), '.codex', 'goals_1.sqlite');
+  const legacyDb = path.join(os.homedir(), '.codex', 'state_5.sqlite');
+  return path.resolve(fs.existsSync(goalsDb) ? goalsDb : legacyDb);
+}
+
+// Thread metadata (cwd/title) stayed in state_5.sqlite even after goals moved to goals_1.sqlite.
+function resolveThreadsPath(args = []) {
+  const explicit = readFlag(args, '--threads-db', process.env.CODEX_THREADS_DB || '');
+  if (explicit) return path.resolve(expandHome(explicit));
+  const legacyDb = path.join(os.homedir(), '.codex', 'state_5.sqlite');
+  return fs.existsSync(legacyDb) ? path.resolve(legacyDb) : '';
+}
+
+function tableExists(dbPath, table) {
+  if (!dbPath || !fs.existsSync(dbPath)) return false;
+  try {
+    const rows = runSqliteJson(dbPath, `SELECT name FROM sqlite_master WHERE type='table' AND name=${sqlString(table)} LIMIT 1;`);
+    return rows.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// Goals live in goals_1.sqlite (no `threads` table); thread metadata lives in state_5.sqlite.
+// Legacy single-file layouts (and test fixtures) keep both in one DB. Resolve which join to use.
+function goalQueryContext(args = []) {
+  const goalsDb = resolveStatePath(args);
+  if (tableExists(goalsDb, 'threads')) {
+    return { goalsDb, threadsTable: 'threads', prefix: '' };
+  }
+  const threadsDb = resolveThreadsPath(args);
+  if (threadsDb && threadsDb !== goalsDb && tableExists(threadsDb, 'threads')) {
+    return { goalsDb, threadsTable: 'tdb.threads', prefix: `ATTACH ${sqlString(threadsDb)} AS tdb;\n` };
+  }
+  return { goalsDb, threadsTable: null, prefix: '' };
+}
+
+function runGoalQuery(args, buildSql) {
+  const ctx = goalQueryContext(args);
+  return runSqliteJson(ctx.goalsDb, ctx.prefix + buildSql(ctx.threadsTable));
 }
 
 function defaultRunsDir(args = []) {
@@ -81,7 +124,11 @@ function ensureStateDb(dbPath) {
   }
 }
 
-function selectGoalSql(whereClause, limit = 10) {
+function selectGoalSql(whereClause, limit = 10, threadsTable = 'threads') {
+  const join = threadsTable ? `LEFT JOIN ${threadsTable} t ON t.id = tg.thread_id` : '';
+  const cwd = threadsTable ? 't.cwd' : 'NULL';
+  const title = threadsTable ? 't.title' : 'NULL';
+  const threadUpdated = threadsTable ? 't.updated_at_ms' : 'NULL';
   return `
 SELECT
   tg.thread_id,
@@ -93,41 +140,43 @@ SELECT
   tg.time_used_seconds,
   tg.created_at_ms,
   tg.updated_at_ms,
-  t.cwd AS thread_cwd,
-  t.title AS thread_title,
-  t.updated_at_ms AS thread_updated_at_ms
+  ${cwd} AS thread_cwd,
+  ${title} AS thread_title,
+  ${threadUpdated} AS thread_updated_at_ms
 FROM thread_goals tg
-LEFT JOIN threads t ON t.id = tg.thread_id
+${join}
 ${whereClause}
-ORDER BY COALESCE(t.updated_at_ms, tg.updated_at_ms) DESC
+ORDER BY COALESCE(${threadUpdated}, tg.updated_at_ms) DESC
 LIMIT ${Number(limit) || 10}
 `;
 }
 
-function readGoalByThread(dbPath, threadId) {
-  const rows = runSqliteJson(dbPath, selectGoalSql(`WHERE tg.thread_id = ${sqlString(threadId)}`, 1));
+function readGoalByThread(args, threadId) {
+  const rows = runGoalQuery(args, (tt) => selectGoalSql(`WHERE tg.thread_id = ${sqlString(threadId)}`, 1, tt));
   return rows[0] || null;
 }
 
-function readLatestGoalForCwd(dbPath, cwd) {
+function readLatestGoalForCwd(args, cwd) {
+  const ctx = goalQueryContext(args);
+  if (!ctx.threadsTable) return null; // cannot cwd-match without thread metadata
   const realCwd = fs.realpathSync.native ? fs.realpathSync.native(cwd) : fs.realpathSync(cwd);
   const pwd = process.env.PWD || '';
   const pwdReal = pwd && fs.existsSync(pwd) ? (fs.realpathSync.native ? fs.realpathSync.native(pwd) : fs.realpathSync(pwd)) : '';
   const candidates = [...new Set([cwd, realCwd, pwdReal === realCwd ? pwd : ''].filter(Boolean))];
-  const rows = runSqliteJson(dbPath, selectGoalSql(`WHERE t.cwd IN (${candidates.map(sqlString).join(', ')})`, 1));
+  const rows = runSqliteJson(ctx.goalsDb, ctx.prefix + selectGoalSql(`WHERE t.cwd IN (${candidates.map(sqlString).join(', ')})`, 1, ctx.threadsTable));
   return rows[0] || null;
 }
 
-function readRecentGoals(dbPath, limit = 10) {
-  return runSqliteJson(dbPath, selectGoalSql('', limit));
+function readRecentGoals(args, limit = 10) {
+  return runGoalQuery(args, (tt) => selectGoalSql('', limit, tt));
 }
 
-function resolveThreadGoal(dbPath, args) {
+function resolveThreadGoal(args) {
   const explicitThread = readFlag(args, '--thread', '');
-  if (explicitThread) return readGoalByThread(dbPath, explicitThread);
-  if (hasFlag(args, '--latest')) return readLatestGoalForCwd(dbPath, process.cwd());
+  if (explicitThread) return readGoalByThread(args, explicitThread);
+  if (hasFlag(args, '--latest')) return readLatestGoalForCwd(args, process.cwd());
   const envThread = process.env.CODEX_THREAD_ID || '';
-  if (envThread) return readGoalByThread(dbPath, envThread);
+  if (envThread) return readGoalByThread(args, envThread);
   return null;
 }
 
@@ -163,7 +212,7 @@ function statusCommand(args) {
   const dbPath = resolveStatePath(args);
   ensureStateDb(dbPath);
 
-  const goal = resolveThreadGoal(dbPath, args);
+  const goal = resolveThreadGoal(args);
   if (goal) {
     const payload = { ok: true, schema: SCHEMA, action: 'status', state_path: dbPath, goal };
     printJsonOrText(payload, [
@@ -176,7 +225,7 @@ function statusCommand(args) {
   }
 
   const limit = Math.max(1, Math.min(50, Number(readFlag(args, '--limit', '10')) || 10));
-  const goals = readRecentGoals(dbPath, limit);
+  const goals = readRecentGoals(args, limit);
   const payload = { ok: true, schema: SCHEMA, action: 'status', state_path: dbPath, goals };
   printJsonOrText(payload, [
     `Codex goals: ${goals.length} recent`,
@@ -192,7 +241,7 @@ function resetCommand(args) {
   ensureStateDb(dbPath);
 
   const startedAt = new Date().toISOString();
-  const goal = resolveThreadGoal(dbPath, args);
+  const goal = resolveThreadGoal(args);
   if (!goal) {
     throw new Error('No Codex goal found. Pass --thread <thread-id> or --latest.');
   }
@@ -238,7 +287,7 @@ SELECT changes() AS deleted;
 COMMIT;
 `, { readonly: false });
   const deleted = Number(rows[0]?.deleted || 0);
-  const remaining = readGoalByThread(dbPath, goal.thread_id);
+  const remaining = readGoalByThread(args, goal.thread_id);
   const ok = deleted === 1 && !remaining;
   const payload = writeReceipt(outDir, {
     ok,
@@ -277,7 +326,8 @@ function usage() {
     `  atris codex-goal reset --thread <id> ${CONFIRM_RESET_FLAG}`,
     '',
     'Flags:',
-    '  --state <path>      Codex state DB (default ~/.codex/state_5.sqlite)',
+    '  --state <path>      Codex goals DB (default ~/.codex/goals_1.sqlite, falls back to state_5.sqlite)',
+    '  --threads-db <path> Codex thread metadata DB for cwd/title (default ~/.codex/state_5.sqlite)',
     '  --latest           Use the latest Codex goal whose thread cwd matches the current directory',
     '  --out-dir <path>   Receipt/backup directory (default .atris/runs)',
     '',

package/commands/computer.js

@@ -1635,6 +1635,41 @@ async function resolveBusinessContextBySlug(token, slug, options = {}) {
   return null;
 }
 
+function shortcutBusinessLabel(slug, fallbackName) {
+  if (normalizeBusinessSlug(slug) === RECRUITING_BUSINESS_SLUG) return 'Atris Labs';
+  return fallbackName || slug;
+}
+
+async function resolveSingleBusinessShortcutFallback(token, slug) {
+  const wantedSlug = normalizeBusinessSlug(slug);
+  if (wantedSlug !== RECRUITING_BUSINESS_SLUG) return null;
+
+  const list = await apiRequestJson('/business/', { method: 'GET', token });
+  const rows = list.ok && Array.isArray(list.data)
+    ? list.data.filter((business) => business && business.id)
+    : [];
+  if (rows.length !== 1) return null;
+
+  const match = rows[0];
+  const businesses = loadBusinesses();
+  const businessName = shortcutBusinessLabel(wantedSlug, match.name || match.slug);
+  businesses[wantedSlug] = {
+    business_id: match.id,
+    workspace_id: match.workspace_id,
+    name: businessName,
+    slug: wantedSlug,
+    cloud_slug: match.slug || null,
+    added_at: new Date().toISOString(),
+  };
+  saveBusinesses(businesses);
+  return {
+    slug: wantedSlug,
+    businessId: match.id,
+    workspaceId: match.workspace_id,
+    businessName,
+  };
+}
+
 async function resolveComputerCommandContext(token, options = {}) {
   if (options.businessSlug || options.workspaceId) {
     const ctx = options.businessSlug
@@ -1660,7 +1695,10 @@ async function resolveTypedBusinessComputerContext(token, options = {}, defaults
     return resolveComputerCommandContext(token, { ...options, businessSlug });
   }
 
-  const ctx = await resolveBusinessContextBySlug(token, businessSlug, { preferCache: true });
+  let ctx = await resolveBusinessContextBySlug(token, businessSlug, { preferCache: true });
+  if (!ctx?.businessId && (options.allowCanonicalShortcutFallback || defaults.allowCanonicalShortcutFallback)) {
+    ctx = await resolveSingleBusinessShortcutFallback(token, businessSlug);
+  }
   if (!ctx?.businessId) return null;
   const workspaces = await listBusinessWorkspaces(token, ctx);
   const workspace = resolveWorkspaceByComputerType(workspaces, computerType);
@@ -1705,7 +1743,7 @@ async function resolveWorkspaceSelector(token, ctx, input) {
   return workspace?.id || selector;
 }
 
-async function resolveBusinessOwnerForCreate(token, businessSlug = null) {
+async function resolveBusinessOwnerForCreate(token, businessSlug = null, options = {}) {
   const wantedSlug = businessSlug ? String(businessSlug).trim() : null;
   if (wantedSlug) {
     const fromApi = await resolveBusinessContextBySlug(token, wantedSlug);
@@ -1720,6 +1758,9 @@ async function resolveBusinessOwnerForCreate(token, businessSlug = null) {
         businessName: cached.name || cached.slug || wantedSlug,
       };
     }
+    if (options.allowCanonicalShortcutFallback) {
+      return resolveSingleBusinessShortcutFallback(token, wantedSlug);
+    }
     return null;
   }
 
@@ -2248,7 +2289,9 @@ async function computerCreate(token, args = [], defaults = {}) {
     return;
   }
 
-  const ctx = await resolveBusinessOwnerForCreate(token, options.businessSlug);
+  const ctx = await resolveBusinessOwnerForCreate(token, options.businessSlug, {
+    allowCanonicalShortcutFallback: Boolean(defaults.allowCanonicalShortcutFallback),
+  });
   if (!ctx?.businessId) {
     console.error('No business found.');
     console.error('Run inside a bound business workspace or pass: --business <slug>');
@@ -3874,6 +3917,7 @@ async function runRecruitingComputerShortcut(token, args, cloudOptions = {}) {
     return computerCreate(token, finalArgs, {
       businessSlug: cloudOptions.businessSlug || RECRUITING_BUSINESS_SLUG,
       computerType: 'recruiting',
+      allowCanonicalShortcutFallback: !cloudOptions.businessSlug,
     });
   }
 
@@ -3888,6 +3932,7 @@ async function runRecruitingComputerShortcut(token, args, cloudOptions = {}) {
   const ctx = await resolveTypedBusinessComputerContext(token, recruitingOptions, {
     businessSlug: RECRUITING_BUSINESS_SLUG,
     computerType: 'recruiting',
+    allowCanonicalShortcutFallback: !recruitingOptions.businessSlug,
   });
   if (!ctx?.businessId) {
     console.error('Atris Recruiting is not available for this account.');

package/commands/gm.js

@@ -331,7 +331,7 @@ function gmState(args = []) {
     missions,
     review_queue: reviewQueue,
     next_commands: commands,
-    xp_rule: 'GM can route missions and review proof, but AgentXP still lands only after human accept.',
+    xp_rule: 'GM can route missions and review proof, but AgentXP is awarded only after human approval.',
     global_sync_rule: AGENTXP_GLOBAL_SYNC_RULE,
     leaderboard_url: AGENTXP_LEADERBOARD_URL,
   };

package/commands/harvest.js

@@ -0,0 +1,179 @@
+const fs = require('fs');
+const path = require('path');
+const {
+  isGenericInboxPlaceholder,
+  seedInboxFromMove,
+} = require('../lib/next-moves');
+
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+
+function safeRead(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch { return ''; }
+}
+
+function walkFiles(dir, predicate, limit = 200) {
+  const out = [];
+  const visit = (current) => {
+    if (out.length >= limit) return;
+    let entries = [];
+    try { entries = fs.readdirSync(current, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      if (out.length >= limit) break;
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) visit(full);
+      else if (!predicate || predicate(full)) out.push(full);
+    }
+  };
+  visit(dir);
+  return out.sort();
+}
+
+function clip(value, max = 140) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 3).trim()}...`;
+}
+
+function addAction(actions, title, source, reason, evidence = null) {
+  const clean = clip(title, 180);
+  if (!clean || isGenericInboxPlaceholder(clean)) return;
+  const key = clean.toLowerCase();
+  if (actions.some((action) => action.key === key)) return;
+  actions.push({
+    key,
+    title: clean,
+    source,
+    reason: clip(reason, 220),
+    evidence,
+  });
+}
+
+function receiptActions(root, actions) {
+  const runsDir = path.join(root, 'atris', 'runs');
+  for (const file of walkFiles(runsDir, (full) => /\.json$/i.test(full), 300).slice(-80)) {
+    let receipt = null;
+    try { receipt = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { receipt = null; }
+    if (!receipt || receipt.schema !== 'atris.mission_receipt.v1') continue;
+    const rel = path.relative(root, file);
+    const landing = receipt.result?.landing || {};
+    const text = [
+      receipt.objective,
+      landing.changed,
+      landing.reason,
+      landing.checked,
+      landing.tested,
+      landing.next,
+      receipt.result?.reason,
+    ].filter(Boolean).join(' ');
+    if (/no concrete follow-up|stop|placeholder|zero value score|near[- ]?miss/i.test(text)) {
+      addAction(actions, 'Improve the next-mission chooser so it explains stopped work and better candidates', 'receipt', text, rel);
+    }
+    if (receipt.result?.verifier_result?.passed === false || /\b(verifier|test|check).{0,40}\b(fail|failed|error)\b/i.test(text)) {
+      addAction(actions, `Fix failing verifier for ${receipt.objective || 'latest mission'}`, 'receipt', text, rel);
+    }
+    if (landing.reason && landing.proof && /receipt saved/i.test(landing.proof)) {
+      addAction(actions, 'Surface buried result landing reasoning in the normal mission view', 'receipt', landing.reason, rel);
+    }
+    if (landing.proof == null || /proof:\s*null/i.test(text)) {
+      addAction(actions, 'Repair proof mismatch where proof exists in metadata but renders as null', 'receipt', text, rel);
+    }
+  }
+}
+
+function runLogActions(root, actions) {
+  const logsDir = path.join(root, 'atris', 'logs', 'runs');
+  for (const file of walkFiles(logsDir, (full) => /\.(log|txt|md|json)$/i.test(full), 200).slice(-60)) {
+    const rel = path.relative(root, file);
+    const text = safeRead(file);
+    if (!text) continue;
+    if (/no concrete follow-up|placeholder|test idea|zero value score/i.test(text)) {
+      addAction(actions, 'Harvest weak chooser traces into a concrete next-mission fix', 'runlog', text, rel);
+    }
+    if (/\b(error|failed|exception|traceback|unhandled)\b/i.test(text)) {
+      addAction(actions, 'Turn recent run-log failures into a bounded fix task with proof', 'runlog', text, rel);
+    }
+  }
+}
+
+function thinkingActions(root, actions) {
+  const rel = 'atris/thinking.md';
+  const text = safeRead(path.join(root, rel));
+  if (!text) return;
+  if (/plain English|jargon|feynman|understand/i.test(text)) {
+    addAction(actions, 'Make proof and task previews plain enough to understand without opening logs', 'thinking', text, rel);
+  }
+  if (/proof over motion|receipt|verified|checked/i.test(text)) {
+    addAction(actions, 'Audit proof surfaces for null proof, hidden receipts, and vague verifier claims', 'thinking', text, rel);
+  }
+  if (/stop.*no concrete|no concrete.*stop|fake|busywork/i.test(text)) {
+    addAction(actions, 'Make autonomous loops stop or ask instead of inventing fake work', 'thinking', text, rel);
+  }
+}
+
+function harvestActions(root = process.cwd()) {
+  const actions = [];
+  receiptActions(root, actions);
+  runLogActions(root, actions);
+  thinkingActions(root, actions);
+  return actions.slice(0, 12).map(({ key, ...action }, index) => ({
+    id: `I${index + 1}`,
+    ...action,
+  }));
+}
+
+function harvestCommand(args = []) {
+  const root = process.cwd();
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || args[0] === 'help') {
+    console.log('Usage: atris harvest [--write] [--json]');
+    console.log('');
+    console.log('Find plain next actions from mission receipts, run logs, and thinking.md.');
+    console.log('Read-only by default. Use --write to append actions to today\'s Inbox.');
+    return { ok: true, action: 'help' };
+  }
+  const asJson = hasFlag(args, '--json');
+  const write = hasFlag(args, '--write');
+  const actions = harvestActions(root);
+  const writes = [];
+  if (write) {
+    for (const action of actions) {
+      const written = seedInboxFromMove(root, { title: action.title, source: action.source });
+      writes.push({
+        title: action.title,
+        file: written.file ? path.relative(root, written.file) : null,
+        line: written.line,
+        already_present: Boolean(written.alreadyPresent),
+      });
+    }
+  }
+  const payload = {
+    ok: true,
+    action: 'harvest',
+    write,
+    count: actions.length,
+    actions,
+    writes,
+  };
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    return payload;
+  }
+  if (!actions.length) {
+    console.log('No harvest actions found.');
+    return payload;
+  }
+  for (const action of actions) {
+    console.log(`- **${action.id}:** ${action.title}`);
+    console.log(`  reason: ${action.reason}`);
+    if (action.evidence) console.log(`  evidence: ${action.evidence}`);
+  }
+  if (write) console.log(`Wrote ${writes.filter((item) => item.line).length} inbox action(s).`);
+  else console.log('Read-only. Add --write to append these to today\'s Inbox.');
+  return payload;
+}
+
+module.exports = {
+  harvestActions,
+  harvestCommand,
+};

package/commands/init.js

@@ -512,7 +512,7 @@ function initAtris() {
   if (!fs.existsSync(featuresDir)) {
     fs.mkdirSync(featuresDir, { recursive: true });
     const featuresReadme = path.join(featuresDir, 'README.md');
-    fs.writeFileSync(featuresReadme, '# Features\n\nThis directory tracks all features built using the atrisDev protocol.\n\nEach feature has:\n- `[feature-name]/idea.md` - Problem, solution, diagrams, success criteria\n- `[feature-name]/build.md` - Implementation plan, files changed, testing\n- `[feature-name]/validate.md` - End-to-end simulation script\n\n---\n\n## Features Built\n\n*Features will appear here as you build them.*\n');
+    fs.writeFileSync(featuresReadme, '# Features\n\nThis directory tracks all features built using the Atris protocol.\n\nEach feature has:\n- `[feature-name]/idea.md` - Problem, solution, diagrams, success criteria\n- `[feature-name]/build.md` - Implementation plan, files changed, testing\n- `[feature-name]/validate.md` - End-to-end simulation script\n\n---\n\n## Features Built\n\n*Features will appear here as you build them.*\n');
     console.log('✓ Created features/ directory with README');
   }