atris 3.56.0 → 3.56.2

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,102 @@
+'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, change, receipt, journalLine } = {}) {
+  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 });
+    const changeText = change || 'fill this';
+    const receiptText = receipt || 'fill this';
+    let shouldWrite = !fs.existsSync(abs);
+    if (!shouldWrite && change && receipt) {
+      shouldWrite = !isFilledApply(parseApplyFields(fs.readFileSync(abs, 'utf8')));
+    }
+    if (shouldWrite) {
+      fs.writeFileSync(abs, [
+        `source: ${source}`,
+        `change: ${changeText}`,
+        `receipt: ${receiptText}`,
+      ].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 = journalLine || `- [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, change, receipt, journalLine,
+} = {}) {
+  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, change, receipt, journalLine });
+  print(incompleteMessage);
+  return required ? 2 : 0;
+}
+
+module.exports = {
+  applySlug,
+  applySidecarRel,
+  ensureApply,
+};

package/lib/config-guard.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+const SETTINGS_NAME = 'settings.json';
+const CLAUDE_DIR_NAME = '.claude';
+const DENY_REASON = 'pack runs cannot change .claude/settings.json to add SessionStart or disable hooks';
+
+function expandUserPath(value, home) {
+  const text = String(value);
+  if (text === '~') return home;
+  if (text.startsWith('~/') || text.startsWith('~\\')) return path.join(home, text.slice(2));
+  return text;
+}
+
+function asText(value) {
+  if (value == null) return '';
+  if (typeof value === 'string') return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function settingsPlantPersistence(value) {
+  if (!value || typeof value !== 'object') return false;
+  if (value.disableAllHooks === true) return true;
+  if (value.hooks && Object.prototype.hasOwnProperty.call(value.hooks, 'SessionStart')) return true;
+  return Object.values(value).some((entry) => settingsPlantPersistence(entry));
+}
+
+function plantsPersistence(text) {
+  const source = asText(text);
+  if (!source) return false;
+  if (/\bSessionStart\b/.test(source)) return true;
+  if (/["']?disableAllHooks["']?\s*:\s*true\b/.test(source)) return true;
+  try {
+    return settingsPlantPersistence(JSON.parse(source));
+  } catch {
+    return false;
+  }
+}
+
+function isClaudeSettingsPath(value, options = {}) {
+  if (typeof value !== 'string' || !value.trim()) return false;
+  const home = options.home || os.homedir();
+  const cwd = options.cwd || process.cwd();
+  const expanded = expandUserPath(value.trim(), home);
+  const resolved = path.resolve(cwd, expanded);
+  if (path.basename(resolved) === SETTINGS_NAME && path.basename(path.dirname(resolved)) === CLAUDE_DIR_NAME) {
+    return true;
+  }
+  const configDir = path.resolve(
+    options.configDir
+      || process.env.CLAUDE_CONFIG_DIR
+      || path.join(home, CLAUDE_DIR_NAME),
+  );
+  return resolved === path.join(configDir, SETTINGS_NAME);
+}
+
+function commandMentionsClaudeSettings(command) {
+  const text = String(command || '');
+  if (!text.trim()) return false;
+  return /(?:^|[^\w])(?:~\/|\.\/|(?:\.\.\/)+)?(?:\$\{?HOME\}?\/)?\.claude\/settings\.json\b/.test(text)
+    || /\$\{?CLAUDE_CONFIG_DIR\}?\/settings\.json/.test(text)
+    || /(?:^|[^\w])(?:\$HOME|\$\{HOME\})\/\.claude\/settings\.json\b/.test(text);
+}
+
+function fileToolPath(input) {
+  const toolInput = (input && input.tool_input) || {};
+  return toolInput.file_path || toolInput.path || null;
+}
+
+function bashCommand(input) {
+  const toolInput = (input && input.tool_input) || {};
+  return toolInput.command || toolInput.cmd || '';
+}
+
+function writeContents(input) {
+  const toolInput = (input && input.tool_input) || {};
+  return toolInput.contents ?? toolInput.content ?? toolInput.new_string ?? '';
+}
+
+function enforceConfigGuard(input, options = {}) {
+  const tool = input && input.tool_name;
+  if (tool === 'Write' || tool === 'Edit') {
+    if (!isClaudeSettingsPath(fileToolPath(input), options)) return { allowed: true };
+    if (!plantsPersistence(writeContents(input))) return { allowed: true };
+    return { allowed: false, reason: DENY_REASON };
+  }
+  if (tool === 'Bash') {
+    if (!commandMentionsClaudeSettings(bashCommand(input))) return { allowed: true };
+    return { allowed: false, reason: DENY_REASON };
+  }
+  return { allowed: true };
+}
+
+module.exports = {
+  DENY_REASON,
+  commandMentionsClaudeSettings,
+  enforceConfigGuard,
+  isClaudeSettingsPath,
+  plantsPersistence,
+};

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);
 

package/lib/engine-registry.js

@@ -68,6 +68,14 @@ function engineRegistryFile(root = process.cwd()) {
   return path.join(root, '.atris', 'state', 'engines.json');
 }
 
+// A scratch folder is not a room. First-touch seed must not mint .atris/.
+// Updates stay allowed once the file or a real workspace already exists.
+function canPersistEngineRegistry(root = process.cwd()) {
+  if (fs.existsSync(engineRegistryFile(root))) return true;
+  return fs.existsSync(path.join(root, 'atris'))
+    || fs.existsSync(path.join(root, '.atris', 'business.json'));
+}
+
 // Machine probe. Routing never calls this on a settled registry: it runs once
 // when an engine first appears (seeding the policy file), at the execution
 // stage right before a spawn, and on the explicit `atris engine doctor`.
@@ -239,14 +247,16 @@ function setEngineOverrides(name, overrides = {}, root = process.cwd()) {
 }
 
 // A read only writes when normalization actually changed the saved engines
-// (first seed, schema drift). Settled registries stay untouched, so read
-// paths cannot stomp a mutation another process just landed. The comparison
-// uses the same raw snapshot the seed was built from: one read, one decision.
+// (first seed, schema drift) and this folder is already a room or already
+// has engines.json. Empty scratch stays empty. Settled registries stay
+// untouched, so read paths cannot stomp a mutation another process just
+// landed. The comparison uses the same raw snapshot the seed was built from:
+// one read, one decision.
 function readEngineRegistry(root = process.cwd(), options = {}) {
   const raw = readRawRegistry(engineRegistryFile(root));
   const registry = seededRegistry(root, raw);
   const needsPersist = JSON.stringify(raw.engines || []) !== JSON.stringify(registry.engines);
-  if (options.persist !== false && needsPersist) {
+  if (options.persist !== false && needsPersist && canPersistEngineRegistry(root)) {
     writeEngineRegistry(root, registry);
   }
   return registry;