atris 3.56.0 → 3.56.1

package/lib/account-bound.js

@@ -15,6 +15,12 @@ function isHelpArg(arg) {
   return arg === '--help' || arg === '-h' || arg === 'help';
 }
 
+function looksLikeBusinessSlug(token) {
+  const value = String(token || '');
+  if (!value || value.startsWith('-')) return false;
+  return /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(value);
+}
+
 /**
  * Account-scoped verbs dump live CRM/cloud state. Outside a bound business
  * workspace they must opt in with --account. Help always passes.
@@ -42,6 +48,7 @@ function refuseAccountGlobal(write = console.error) {
 
 module.exports = {
   ACCOUNT_GLOBAL_MESSAGE,
+  looksLikeBusinessSlug,
   requireAccountBound,
   refuseAccountGlobal,
 };

package/lib/apply-gate.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function dateStamp(now) {
+  if (typeof now === 'string' && /^\d{4}-\d{2}-\d{2}/.test(now)) {
+    return now.slice(0, 10);
+  }
+  const value = now instanceof Date ? now : new Date(now || Date.now());
+  if (Number.isNaN(value.getTime())) return new Date().toISOString().slice(0, 10);
+  return value.toISOString().slice(0, 10);
+}
+
+function parseApplyFields(text) {
+  const change = String(text || '').match(/^change:\s*(.+)$/im);
+  const receipt = String(text || '').match(/^receipt:\s*(.+)$/im);
+  return {
+    change: change ? change[1].trim() : '',
+    receipt: receipt ? receipt[1].trim() : '',
+  };
+}
+
+function isFilledApply(fields) {
+  const empty = (value) => !value || /^fill this$/i.test(value);
+  return !empty(fields.change) && !empty(fields.receipt);
+}
+
+function applySlug(text) {
+  const slug = String(text || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48);
+  return slug || 'query';
+}
+
+function applySidecarRel(kind, id) {
+  return `atris/wiki/briefs/${kind}-${id}.apply.md`;
+}
+
+function readApplyReceipt({ cwd, rel } = {}) {
+  if (!rel || !cwd) return null;
+  const abs = path.join(cwd, rel);
+  if (!fs.existsSync(abs)) return null;
+  return { rel, text: fs.readFileSync(abs, 'utf8') };
+}
+
+function writeApplyStub({ cwd, source, rel, now } = {}) {
+  try {
+    if (!rel || !cwd) return null;
+    const wikiDir = path.join(cwd, 'atris', 'wiki');
+    if (!fs.existsSync(wikiDir)) return null;
+
+    const abs = path.join(cwd, rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    if (!fs.existsSync(abs)) {
+      fs.writeFileSync(abs, [
+        `source: ${source}`,
+        'change: fill this',
+        'receipt: fill this',
+      ].join('\n') + '\n');
+    }
+
+    const date = dateStamp(now);
+    const journalPath = path.join(cwd, 'atris', 'logs', date.slice(0, 4), `${date}.md`);
+    fs.mkdirSync(path.dirname(journalPath), { recursive: true });
+    let existing = '';
+    if (fs.existsSync(journalPath)) existing = fs.readFileSync(journalPath, 'utf8');
+    const line = `- [claimable] apply: fill this -> ${rel}`;
+    if (!existing.includes(line)) {
+      const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+      fs.writeFileSync(journalPath, `${existing}${prefix}${line}\n`);
+    }
+    return rel;
+  } catch {
+    return null;
+  }
+}
+
+function ensureApply({ cwd, source, rel, now, output, incompleteMessage, required = true } = {}) {
+  const print = typeof output === 'function' ? output : (line = '') => console.error(line);
+  const existing = readApplyReceipt({ cwd, rel });
+  if (existing && isFilledApply(parseApplyFields(existing.text))) return 0;
+  if (!(required && existing)) writeApplyStub({ cwd, source, rel, now });
+  print(incompleteMessage);
+  return required ? 2 : 0;
+}
+
+module.exports = {
+  applySlug,
+  applySidecarRel,
+  ensureApply,
+};

package/lib/context-gatherer.js

@@ -54,9 +54,11 @@ function isFlagLikeAnswer(answer) {
   return tokens.every((token) => token.startsWith('-') || token === 'help');
 }
 
-function starterTaskTitle(answer) {
-  const summary = compactText(answer, 80) || 'first useful path';
-  return `First useful step: ${summary}`;
+function starterTaskTitle(answer, folder = 'this folder') {
+  const room = folder || 'this folder';
+  const { isFirstTalkLine } = require('./first-minute');
+  if (isFirstTalkLine(answer)) return room;
+  return compactText(answer, 80) || room;
 }
 
 function saveContextProfile(root, answer, { source = 'first_contact' } = {}) {
@@ -77,29 +79,71 @@ function saveContextProfile(root, answer, { source = 'first_contact' } = {}) {
   return profile;
 }
 
+function runSilentMinimalInit(root = process.cwd()) {
+  const { spawnSync } = require('child_process');
+  const script = process.argv[1] || path.join(__dirname, '..', 'bin', 'atris.js');
+  const result = spawnSync(process.execPath, [script, 'init', '--minimal', '--yes'], {
+    cwd: root,
+    env: process.env,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return Number.isInteger(result.status) ? result.status : 1;
+}
+
+function startFirstTalk(root, answer, { asJson = false, log = console.log } = {}) {
+  const {
+    firstTalkJson,
+    folderName,
+    personName,
+    renderFirstTalk,
+  } = require('./first-minute');
+  const initStatus = runSilentMinimalInit(root);
+  if (initStatus !== 0) return initStatus;
+  saveContextProfile(root, answer, { source: 'first_talk' });
+  const starter = createStarterTask(root, answer);
+  const room = folderName(root);
+  const who = personName();
+  if (asJson) {
+    log(JSON.stringify(firstTalkJson({ starter, person: who, folder: room }), null, 2));
+    return 0;
+  }
+  log('');
+  log(renderFirstTalk({ person: who, folder: room, starter }));
+  return 0;
+}
+
 function createStarterTask(root, answer) {
   if (isFlagLikeAnswer(answer)) return null;
   const atrisDir = path.join(root, 'atris');
   if (!fs.existsSync(atrisDir)) return null;
+  const { folderName, personName } = require('./first-minute');
+  const title = starterTaskTitle(answer, folderName(root));
+  const who = personName() || 'operator';
   try {
     const taskDb = require('./task-db');
     const db = taskDb.open();
     const workspaceRoot = taskDb.workspaceRoot(root);
-    const title = starterTaskTitle(answer);
     const sourceKey = taskDb.sourceKey('context-gatherer:first-task', title);
     const added = taskDb.addTask(db, {
       title,
       tag: 'onboarding',
       workspaceRoot,
       sourceKey,
+      status: 'claimed',
+      claimedBy: who,
       metadata: {
         source: 'context_gatherer',
         first_answer: compactText(answer, 500),
       },
     });
-    const rows = taskDb.listTasks(db, { workspaceRoot });
-    const displayRows = taskDb.withTaskDisplayRefs(rows);
-    const task = displayRows.find(row => row.id === added.id) || null;
+    let rows = taskDb.listTasks(db, { workspaceRoot });
+    let task = taskDb.withTaskDisplayRefs(rows).find(row => row.id === added.id) || null;
+    if (task && task.status === 'open') {
+      taskDb.claimTask(db, { id: added.id, claimedBy: who });
+      rows = taskDb.listTasks(db, { workspaceRoot });
+      task = taskDb.withTaskDisplayRefs(rows).find(row => row.id === added.id) || task;
+    }
     try {
       const todoPath = path.join(root, 'atris', 'TODO.md');
       fs.writeFileSync(todoPath, taskDb.renderTodoMarkdown(rows, { title: 'TODO.md' }), 'utf8');
@@ -109,11 +153,13 @@ function createStarterTask(root, answer) {
       inserted: added.inserted,
       display_id: task && task.display_id || null,
       title,
+      status: task && task.status || 'claimed',
+      claimed_by: (task && task.claimed_by) || who,
     };
   } catch (error) {
     return {
       error: error && error.message ? error.message : String(error),
-      title: starterTaskTitle(answer),
+      title,
     };
   }
 }
@@ -185,6 +231,7 @@ module.exports = {
   hasContextProfile,
   saveContextProfile,
   createStarterTask,
+  startFirstTalk,
   shouldGatherContext,
   renderPrompt,
   starterTaskTitle,

package/lib/engine-ask.js

@@ -25,6 +25,7 @@ const DEFAULT_ASK_TIMEOUT_MS = 120000;
 const MAX_ASK_CONCURRENCY = 4;
 const MAX_ASK_JOBS = 8;
 const MAX_ASK_TIMEOUT_MS = 10 * 60 * 1000;
+const DEFAULT_FABLE_ASK_TIMEOUT_MS = MAX_ASK_TIMEOUT_MS;
 const MAX_ASK_PROMPT_BYTES = 16 * 1024;
 const MAX_ASK_TOTAL_PROMPT_BYTES = 64 * 1024;
 const MAX_ASK_OUTPUT_BYTES = 1024 * 1024;
@@ -45,7 +46,7 @@ function askUsage() {
     'options:',
     '  --model <name>     exact model for every selected engine',
     `  --concurrency <n>  parallel runs, 1-${MAX_ASK_CONCURRENCY} (default ${DEFAULT_ASK_CONCURRENCY})`,
-    `  --timeout <sec>    per-engine timeout, 1-${MAX_ASK_TIMEOUT_MS / 1000} (default ${DEFAULT_ASK_TIMEOUT_MS / 1000})`,
+    `  --timeout <sec>    per-engine timeout, 1-${MAX_ASK_TIMEOUT_MS / 1000} (default ${DEFAULT_ASK_TIMEOUT_MS / 1000}; Fable ${DEFAULT_FABLE_ASK_TIMEOUT_MS / 1000})`,
     '  --json             print the receipt as json',
     '',
     `jobs files contain up to ${MAX_ASK_JOBS} objects: [{"engine":"codex","model":"optional","prompt":"question","label":"optional"}]`,
@@ -74,7 +75,7 @@ function normalizeAskJob(job, index) {
   if (Buffer.byteLength(prompt) > MAX_ASK_PROMPT_BYTES) {
     throw new Error(`job ${index + 1} prompt must be ${MAX_ASK_PROMPT_BYTES} bytes or fewer`);
   }
-  const model = String(job.model || '').trim();
+  const model = resolveAskModel(engine, job.model);
   const label = String(job.label || '').trim();
   if (label.length > 80) throw new Error(`job ${index + 1} label must be 80 characters or fewer`);
   return { engine, model, prompt, label };
@@ -99,7 +100,7 @@ function parseEngineAskArgs(args, { root = process.cwd(), readFile = fs.readFile
   let requestedModel = '';
   let modelFlagPresent = false;
   let concurrency = DEFAULT_ASK_CONCURRENCY;
-  let timeoutMs = DEFAULT_ASK_TIMEOUT_MS;
+  let timeoutMs = null;
   let json = false;
   let help = false;
 
@@ -146,7 +147,7 @@ function parseEngineAskArgs(args, { root = process.cwd(), readFile = fs.readFile
     promptParts.push(arg);
   }
 
-  if (help) return { help: true, json, jobs: [], concurrency, timeoutMs };
+  if (help) return { help: true, json, jobs: [], concurrency, timeoutMs: timeoutMs || DEFAULT_ASK_TIMEOUT_MS };
   if (modelFlagPresent && !requestedModel) throw new Error('--model needs a name');
   const commonPrompt = promptParts.join(' ').trim();
   let jobs;
@@ -178,7 +179,9 @@ function parseEngineAskArgs(args, { root = process.cwd(), readFile = fs.readFile
   if (totalPromptBytes > MAX_ASK_TOTAL_PROMPT_BYTES) {
     throw new Error(`engine ask accepts at most ${MAX_ASK_TOTAL_PROMPT_BYTES} prompt bytes per run`);
   }
-  return { help: false, json, jobs: labelAskJobs(jobs), concurrency, timeoutMs };
+  const resolvedTimeoutMs = timeoutMs
+    || (jobs.some((job) => job.engine === 'fable') ? DEFAULT_FABLE_ASK_TIMEOUT_MS : DEFAULT_ASK_TIMEOUT_MS);
+  return { help: false, json, jobs: labelAskJobs(jobs), concurrency, timeoutMs: resolvedTimeoutMs };
 }
 
 function guardedPrompt(prompt) {
@@ -192,11 +195,18 @@ function assertAskModelSupported(engine, model) {
   throw error;
 }
 
+function resolveAskModel(engine, modelName = '') {
+  const requested = String(modelName || '').trim();
+  if (requested) return requested;
+  if (engine !== 'claude' && engine !== 'fable' && engine !== 'haiku') return '';
+  return RUNNER_PROFILE_DEFS[engine]?.model || DEFAULT_CLAUDE_RUNNER_MODEL;
+}
+
 function buildReadOnlyEngineInvocation(engineName, prompt, modelName = '') {
   const engine = canonicalEngineName(engineName);
   const profile = RUNNER_PROFILE_DEFS[engine];
   if (!profile) throw new Error(`unknown engine "${engineName}"`);
-  const model = String(modelName || '').trim();
+  const model = resolveAskModel(engine, modelName);
   assertAskModelSupported(engine, model);
   const request = guardedPrompt(prompt);