atris 3.34.0 → 3.36.0

package/commands/cloud.js

@@ -0,0 +1,245 @@
+const fs = require('fs');
+const path = require('path');
+const { loadCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+const { loadBusinesses, saveBusinesses, businessMatchesSlug } = require('./business');
+const { computeLocalHashes, isIgnoredSyncPath } = require('../lib/manifest');
+const { assertSafeWorkspaceRoot } = require('../lib/workspace-safety');
+const { isMassDeletePlan } = require('./push');
+
+const DEFAULT_DEPS = {
+  loadCredentials,
+  apiRequestJson,
+  loadBusinesses,
+  saveBusinesses,
+  computeLocalHashes,
+  isMassDeletePlan,
+};
+
+function parseCloudCleanArgs(args = []) {
+  const positional = args.filter((arg) => arg && !arg.startsWith('-'));
+  const help = args.includes('--help') || args.includes('-h') || positional[0] === 'help';
+  const subcommand = positional[0] || (help ? 'help' : 'clean');
+  const slug = positional[1] || null;
+  const dryRun = args.includes('--dry-run');
+  const yes = args.includes('--yes') || args.includes('-y');
+  const deleteAll = args.includes('--delete-all');
+  return { subcommand, slug, dryRun, yes, deleteAll, help };
+}
+
+function readCloudCleanSlug(cwd, args) {
+  const parsed = parseCloudCleanArgs(args);
+  if (parsed.slug) return parsed.slug;
+  const bizFile = path.join(cwd, '.atris', 'business.json');
+  if (fs.existsSync(bizFile)) {
+    try {
+      const biz = JSON.parse(fs.readFileSync(bizFile, 'utf8'));
+      return biz.slug || biz.name || null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+async function resolveBusinessWorkspace(token, slug, deps = {}) {
+  const d = { ...DEFAULT_DEPS, ...deps };
+  const businesses = d.loadBusinesses();
+  const listResult = await d.apiRequestJson('/business/', { method: 'GET', token });
+  if (listResult.ok) {
+    const match = (listResult.data || []).find((b) => businessMatchesSlug(b, slug, { includeName: true }));
+    if (!match) return null;
+    const { id: businessId, workspace_id: workspaceId, name: businessName, slug: resolvedSlug } = match;
+    businesses[slug] = {
+      business_id: businessId,
+      workspace_id: workspaceId,
+      name: businessName,
+      slug: resolvedSlug,
+      added_at: new Date().toISOString(),
+    };
+    d.saveBusinesses(businesses);
+    return { businessId, workspaceId, businessName, resolvedSlug };
+  }
+  if (businesses[slug]) {
+    return {
+      businessId: businesses[slug].business_id,
+      workspaceId: businesses[slug].workspace_id,
+      businessName: businesses[slug].name || slug,
+      resolvedSlug: businesses[slug].slug || slug,
+    };
+  }
+  return null;
+}
+
+function normalizeCloudPath(p) {
+  const s = String(p || '').replace(/\\/g, '/');
+  return s.startsWith('/') ? s : `/${s}`;
+}
+
+async function collectCloudOrphans(cwd, slug, deps = {}) {
+  const d = { ...DEFAULT_DEPS, ...deps };
+  const credentials = d.loadCredentials();
+  if (!credentials || !credentials.token) {
+    throw new Error('Not logged in. Run: atris login');
+  }
+  assertSafeWorkspaceRoot(cwd, { op: 'cloud clean' });
+  const resolvedSlug = slug || readCloudCleanSlug(cwd, []);
+  if (!resolvedSlug) {
+    throw new Error('No business workspace found. Run inside a business workspace or pass a business slug.');
+  }
+  const biz = await resolveBusinessWorkspace(credentials.token, resolvedSlug, d);
+  if (!biz) {
+    throw new Error(`Business "${resolvedSlug}" not found.`);
+  }
+  const localFiles = d.computeLocalHashes(cwd);
+  const result = await d.apiRequestJson(
+    `/business/${biz.businessId}/workspaces/${biz.workspaceId}/snapshot?include_content=false`,
+    { method: 'GET', token: credentials.token, timeoutMs: 120000 }
+  );
+  if (!result.ok) {
+    throw new Error(`could not list cloud files: ${result.error || result.status}`);
+  }
+  const cloudFiles = (result.data && Array.isArray(result.data.files)) ? result.data.files : [];
+  const cloudPaths = new Set();
+  for (const f of cloudFiles) {
+    if (!f || f.binary) continue;
+    const normalized = normalizeCloudPath(f.path);
+    if (!normalized) continue;
+    if (isIgnoredSyncPath(normalized)) continue;
+    if (path.basename(normalized).startsWith('.')) continue;
+    cloudPaths.add(normalized);
+  }
+  const orphanPaths = [];
+  for (const p of cloudPaths) {
+    if (!localFiles[p]) {
+      orphanPaths.push(p);
+    }
+  }
+  orphanPaths.sort();
+  return {
+    orphanPaths,
+    localCount: Object.keys(localFiles).length,
+    cloudCount: cloudPaths.size,
+    ...biz,
+  };
+}
+
+function renderCloudCleanSummary(orphanPaths, { dryRun = false, deleted = null, failed = null, localCount = 0 } = {}) {
+  const count = orphanPaths.length;
+  if (count === 0) {
+    return 'No cloud orphans found.\n';
+  }
+  const fileLabel = count === 1 ? 'file' : 'files';
+  const label = dryRun ? 'cloud clean (dry run):' : 'cloud clean:';
+  const lines = [
+    `${label} ${count} cloud ${fileLabel} not present locally:`,
+    ...orphanPaths.map((p) => `  - ${p.replace(/^\//, '')}`),
+    '',
+  ];
+  if (dryRun) {
+    lines.push('pass --yes to delete these cloud files.');
+  } else if (deleted !== null) {
+    const parts = [];
+    if (deleted > 0) parts.push(`${deleted} deleted`);
+    if (failed > 0) parts.push(`${failed} failed`);
+    if (parts.length === 0) parts.push(`${count} deleted`);
+    lines.push(`${parts.join(', ')}. local files: ${localCount}`);
+  } else {
+    lines.push('pass --yes to delete these cloud files.');
+  }
+  return lines.join('\n') + '\n';
+}
+
+async function cloudClean(args = [], cwd = process.cwd(), deps = {}) {
+  const d = { ...DEFAULT_DEPS, ...deps };
+  const options = parseCloudCleanArgs(args);
+  if (options.help || options.subcommand === 'help') {
+    return {
+      ok: true,
+      output: [
+        'Usage: atris cloud clean [business] [--dry-run] [--yes] [--delete-all]',
+        '',
+        'List or delete cloud files that are not present locally.',
+        '',
+        '  --dry-run     Preview which cloud files would be deleted',
+        '  --yes         Delete the listed cloud files',
+        '  --delete-all  Confirm a mass delete (required with --yes for large cleanups)',
+        '',
+      ].join('\n') + '\n',
+    };
+  }
+  if (options.subcommand !== 'clean') {
+    throw new Error(`Unknown cloud subcommand: ${options.subcommand}. Try: atris cloud clean --help`);
+  }
+  const slug = options.slug || readCloudCleanSlug(cwd, args);
+  if (!slug) {
+    throw new Error('No business workspace found. Run inside a business workspace or pass a business slug.');
+  }
+  const { orphanPaths, localCount, businessId, workspaceId } = await collectCloudOrphans(cwd, slug, d);
+  if (orphanPaths.length === 0) {
+    return { ok: true, output: 'No cloud orphans found.\n' };
+  }
+  if (!options.yes) {
+    return {
+      ok: true,
+      output: renderCloudCleanSummary(orphanPaths, { dryRun: options.dryRun, localCount }),
+    };
+  }
+  if (isMassDeletePlan({ deletedPaths: orphanPaths, filesToPush: [], unchangedCount: localCount }) && !options.deleteAll) {
+    throw new Error(
+      `mass delete guard: ${orphanPaths.length} cloud files would be deleted with only ${localCount} local files present.\n` +
+      'this looks like a wrong source root or empty local copy. pass --delete-all with --yes to confirm.'
+    );
+  }
+  let deleted = 0;
+  let failed = 0;
+  const credentials = d.loadCredentials();
+  for (let i = 0; i < orphanPaths.length; i++) {
+    const filePath = orphanPaths[i];
+    if (i > 0) {
+      await new Promise((r) => setTimeout(r, 600));
+    }
+    let result = await d.apiRequestJson(
+      `/business/${businessId}/workspaces/${workspaceId}/file?path=${encodeURIComponent(filePath)}`,
+      { method: 'DELETE', token: credentials.token }
+    );
+    if (result.status === 429) {
+      await new Promise((r) => setTimeout(r, 20000));
+      result = await d.apiRequestJson(
+        `/business/${businessId}/workspaces/${workspaceId}/file?path=${encodeURIComponent(filePath)}`,
+        { method: 'DELETE', token: credentials.token }
+      );
+    }
+    if (result.ok || result.status === 404) {
+      deleted++;
+    } else {
+      failed++;
+    }
+  }
+  return {
+    ok: failed === 0,
+    output: renderCloudCleanSummary(orphanPaths, { dryRun: false, deleted, failed, localCount }),
+  };
+}
+
+function cloudAtris() {
+  const args = process.argv.slice(3);
+  cloudClean(args, process.cwd())
+    .then((result) => {
+      process.stdout.write(result.output || '');
+      process.exit(result.ok ? 0 : 1);
+    })
+    .catch((err) => {
+      console.error(`\n✗ Error: ${err.message || err}`);
+      process.exit(1);
+    });
+}
+
+module.exports = {
+  cloudAtris,
+  cloudClean,
+  collectCloudOrphans,
+  parseCloudCleanArgs,
+  readCloudCleanSlug,
+  renderCloudCleanSummary,
+};

package/commands/codex-goal.js

@@ -99,11 +99,35 @@ function chmodPrivate(filePath) {
   }
 }
 
-function runSqliteJson(dbPath, sql, { readonly = true } = {}) {
+function runSqliteOnce(dbPath, sql, readonly) {
   const sqliteArgs = [];
   if (readonly) sqliteArgs.push('-readonly');
   sqliteArgs.push('-json', dbPath, sql);
-  const result = spawnSync('sqlite3', sqliteArgs, { encoding: 'utf8' });
+  return spawnSync('sqlite3', sqliteArgs, { encoding: 'utf8' });
+}
+
+function runSqliteJson(dbPath, sql, { readonly = true } = {}) {
+  let result = runSqliteOnce(dbPath, sql, readonly);
+  // Codex DBs are WAL-mode. `sqlite3 -readonly` cannot open a WAL db unless a
+  // writer already holds the -shm/-wal sidecars open (error 14 with no Codex
+  // running). Fall back to reading a private snapshot copy of db+wal.
+  const walLocked =
+    readonly &&
+    result.status !== 0 &&
+    /unable to open database file/i.test(String(result.stderr || result.stdout || ''));
+  if (walLocked) {
+    const snapDir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-codex-goal-'));
+    const snapDb = path.join(snapDir, path.basename(dbPath));
+    try {
+      fs.copyFileSync(dbPath, snapDb);
+      for (const ext of ['-wal', '-shm']) {
+        if (fs.existsSync(dbPath + ext)) fs.copyFileSync(dbPath + ext, snapDb + ext);
+      }
+      result = runSqliteOnce(snapDb, sql, false);
+    } finally {
+      fs.rmSync(snapDir, { recursive: true, force: true });
+    }
+  }
   if (result.error) throw new Error(`sqlite3 failed: ${result.error.message}`);
   if (result.status !== 0) {
     const detail = (result.stderr || result.stdout || '').trim();

package/commands/compile.js

@@ -17,12 +17,15 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
 const { execSync } = require('child_process');
 const {
   buildRunnerAvailabilityCommand,
   buildRunnerCommand,
   resolveClaudeRunnerBin,
 } = require('../lib/runner-command');
+const { apiRequestJson, getApiBaseUrl } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
 
 const DEFAULT_THRESHOLD = 0.99;
 const SAMPLE_RECORDS_FOR_BUILD = 25;
@@ -38,6 +41,10 @@ function recordsPath(root, name) {
   return path.join(root, '.atris', 'state', 'processes', name, 'records.jsonl');
 }
 
+function pushCursorPath(root, name) {
+  return path.join(root, '.atris', 'state', 'processes', name, 'push-cursor.json');
+}
+
 function manifestPath(root, name) {
   return path.join(processDir(root, name), 'process.json');
 }
@@ -134,6 +141,172 @@ function listProcesses(root) {
   return [...names].sort();
 }
 
+function readPushCursor(root, name) {
+  const p = pushCursorPath(root, name);
+  if (!fs.existsSync(p)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(p, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function writePushCursor(root, name, cursor) {
+  const p = pushCursorPath(root, name);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const tmp = `${p}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(cursor, null, 2) + '\n');
+  fs.renameSync(tmp, p);
+  return cursor;
+}
+
+function hashString(value) {
+  return crypto.createHash('sha256').update(String(value)).digest('hex');
+}
+
+function pushContextKey(ctx) {
+  return hashString(`${ctx.apiBase}\0${ctx.agentId}`);
+}
+
+function recordKey(name, index) {
+  return `compile-record-v1:${hashString(`${name}\0${index}`)}`;
+}
+
+function normalizePushCursorState(raw) {
+  if (raw && typeof raw === 'object' && raw.contexts && typeof raw.contexts === 'object' && !Array.isArray(raw.contexts)) {
+    return { version: 1, contexts: { ...raw.contexts } };
+  }
+  if (
+    raw
+    && typeof raw === 'object'
+    && typeof raw.agent_id === 'string'
+    && typeof raw.api_base === 'string'
+  ) {
+    return {
+      version: 1,
+      contexts: {
+        [pushContextKey({ agentId: raw.agent_id, apiBase: raw.api_base })]: raw,
+      },
+    };
+  }
+  return { version: 1, contexts: {} };
+}
+
+function cursorForContext(cursorState, ctx) {
+  const state = normalizePushCursorState(cursorState);
+  const cursor = state.contexts[pushContextKey(ctx)];
+  if (!cursor || cursor.agent_id !== ctx.agentId || cursor.api_base !== ctx.apiBase) return null;
+  return cursor;
+}
+
+function writePushCursorForContext(root, name, cursorState, ctx, nextRecordIndex) {
+  const state = normalizePushCursorState(cursorState);
+  state.contexts[pushContextKey(ctx)] = {
+    agent_id: ctx.agentId,
+    api_base: ctx.apiBase,
+    nextRecordIndex,
+    updatedAt: new Date().toISOString(),
+  };
+  return writePushCursor(root, name, state);
+}
+
+function requireManifest(root, name) {
+  const p = manifestPath(root, name);
+  if (!fs.existsSync(p)) {
+    throw new Error(`no manifest at ${path.relative(root, p)} - run "atris compile build ${name}" first`);
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(p, 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('manifest must be a JSON object');
+    }
+    return parsed;
+  } catch (err) {
+    throw new Error(`invalid manifest at ${path.relative(root, p)}: ${err.message}`);
+  }
+}
+
+function readRunnerSource(root, name) {
+  const p = runnerPath(root, name);
+  if (!fs.existsSync(p)) {
+    throw new Error(`no compiled artifact at ${path.relative(root, p)} - run "atris compile build ${name}" first`);
+  }
+  return fs.readFileSync(p, 'utf8');
+}
+
+function requireServerContext(flags) {
+  const agentId = typeof flags.agent === 'string' ? flags.agent.trim() : '';
+  if (!agentId) {
+    throw new Error('server compile commands require --agent <id>');
+  }
+
+  const credentials = loadCredentials();
+  if (!credentials || !credentials.token) {
+    throw new Error('Missing Atris auth. Run: atris login or set ATRIS_TOKEN, then retry.');
+  }
+
+  const apiBase = getApiBaseUrl();
+  try {
+    // Validate now so failures explain configuration instead of surfacing as
+    // opaque network errors from the request helper.
+    new URL(apiBase);
+  } catch {
+    throw new Error(`Invalid ATRIS_API_URL: ${apiBase}`);
+  }
+
+  return { agentId, token: credentials.token, apiBase };
+}
+
+function processApiPath(agentId, name, suffix = '') {
+  return `/processes/${encodeURIComponent(agentId)}/${encodeURIComponent(name)}${suffix}`;
+}
+
+function serverErrorMessage(method, pathname, result) {
+  const status = result && result.status ? `HTTP ${result.status}` : 'network error';
+  const detail = result && (result.error || result.text) ? `: ${result.error || result.text}` : '';
+  return `${method} ${pathname} failed (${status})${detail}`;
+}
+
+async function serverRequest(ctx, method, pathname, body) {
+  const options = {
+    method,
+    token: ctx.token,
+    timeoutMs: 60000,
+    retries: 0,
+  };
+  if (body !== undefined) options.body = body;
+  const result = await apiRequestJson(pathname, options);
+  if (!result || !result.ok) {
+    throw new Error(serverErrorMessage(method, pathname, result || {}));
+  }
+  return result.data || {};
+}
+
+function recordPushPayload(name, record, index) {
+  if (!record || typeof record !== 'object') {
+    throw new Error(`record ${index + 1} is not an object`);
+  }
+  if (!Object.prototype.hasOwnProperty.call(record, 'input')) {
+    throw new Error(`record ${index + 1} is missing input`);
+  }
+  if (!Object.prototype.hasOwnProperty.call(record, 'output')) {
+    throw new Error(`record ${index + 1} is missing output`);
+  }
+  const payload = { input: record.input, output: record.output, record_key: recordKey(name, index) };
+  if (Object.prototype.hasOwnProperty.call(record, 'expected')) payload.expected = record.expected;
+  if (record.source) payload.source = String(record.source);
+  return payload;
+}
+
+function cursorStartIndex(cursorState, total, ctx) {
+  const cursor = cursorForContext(cursorState, ctx);
+  if (!cursor) return 0;
+  const n = Number(cursor.nextRecordIndex);
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return Math.min(Math.floor(n), total);
+}
+
 // ── compare ────────────────────────────────────────────────────────
 
 function deepEqual(a, b) {
@@ -372,6 +545,103 @@ function printBacktest(name, result, failureCount, manifest) {
   }
 }
 
+function extractServerBacktest(data) {
+  const result = (data && data.result && typeof data.result === 'object') ? data.result : (data || {});
+  const manifest = (data && data.manifest && typeof data.manifest === 'object') ? data.manifest : {};
+  return { result, manifest };
+}
+
+function printServerBacktest(name, data, ctx) {
+  const { result, manifest } = extractServerBacktest(data);
+  const version = result.version !== undefined ? result.version : '?';
+  const passed = result.passed !== undefined ? result.passed : '?';
+  const total = result.total !== undefined ? result.total : '?';
+  const accuracy = typeof result.accuracy === 'number' ? formatAccuracy(result.accuracy) : 'unknown';
+  const threshold = typeof result.threshold === 'number' ? formatAccuracy(result.threshold) : 'unknown';
+  const status = manifest.status || result.status || 'unknown';
+  console.log(`server backtest ${name} v${version}: ${passed}/${total} passed (${accuracy}), gate ${threshold}, status ${status}`);
+  if (typeof result.accuracy === 'number' && typeof result.threshold === 'number' && result.accuracy >= result.threshold) {
+    console.log(`next: promote on server with "atris compile promote ${name} --server --agent ${ctx.agentId}"`);
+  } else {
+    console.log('next: fix records or rebuild, publish again, then promote on server when the gate passes');
+  }
+}
+
+async function publishProcessToServer(root, name, flags) {
+  const ctx = requireServerContext(flags);
+  const runJs = readRunnerSource(root, name);
+  const manifest = requireManifest(root, name);
+  const artifact = await serverRequest(ctx, 'PUT', processApiPath(ctx.agentId, name, '/artifact'), {
+    run_js: runJs,
+    manifest,
+  });
+
+  const serverStatus = artifact && artifact.manifest && artifact.manifest.status
+    ? artifact.manifest.status
+    : 'unknown';
+  console.log(`published artifact ${name} to server (${serverStatus})`);
+
+  const records = readRecords(root, name);
+  let cursorState = normalizePushCursorState(readPushCursor(root, name));
+  const startIndex = cursorStartIndex(cursorState, records.length, ctx);
+  let pushed = 0;
+  for (let i = startIndex; i < records.length; i++) {
+    await serverRequest(ctx, 'POST', processApiPath(ctx.agentId, name, '/records'), recordPushPayload(name, records[i], i));
+    pushed++;
+    cursorState = writePushCursorForContext(root, name, cursorState, ctx, i + 1);
+  }
+
+  if (records.length === 0) {
+    console.log('no local records to push');
+  } else if (pushed === 0) {
+    console.log(`records up to date (${records.length} already pushed)`);
+  } else {
+    console.log(`pushed ${pushed} new record${pushed === 1 ? '' : 's'} (${records.length} total local)`);
+  }
+
+  const backtest = await serverRequest(ctx, 'POST', processApiPath(ctx.agentId, name, '/backtest'));
+  printServerBacktest(name, backtest, ctx);
+  return { artifact, recordsPushed: pushed, backtest };
+}
+
+async function promoteProcessOnServer(root, name, flags) {
+  const ctx = requireServerContext(flags);
+  const body = {};
+  if (flags.gate !== undefined) {
+    const gate = Number(flags.gate);
+    if (!(gate > 0 && gate <= 1)) {
+      throw new Error('--gate must be between 0 and 1 (e.g. 0.99)');
+    }
+    body.gate = gate;
+  }
+  const data = await serverRequest(
+    ctx,
+    'POST',
+    processApiPath(ctx.agentId, name, '/promote'),
+    Object.keys(body).length ? body : undefined
+  );
+  const manifest = data.manifest || {};
+  const bt = manifest.backtest || {};
+  const accuracy = typeof bt.accuracy === 'number' ? formatAccuracy(bt.accuracy) : 'unknown accuracy';
+  const total = bt.total !== undefined ? `${bt.total} records` : 'server records';
+  console.log(`${name} v${manifest.version ?? '?'} server status ${manifest.status || 'unknown'} (${accuracy} over ${total})`);
+  return data;
+}
+
+async function scheduleProcessOnServer(root, name, flags) {
+  const ctx = requireServerContext(flags);
+  const cron = typeof flags.cron === 'string' ? flags.cron.trim() : '';
+  if (!cron) {
+    throw new Error('schedule needs --cron "<expr>"');
+  }
+  const input = flags.input === undefined ? null : parseValueArg(flags.input);
+  const data = await serverRequest(ctx, 'POST', processApiPath(ctx.agentId, name, '/schedule'), { cron, input });
+  const schedule = data.schedule || {};
+  const id = schedule.id || schedule.schedule_id || schedule.name || '(server did not return an id)';
+  console.log(`scheduled ${name}: ${id}`);
+  return data;
+}
+
 // ── command dispatcher ─────────────────────────────────────────────
 
 function showCompileHelp() {
@@ -392,10 +662,17 @@ function showCompileHelp() {
   console.log('  promote <name> [--gate 0.99]');
   console.log('                            mark active (gate: backtest accuracy >= threshold);');
   console.log('                            --gate is the only way to change the standing threshold');
+  console.log('  publish <name> --agent <id>');
+  console.log('                            push run.js, process.json, new records, then run server backtest');
+  console.log('  promote <name> --server --agent <id> [--gate 0.99]');
+  console.log('                            promote the server-side process');
+  console.log('  schedule <name> --agent <id> --cron "<expr>" --input \'<json|@file>\'');
+  console.log('                            schedule the server-side process');
   console.log('  exec <name> --input <json|@file> [--record]');
   console.log('                            run the compiled process on new input');
   console.log('  status [<name>] [--json]  list processes, versions, accuracy, drift');
   console.log('');
+  console.log('Server commands require --agent <id> and Atris auth from atris login or ATRIS_TOKEN.');
   console.log('Loop: record real runs -> build -> backtest -> promote -> exec --record');
   console.log('When backtest accuracy drops below the gate, the process is marked drifted');
   console.log('and a recompile is suggested — self-healing against process drift.');
@@ -414,7 +691,7 @@ async function compileCommand(subcommand, ...rawArgs) {
   // `atris compile <name>` with an existing process name = build shortcut
   let cmd = subcommand;
   let name = positional[0];
-  const subcommands = ['record', 'build', 'backtest', 'promote', 'exec', 'status'];
+  const subcommands = ['record', 'build', 'backtest', 'promote', 'publish', 'schedule', 'exec', 'status'];
   if (!subcommands.includes(subcommand)) {
     if (validName(subcommand) && listProcesses(root).includes(subcommand)) {
       cmd = 'build';
@@ -514,6 +791,10 @@ async function compileCommand(subcommand, ...rawArgs) {
   }
 
   if (cmd === 'promote') {
+    if (flags.server) {
+      await promoteProcessOnServer(root, name, flags);
+      return;
+    }
     const options = {};
     if (flags.gate !== undefined) {
       const t = Number(flags.gate);
@@ -530,6 +811,16 @@ async function compileCommand(subcommand, ...rawArgs) {
     return;
   }
 
+  if (cmd === 'publish') {
+    await publishProcessToServer(root, name, flags);
+    return;
+  }
+
+  if (cmd === 'schedule') {
+    await scheduleProcessOnServer(root, name, flags);
+    return;
+  }
+
   if (cmd === 'exec') {
     const input = parseValueArg(flags.input);
     if (input === undefined) {