atris 3.32.0 → 3.34.0

package/bin/atris.js

@@ -127,6 +127,19 @@ function isOptionValue(args, index, optionNames) {
 }
 
 function applyRunnerFlags(args) {
+  // --engine <name> is the operator-facing spelling of --runner-profile:
+  // one flag rents a specific intelligence for this run.
+  const engineFlag = readOptionArg(args, '--engine');
+  if (engineFlag) {
+    const { canonicalEngineName } = require('../commands/engine');
+    const { RUNNER_PROFILE_NAMES } = require('../lib/runner-command');
+    const canonical = canonicalEngineName(engineFlag);
+    if (!canonical) {
+      console.error(`Unknown --engine "${engineFlag}". Known engines: ${RUNNER_PROFILE_NAMES.join(', ')}.`);
+      process.exit(1);
+    }
+    process.env.ATRIS_RUNNER_PROFILE = canonical;
+  }
   const runnerProfile = readOptionArg(args, '--runner-profile');
   if (runnerProfile) {
     // Fail fast at the CLI boundary: an unknown profile otherwise stays silent
@@ -153,8 +166,30 @@ function applyRunnerFlags(args) {
     process.env.ATRIS_RUNNER_MODEL = runnerModel;
     process.env.ATRIS_CLAUDE_MODEL = runnerModel;
   }
+  // No per-run choice and no env: the workspace's saved engine
+  // (.atris/engine.json, written by `atris engine <name>`) becomes the
+  // profile for every loop spawn. For the loop commands themselves, fall all
+  // the way to the house engine (atris-fast when ax is installed) so the
+  // default intelligence is our own. Heartbeats stay engine-agnostic without
+  // any loop code knowing about engines.
+  if (!process.env.ATRIS_RUNNER_PROFILE) {
+    try {
+      const engine = require('../commands/engine');
+      const saved = engine.readSavedEngine();
+      if (saved) {
+        process.env.ATRIS_RUNNER_PROFILE = saved;
+      } else if (RUNNER_SPAWNING_COMMANDS.includes(command)) {
+        const resolved = engine.resolveDefaultEngine();
+        if (resolved.source === 'house') process.env.ATRIS_RUNNER_PROFILE = resolved.name;
+      }
+    } catch {}
+  }
 }
 
+// Commands whose ticks spawn a worker engine; only these pay the engine
+// detection probe when nothing is configured.
+const RUNNER_SPAWNING_COMMANDS = ['run', 'autopilot', 'mission', 'pulse', 'gm', 'spaceship'];
+
 const isBusinessSyncSafetyCommand = command === 'sync'
   && (
     commandArgs.includes('--status')
@@ -429,11 +464,13 @@ function showHelp() {
   console.log('Quick Start:');
   console.log('');
   console.log('  1. atris                  Open a persistent AI computer for this workspace');
+  console.log('     npx atris              Same command after a local project install');
   console.log('  2. Describe what you want run, built, researched, or validated');
   console.log('  3. Atris acts with context, memory, tools, and a review loop');
   console.log('');
   console.log('Common invocations:');
-  console.log('  atris init');
+  console.log('  atris init                Global install: initialize this project');
+  console.log('  npx atris init            Local install: initialize this project');
   console.log('  atris computer');
   console.log('  atris business init "My Company"');
   console.log('  atris run');
@@ -497,6 +534,7 @@ function showHelp() {
   console.log('  worktree   - Isolated Git worktrees plus guarded ship/merge for parallel agents');
   console.log('  land       - The landing: what is actually done vs still in the air; --reap backs up + clears overdue');
   console.log('  autoland   - Approve the policy once; certified work lands itself, you keep irreversible calls');
+  console.log('  engine     - Bring any intelligence: roster of installed coding CLIs, default engine, --engine per run, `engine test` preflight');
   console.log('  sign       - Co-author trailer on every commit in an atris workspace (on/off/status)');
   console.log('  visualize  - Generate a Slack/deck-ready visual from a prompt');
   console.log('  youtube    - Process YouTube videos with timestamped transcript-first analysis');
@@ -556,6 +594,7 @@ function showHelp() {
   console.log('  console    - Start/attach always-on coding console (tmux daemon)');
   console.log('  soul       - Show, snapshot, or fork workspace identity');
   console.log('  fleet      - Inspect local fleet status');
+  console.log('  loops      - Background loops board: what runs, what died, start/stop');
   console.log('  agent      - Select cloud agent, spawn worker requests, or run `agent doctor`');
   console.log('  chat       - Chat with Atris 2 Fast in this workspace (--agent for cloud agent; or: atris chat scan)');
   console.log('  fast       - Chat with Atris2 Fast');
@@ -567,7 +606,7 @@ function showHelp() {
   console.log('  accounts   - Manage accounts (list, add, remove)');
   console.log('');
   console.log('Integrations:');
-  console.log('  gmail      - Email commands (inbox, read)');
+  console.log('  gmail      - Email commands (inbox, read, archive)');
   console.log('  calendar   - Calendar commands (today, week)');
   console.log('  twitter    - Twitter commands (post)');
   console.log('  slack      - Slack commands (channels)');
@@ -937,7 +976,7 @@ const knownCommands = ['init', 'log', 'now', 'radar', 'ctop', 'launchpad', 'stat
                        'clean', 'harvest', 'verify', 'search', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'plugin', 'experiments', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'probe', 'worktree', 'land', 'autoland', 'aeo', 'slop', 'strings', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'xp', 'play', 'gm', 'x', 'recap', 'signup', 'clarity', 'moves',
                        'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
-                       'fork', 'browse', 'publish', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'compile', 'spaceship', 'truth', 'sign'];
+                       'fork', 'browse', 'publish', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'loops', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines'];
 
 // Check if command is an atris.md spec file - triggers welcome visualization
 function isSpecFile(cmd) {
@@ -1059,7 +1098,11 @@ async function interactiveEntry(userInput) {
 
   // Fresh install - offer init
   if (state.state === 'fresh') {
-    console.log('\nNo atris/ folder found. Run: atris init');
+    console.log('\nNo atris/ folder found.');
+    console.log('');
+    console.log('Start here:');
+    console.log('  atris init       if Atris is installed globally');
+    console.log('  npx atris init   if Atris was installed in this project');
     return;
   }
 
@@ -2225,6 +2268,14 @@ if (command === 'init') {
   require('../commands/fleet').fleet(args)
     .then(() => process.exit(0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'loops') {
+  try {
+    require('../commands/loops').loopsCommand(process.argv[3], ...process.argv.slice(4));
+    process.exit(0);
+  } catch (error) {
+    console.error(`\n✗ Error: ${error.message || error}`);
+    process.exit(1);
+  }
 } else if (command === 'spaceship') {
   const args = process.argv.slice(3);
   require('../commands/spaceship').spaceship(args)
@@ -2272,6 +2323,13 @@ if (command === 'init') {
   Promise.resolve(require('../commands/compile').compileCommand(subcommand, ...args))
     .then(() => process.exit(process.exitCode || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'engine' || command === 'engines') {
+  // Engine: bring any intelligence — roster of installed coding CLIs, default
+  // engine per workspace, --engine <name> rides any loop for one run.
+  try {
+    const engineArgs = command === 'engines' && process.argv.length <= 3 ? [] : process.argv.slice(3);
+    process.exit(require('../commands/engine').engineCommand(engineArgs) || 0);
+  } catch (err) { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); }
 } else if (command === 'sign') {
   // Sign: prepare-commit-msg hook that credits Atris as co-author on commits in atris workspaces.
   try { process.exit(require('../commands/sign').signCommand(process.argv[3]) || 0); }

package/commands/autoland.js

@@ -357,15 +357,21 @@ function showHelp() {
   console.log('                                     on you past 24h');
   console.log('  atris autoland off                 back to approving every item');
   console.log('  atris autoland digest [--send]     the daily message, now');
-  console.log('  atris autoland tick                one heartbeat (what the hourly cron runs)');
+  console.log('  atris autoland tick [--json]       one heartbeat (what the hourly cron runs)');
+  console.log('');
+  console.log('help is always read-only: atris autoland tick --help never lands work.');
   console.log('');
   return 0;
 }
 
+function wantsHelp(args = []) {
+  return args.some((arg) => arg === 'help' || arg === '--help' || arg === '-h');
+}
+
 function autolandCommand(args = []) {
   const [sub, ...rest] = args;
+  if (wantsHelp(args)) return showHelp();
   if (!sub || sub.startsWith('--')) return showStatus(repoRoot(), args);
-  if (sub === 'help' || sub === '--help' || sub === '-h') return showHelp();
   const root = repoRoot();
   if (sub === 'on') return turnOn(root, rest);
   if (sub === 'off') return turnOff(root);

package/commands/engine.js

@@ -0,0 +1,299 @@
+'use strict';
+
+// atris engine: bring any intelligence.
+// Every installed headless coding CLI is a swappable worker behind one
+// contract (bounded prompt in, verified proof out, engines never
+// self-certify). This command shows the roster, flips the default, and the
+// same names ride --engine on mission run / autopilot / run.
+//
+//   atris engine            roster + current default
+//   atris engine cursor     make cursor the default engine here
+//   atris engine reset      back to the house default (atris-fast)
+//
+// The default persists to .atris/engine.json. Per-run flags and
+// ATRIS_RUNNER_PROFILE always beat the file.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const {
+  RUNNER_PROFILE_DEFS,
+  RUNNER_PROFILE_ALIASES,
+  RUNNER_PROFILE_NAMES,
+  buildRunnerCommand,
+} = require('../lib/runner-command');
+
+const HOUSE_ENGINE = 'atris-fast';
+
+function engineFile(root = process.cwd()) {
+  return path.join(root, '.atris', 'engine.json');
+}
+
+function binInstalled(bin) {
+  const safe = String(bin || '').replace(/[^A-Za-z0-9_.-]/g, '');
+  if (!safe) return false;
+  const probe = spawnSync('sh', ['-c', `command -v ${safe}`], { encoding: 'utf8' });
+  return probe.status === 0 && Boolean(String(probe.stdout || '').trim());
+}
+
+function canonicalEngineName(name) {
+  const trimmed = String(name || '').trim();
+  if (!trimmed) return '';
+  if (RUNNER_PROFILE_DEFS[trimmed]) return trimmed;
+  if (RUNNER_PROFILE_ALIASES[trimmed]) return RUNNER_PROFILE_ALIASES[trimmed];
+  return '';
+}
+
+function readSavedEngine(root = process.cwd()) {
+  try {
+    const saved = JSON.parse(fs.readFileSync(engineFile(root), 'utf8'));
+    return canonicalEngineName(saved.default);
+  } catch {
+    return '';
+  }
+}
+
+// The default engine for this workspace, in precedence order:
+// env (per-run flags land here) -> .atris/engine.json -> house default.
+// The house default is our own intelligence when it is installed.
+function resolveDefaultEngine(root = process.cwd()) {
+  const env = canonicalEngineName(process.env.ATRIS_RUNNER_PROFILE);
+  if (env) return { name: env, source: 'env' };
+  const saved = readSavedEngine(root);
+  if (saved) return { name: saved, source: 'saved' };
+  if (binInstalled(RUNNER_PROFILE_DEFS[HOUSE_ENGINE].bin)) return { name: HOUSE_ENGINE, source: 'house' };
+  const fallback = RUNNER_PROFILE_NAMES.find((name) => binInstalled(RUNNER_PROFILE_DEFS[name].bin));
+  return fallback ? { name: fallback, source: 'detected' } : { name: HOUSE_ENGINE, source: 'none' };
+}
+
+function roster(root = process.cwd()) {
+  const current = resolveDefaultEngine(root);
+  return RUNNER_PROFILE_NAMES.map((name) => ({
+    name,
+    bin: RUNNER_PROFILE_DEFS[name].bin,
+    installed: binInstalled(RUNNER_PROFILE_DEFS[name].bin),
+    default: name === current.name,
+  }));
+}
+
+function setEngine(name, root = process.cwd()) {
+  const canonical = canonicalEngineName(name);
+  if (!canonical) {
+    throw new Error(`Unknown engine "${name}". Known engines: ${RUNNER_PROFILE_NAMES.join(', ')}`);
+  }
+  const file = engineFile(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify({ default: canonical, set_at: new Date().toISOString() }, null, 2)}\n`);
+  return canonical;
+}
+
+function resetEngine(root = process.cwd()) {
+  try { fs.unlinkSync(engineFile(root)); return true; } catch { return false; }
+}
+
+function printRoster(root) {
+  const list = roster(root);
+  const found = list.filter((e) => e.installed).length;
+  const current = resolveDefaultEngine(root);
+  console.log('');
+  console.log(`  engines — ${found} intelligence${found === 1 ? '' : 's'} found`);
+  console.log('');
+  for (const engine of list) {
+    const mark = engine.default ? '→' : ' ';
+    const state = engine.installed ? 'ready' : 'not installed';
+    console.log(`  ${mark} ${engine.name.padEnd(12)} ${state}`);
+  }
+  console.log('');
+  console.log(`  default: ${current.name}${current.source === 'saved' ? ' (set here)' : current.source === 'env' ? ' (this session)' : ''}`);
+  console.log(`  switch:  atris engine <name>   ·   one run: --engine <name> on mission run / autopilot / run`);
+  console.log('');
+}
+
+// Preflight: run one engine CLI headless with a reply-OK prompt and report
+// pass/fail. A dead login, missing binary, or hung spawn is a one-command
+// diagnosis instead of a failed overnight flight. `name` is canonical.
+const PROBE_PROMPT = 'Reply with exactly the two characters: OK';
+// Real engines think before replying: cursor measured at ~68s for a one-word
+// answer on 2026-07-02. 30s produced a false FAIL on a healthy engine.
+const PROBE_DEFAULT_TIMEOUT_MS = 120000;
+
+function probeEngine(name, { timeout = PROBE_DEFAULT_TIMEOUT_MS } = {}) {
+  const def = RUNNER_PROFILE_DEFS[name];
+  if (!binInstalled(def.bin)) {
+    return {
+      engine: name,
+      bin: def.bin,
+      pass: false,
+      reason: 'not-installed',
+      message: `${def.bin} CLI not installed`,
+      stdout: '',
+      stderr: '',
+      durationMs: 0,
+    };
+  }
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-engine-probe-'));
+  const promptFile = path.join(tmpDir, 'prompt.txt');
+  fs.writeFileSync(promptFile, `${PROBE_PROMPT}\n`);
+  let cmd;
+  const prevProfile = process.env.ATRIS_RUNNER_PROFILE;
+  process.env.ATRIS_RUNNER_PROFILE = name;
+  try {
+    cmd = buildRunnerCommand({ promptFile });
+  } finally {
+    if (prevProfile === undefined) delete process.env.ATRIS_RUNNER_PROFILE;
+    else process.env.ATRIS_RUNNER_PROFILE = prevProfile;
+  }
+  const start = Date.now();
+  let res;
+  try {
+    res = spawnSync('sh', ['-c', cmd], { encoding: 'utf8', timeout });
+  } catch (err) {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    return {
+      engine: name,
+      bin: def.bin,
+      pass: false,
+      reason: 'spawn-error',
+      message: String(err && err.message ? err.message : err),
+      stdout: '',
+      stderr: '',
+      durationMs: Date.now() - start,
+    };
+  }
+  const durationMs = Date.now() - start;
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  const stdout = res.stdout || '';
+  const stderr = res.stderr || '';
+  const timedOut = res.status === null && Boolean(res.signal) && String(res.signal).toLowerCase().includes('term');
+  const combined = `${stdout}\n${stderr}`.trim();
+  const ok = res.status === 0 && /OK/i.test(combined);
+  let reason;
+  if (ok) reason = 'ok';
+  else if (timedOut) reason = 'timeout';
+  else if (res.status !== 0 && res.status !== null) reason = 'bad-exit';
+  else if (!/OK/i.test(combined)) reason = 'no-ok';
+  else reason = 'unknown';
+  return {
+    engine: name,
+    bin: def.bin,
+    pass: ok,
+    reason,
+    message: ok
+      ? 'responded OK'
+      : (timedOut ? `no reply within ${timeout}ms` : `did not reply OK (exit ${res.status}, signal ${res.signal})`),
+    stdout,
+    stderr,
+    durationMs,
+  };
+}
+
+function runEngineTest(targets, { json, root } = {}) {
+  let enginesToTest;
+  if (targets && targets.length) {
+    enginesToTest = targets.map((n) => {
+      const c = canonicalEngineName(n);
+      if (!c) {
+        throw new Error(`Unknown engine "${n}". Known engines: ${RUNNER_PROFILE_NAMES.join(', ')}`);
+      }
+      return c;
+    });
+  } else {
+    enginesToTest = RUNNER_PROFILE_NAMES.filter((n) => binInstalled(RUNNER_PROFILE_DEFS[n].bin));
+    if (!enginesToTest.length) {
+      if (json) {
+        console.log(JSON.stringify({ ok: false, results: [], summary: { pass: 0, fail: 0 } }, null, 2));
+      } else {
+        console.error('\n  no installed engines to test\n');
+      }
+      return 1;
+    }
+  }
+  const results = enginesToTest.map((name) => probeEngine(name));
+  const failures = results.filter((r) => !r.pass);
+  const passed = results.length - failures.length;
+  if (json) {
+    console.log(JSON.stringify({
+      ok: failures.length === 0,
+      results,
+      summary: { pass: passed, fail: failures.length },
+    }, null, 2));
+  } else {
+    console.log('');
+    for (const r of results) {
+      const mark = r.pass ? '✓' : '✗';
+      const line = r.pass
+        ? `  ${mark} ${r.engine.padEnd(12)} pass — ${r.message} (${r.durationMs}ms)`
+        : `  ${mark} ${r.engine.padEnd(12)} FAIL — ${r.message}`;
+      if (r.pass) console.log(line);
+      else console.error(line);
+    }
+    console.log('');
+    if (failures.length) {
+      console.error(`  ${failures.length} engine${failures.length === 1 ? '' : 's'} failed: ${failures.map((f) => f.engine).join(', ')}`);
+      console.error(`  fix the login/binary, then re-run: atris engine test${targets && targets.length ? ' ' + targets.join(' ') : ''}`);
+    } else {
+      console.log(`  all engines responded — clear for flight`);
+    }
+    console.log('');
+  }
+  return failures.length ? 1 : 0;
+}
+
+function engineCommand(args = []) {
+  const json = args.includes('--json');
+  const positional = args.filter((a) => !a.startsWith('--'));
+  const sub = (positional[0] || '').trim();
+  const root = process.cwd();
+
+  if (sub === 'test') {
+    return runEngineTest(positional.slice(1), { json, root });
+  }
+
+  if (!sub || sub === 'list' || sub === 'status') {
+    if (json) {
+      const current = resolveDefaultEngine(root);
+      console.log(JSON.stringify({ engines: roster(root), default: current.name, source: current.source }, null, 2));
+      return 0;
+    }
+    printRoster(root);
+    return 0;
+  }
+
+  if (sub === 'reset' || sub === 'off') {
+    const removed = resetEngine(root);
+    console.log(removed
+      ? `\n  default engine reset — back to ${resolveDefaultEngine(root).name}\n`
+      : `\n  nothing to reset — no engine was set here\n`);
+    return 0;
+  }
+
+  if (sub === 'help') {
+    console.log('\n  atris engine            roster + current default\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
+    return 0;
+  }
+
+  // atris engine <name> — flip the default.
+  const canonical = setEngine(sub, root);
+  const def = RUNNER_PROFILE_DEFS[canonical];
+  const installed = binInstalled(def.bin);
+  console.log('');
+  console.log(`  default engine: ${canonical}`);
+  if (!installed) console.log(`  heads up: its CLI (${def.bin}) is not installed here yet — runs will fail until it is.`);
+  console.log(`  every mission run / autopilot / run tick now rides it. one-off: --engine <name>. undo: atris engine reset`);
+  console.log('');
+  return 0;
+}
+
+module.exports = {
+  engineCommand,
+  resolveDefaultEngine,
+  canonicalEngineName,
+  readSavedEngine,
+  setEngine,
+  resetEngine,
+  roster,
+  probeEngine,
+  runEngineTest,
+  HOUSE_ENGINE,
+};

package/commands/integrations.js

@@ -124,6 +124,32 @@ async function gmailRead(messageId) {
   console.log(msg.body || msg.snippet || '(no body)');
 }
 
+async function gmailArchive(messageIds) {
+  const ids = (messageIds || []).map(id => String(id || '').trim()).filter(Boolean);
+  if (!ids.length) {
+    console.error('Usage: atris gmail archive <message_id> [<message_id> ...]');
+    process.exit(1);
+  }
+
+  const token = await getAuthToken();
+
+  console.log(`Archiving ${ids.length} message${ids.length === 1 ? '' : 's'}...`);
+
+  const result = await apiRequestJson('/integrations/gmail/messages/batch-archive', {
+    method: 'POST',
+    token,
+    body: { message_ids: ids },
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to archive'}`);
+    process.exit(1);
+  }
+
+  const archived = result.data?.archived ?? result.data?.count ?? ids.length;
+  console.log(`Archived ${archived} message${archived === 1 ? '' : 's'}. They stay searchable in All Mail.`);
+}
+
 async function gmailCommand(subcommand, ...args) {
   switch (subcommand) {
     case 'inbox':
@@ -133,10 +159,14 @@ async function gmailCommand(subcommand, ...args) {
     case 'read':
       await gmailRead(args[0]);
       break;
+    case 'archive':
+      await gmailArchive(args);
+      break;
     default:
       console.log('Gmail commands:');
       console.log('  atris gmail inbox       - List recent emails');
       console.log('  atris gmail read <id>   - Read specific email');
+      console.log('  atris gmail archive <id> [...] - Archive messages (reversible, All Mail keeps them)');
   }
 }
 
@@ -474,6 +504,58 @@ async function calendarDate(dateText) {
   await calendarRange(`Events on ${dateText}`, { timeMin: start.toISOString(), timeMax: end.toISOString() });
 }
 
+async function calendarAdd(args) {
+  // atris calendar add "Title" --date YYYY-MM-DD --from HH:MM --to HH:MM
+  //   or: --start <ISO> --end <ISO>; optional --location, --description
+  const rest = [...(args || [])];
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = String(rest[i] || '');
+    if (arg.startsWith('--')) {
+      flags[arg.slice(2)] = String(rest[i + 1] || '');
+      i += 1;
+    } else {
+      positional.push(arg);
+    }
+  }
+  const summary = positional.join(' ').trim();
+  let start = String(flags.start || '').trim();
+  let end = String(flags.end || '').trim();
+  if (!start && flags.date && flags.from) start = `${flags.date}T${flags.from}:00`;
+  if (!end && flags.date && flags.to) end = `${flags.date}T${flags.to}:00`;
+  if (!summary || !start || !end) {
+    console.error('Usage: atris calendar add "Title" --date YYYY-MM-DD --from HH:MM --to HH:MM');
+    console.error('   or: atris calendar add "Title" --start <ISO datetime> --end <ISO datetime>');
+    process.exit(1);
+  }
+
+  const token = await getAuthToken();
+
+  console.log(`Creating event: ${summary} (${start} to ${end})...`);
+
+  const body = { summary, start, end };
+  if (flags.location) body.location = flags.location;
+  if (flags.description) body.description = flags.description;
+  if (flags.timezone) body.timezone = flags.timezone;
+
+  const result = await apiRequestJson('/integrations/google-calendar/events', {
+    method: 'POST',
+    token,
+    body,
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to create event'}`);
+    process.exit(1);
+  }
+
+  const created = result.data || {};
+  console.log(`Created: ${created.summary || summary}`);
+  if (created.htmlLink) console.log(`Link: ${created.htmlLink}`);
+  console.log(`Verified on calendar: ${created.verified ? 'yes' : 'no'}`);
+}
+
 async function calendarCommand(subcommand, ...args) {
   switch (subcommand) {
     case 'today':
@@ -492,6 +574,10 @@ async function calendarCommand(subcommand, ...args) {
     case 'search':
       await calendarSearch(args);
       break;
+    case 'add':
+    case 'create':
+      await calendarAdd(args);
+      break;
     default:
       console.log('Calendar commands:');
       console.log('  atris calendar today          - Show today\'s events');
@@ -499,6 +585,7 @@ async function calendarCommand(subcommand, ...args) {
       console.log('  atris calendar week           - Show this week\'s events');
       console.log('  atris calendar date YYYY-MM-DD - Show events on a date');
       console.log('  atris calendar search <query> [--days 30] [--limit 20] [--timeout-ms 10000] [--json] - Search upcoming events');
+      console.log('  atris calendar add \"Title\" --date YYYY-MM-DD --from HH:MM --to HH:MM - Create an event');
   }
 }
 
@@ -737,6 +824,58 @@ async function slackSearch(query, args = []) {
   formatSlackMessages(messages);
 }
 
+async function slackSend(channel, textParts) {
+  const target = String(channel || '').trim();
+  const text = (textParts || []).join(' ').trim();
+  if (!target || !text) {
+    console.error('Usage: atris slack send <channel> "<message>"');
+    process.exit(1);
+  }
+
+  const token = await getAuthToken();
+
+  console.log(`Sending to ${target}...`);
+
+  const result = await apiRequestJson('/integrations/slack/me/send', {
+    method: 'POST',
+    token,
+    body: { channel: target, text },
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to send'}`);
+    process.exit(1);
+  }
+
+  console.log(`Sent to ${target} as you.`);
+}
+
+async function slackDm(userId, textParts) {
+  const target = String(userId || '').trim();
+  const text = (textParts || []).join(' ').trim();
+  if (!target || !text) {
+    console.error('Usage: atris slack dm <slack_user_id> "<message>"');
+    process.exit(1);
+  }
+
+  const token = await getAuthToken();
+
+  console.log(`Sending DM to ${target}...`);
+
+  const result = await apiRequestJson('/integrations/slack/me/dm', {
+    method: 'POST',
+    token,
+    body: { slack_user_id: target, text },
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to send DM'}`);
+    process.exit(1);
+  }
+
+  console.log(`DM sent to ${target} as you.`);
+}
+
 async function slackCommand(subcommand, ...args) {
   switch (subcommand) {
     case 'channels':
@@ -753,12 +892,20 @@ async function slackCommand(subcommand, ...args) {
     case 'search':
       await slackSearch(argsWithoutLimit(args).join(' '), args);
       break;
+    case 'send':
+      await slackSend(args[0], args.slice(1));
+      break;
+    case 'dm':
+      await slackDm(args[0], args.slice(1));
+      break;
     default:
       console.log('Slack commands:');
       console.log('  atris slack channels             - List Slack channels');
       console.log('  atris slack dms                  - List Slack DMs');
       console.log('  atris slack messages <channel>   - Read recent messages');
       console.log('  atris slack search <query>       - Search Slack messages');
+      console.log('  atris slack send <channel> "<message>" - Send a message as you');
+      console.log('  atris slack dm <user_id> "<message>"   - DM someone as you');
   }
 }