atris 3.35.0 → 3.36.0

package/lib/orb-scorecard.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_DAYS = 7;
+
+function emptyOrbScorecard(days = DEFAULT_DAYS) {
+  return {
+    days,
+    picks: 0,
+    dispatches: 0,
+    dispatches_by_kind: {},
+    dispatches_by_engine: {},
+    ok: 0,
+    fail: 0,
+    orphaned: 0,
+    completion_rate: null,
+    median_duration_ms: null,
+    failures: [],
+    orphans: [],
+  };
+}
+
+function readText(file) {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function readJsonl(file) {
+  const rows = [];
+  for (const line of readText(file).split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (row && typeof row === 'object') rows.push(row);
+    } catch {}
+  }
+  return rows;
+}
+
+function sortedCounts(values) {
+  const counts = new Map();
+  for (const value of values) {
+    const key = typeof value === 'string' && value.trim() ? value.trim() : 'unknown';
+    counts.set(key, (counts.get(key) || 0) + 1);
+  }
+  return Object.fromEntries([...counts.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
+
+function median(values) {
+  const numbers = values.filter((value) => Number.isFinite(value) && value >= 0).sort((a, b) => a - b);
+  if (!numbers.length) return null;
+  const middle = Math.floor(numbers.length / 2);
+  return numbers.length % 2 === 1
+    ? numbers[middle]
+    : (numbers[middle - 1] + numbers[middle]) / 2;
+}
+
+function readOrbPicks(root, cutoffDay, today) {
+  let picks = 0;
+  for (const line of readText(path.join(root, 'now.md')).split(/\r?\n/)) {
+    const match = line.match(/^orb:\s+.+\s+·\s+(\d{4}-\d{2}-\d{2})\s*$/);
+    if (match && match[1] >= cutoffDay && match[1] <= today) picks += 1;
+  }
+  return picks;
+}
+
+function pidIsAlive(pid) {
+  const numericPid = Number(pid);
+  if (!Number.isInteger(numericPid) || numericPid <= 0) return false;
+  try {
+    process.kill(numericPid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function pairOrbRuns(records) {
+  const terminalsByLogPath = new Map();
+  for (const row of records) {
+    if (row.status === 'dispatched') continue;
+    const logPath = String(row.logPath || '');
+    const terminals = terminalsByLogPath.get(logPath) || [];
+    terminals.push(row);
+    terminalsByLogPath.set(logPath, terminals);
+  }
+
+  const consumedTerminals = new Set();
+  const runs = [];
+  const orphans = [];
+  for (const row of records) {
+    if (row.status !== 'dispatched') continue;
+    const terminals = terminalsByLogPath.get(String(row.logPath || '')) || [];
+    const terminal = terminals.find((candidate) => !consumedTerminals.has(candidate));
+    if (terminal) {
+      consumedTerminals.add(terminal);
+      runs.push({ ...row, ...terminal, status: terminal.status });
+      continue;
+    }
+    const orphaned = !pidIsAlive(row.pid);
+    runs.push({ ...row, orphaned });
+    if (orphaned) orphans.push({ ...row, orphaned: true });
+  }
+
+  for (const row of records) {
+    if (row.status !== 'dispatched' && !consumedTerminals.has(row)) runs.push(row);
+  }
+  return { runs, orphans };
+}
+
+function readOrbScorecard(root, { days = DEFAULT_DAYS, now = Date.now() } = {}) {
+  const windowDays = Number(days);
+  if (!Number.isInteger(windowDays) || windowDays < 1) {
+    throw new Error('orb scorecard days must be a positive integer');
+  }
+  const nowMs = now instanceof Date ? now.getTime() : Number(now);
+  if (!Number.isFinite(nowMs)) throw new Error('orb scorecard now must be a valid time');
+
+  const scorecard = emptyOrbScorecard(windowDays);
+  const cutoffMs = nowMs - (windowDays * DAY_MS);
+  const cutoffDay = new Date(cutoffMs).toISOString().slice(0, 10);
+  const today = new Date(nowMs).toISOString().slice(0, 10);
+  scorecard.picks = readOrbPicks(root, cutoffDay, today);
+
+  const indexPath = path.join(root, '.atris', 'state', 'orb-runs', 'index.jsonl');
+  const records = readJsonl(indexPath).filter((row) => {
+    const ts = Date.parse(String(row.ts || ''));
+    return Number.isFinite(ts) && ts >= cutoffMs && ts <= nowMs;
+  });
+  const paired = pairOrbRuns(records);
+  const runs = paired.runs;
+  const terminalRuns = runs.filter((row) => row.status !== 'dispatched');
+
+  scorecard.dispatches = runs.length;
+  scorecard.dispatches_by_kind = sortedCounts(runs.map((row) => row.kind));
+  scorecard.dispatches_by_engine = sortedCounts(runs.map((row) => row.engine));
+  scorecard.ok = terminalRuns.filter((row) => Number(row.exitCode) === 0).length;
+  scorecard.fail = terminalRuns.filter((row) => Number(row.exitCode) !== 0).length + paired.orphans.length;
+  scorecard.orphaned = paired.orphans.length;
+  const outcomes = scorecard.ok + scorecard.fail;
+  scorecard.completion_rate = outcomes ? scorecard.ok / outcomes : null;
+  scorecard.median_duration_ms = median(terminalRuns.map((row) => Number(row.durationMs)));
+  scorecard.failures = terminalRuns
+    .filter((row) => Number(row.exitCode) !== 0)
+    .map((row) => ({
+      ts: row.ts,
+      label: row.label,
+      kind: row.kind,
+      engine: row.engine,
+      exitCode: Number(row.exitCode),
+      durationMs: Number(row.durationMs),
+      logPath: row.logPath,
+      error: row.error || null,
+    }));
+  scorecard.orphans = paired.orphans.map((row) => ({
+    ts: row.ts,
+    label: row.label,
+    kind: row.kind,
+    engine: row.engine,
+    logPath: row.logPath,
+    pid: Number(row.pid),
+    status: row.status,
+  }));
+  return scorecard;
+}
+
+function formatCounts(counts) {
+  const entries = Object.entries(counts || {});
+  return entries.length ? entries.map(([key, count]) => `${key} ${count}`).join(', ') : 'none';
+}
+
+function renderOrbScorecard(scorecard) {
+  const rate = scorecard.completion_rate == null
+    ? 'n/a'
+    : `${(scorecard.completion_rate * 100).toFixed(1)}%`;
+  const duration = scorecard.median_duration_ms == null
+    ? 'n/a'
+    : `${scorecard.median_duration_ms} ms`;
+  return [
+    `orb scorecard: ${scorecard.days} days`,
+    `picks: ${scorecard.picks}`,
+    `dispatches: ${scorecard.dispatches}`,
+    `by kind: ${formatCounts(scorecard.dispatches_by_kind)}`,
+    `by engine: ${formatCounts(scorecard.dispatches_by_engine)}`,
+    `outcomes: ${scorecard.ok} ok, ${scorecard.fail} fail`,
+    `orphaned: ${scorecard.orphaned}`,
+    `completion rate: ${rate}`,
+    `median duration: ${duration}`,
+  ].join('\n');
+}
+
+function parseOrbScorecardDays(args = []) {
+  let raw = String(DEFAULT_DAYS);
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--days') {
+      raw = args[index + 1];
+      index += 1;
+    } else if (String(arg).startsWith('--days=')) {
+      raw = String(arg).slice('--days='.length);
+    }
+  }
+  const days = Number(raw);
+  if (!Number.isInteger(days) || days < 1) {
+    return { ok: false, error: `invalid --days value: ${raw == null ? '(missing)' : raw}` };
+  }
+  return { ok: true, days };
+}
+
+module.exports = {
+  DAY_MS,
+  DEFAULT_DAYS,
+  emptyOrbScorecard,
+  readOrbScorecard,
+  renderOrbScorecard,
+  parseOrbScorecardDays,
+};

package/lib/policy-lessons.js

@@ -16,6 +16,7 @@ const POLICY_LESSONS_FILE = path.join('.atris', 'state', 'policy_lessons.json');
 const CAREER_XP_RECEIPTS_FILE = path.join('.atris', 'state', 'career_xp_receipts.jsonl');
 const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
 const SCORECARDS_FILE = path.join('.atris', 'state', 'scorecards.jsonl');
+const DAY_MS = 24 * 60 * 60 * 1000;
 
 // Review actors that are agents, not the human gate. Mining must split the
 // two: agent self-review churn and human accept/bounce are different signals.
@@ -93,6 +94,7 @@ function mineProofPolicy(history, opts = {}) {
   const { receipts = [], episodes = [], scorecards = [] } = history || {};
   const minHumanReviewed = Number.isFinite(opts.minHumanReviewed) ? opts.minHumanReviewed : 10;
   const now = opts.now instanceof Date ? opts.now : new Date();
+  const orbWindowDays = Number.isInteger(opts.orbWindowDays) && opts.orbWindowDays > 0 ? opts.orbWindowDays : 7;
 
   const reviewed = episodes.filter((e) => e && e.rl && e.action && e.action.actor);
   const humanReviewed = reviewed.filter((e) => !isAgentActor(e.action.actor));
@@ -117,6 +119,15 @@ function mineProofPolicy(history, opts = {}) {
 
   const improveTicks = scorecards.filter((s) => s && s.schema === 'atris.improve_tick.v1');
   const brainScorecards = scorecards.filter((s) => s && s.schema === 'atris.brain.scorecard.v1');
+  const orbFailures = scorecards.filter((s) => s
+    && s.schema === 'atris.improve_tick.v1'
+    && s.source === 'orb'
+    && Number(s.orb_exit_code) !== 0);
+  const orbCutoff = now.getTime() - (orbWindowDays * DAY_MS);
+  const recentOrbFailures = orbFailures.filter((row) => {
+    const ts = Date.parse(String(row.ts || ''));
+    return Number.isFinite(ts) && ts >= orbCutoff && ts <= now.getTime();
+  });
   const avgReward = (rows) => (rows.length
     ? Math.round((rows.reduce((sum, r) => sum + (Number(r.reward) || 0), 0) / rows.length) * 100) / 100
     : null);
@@ -139,6 +150,11 @@ function mineProofPolicy(history, opts = {}) {
       total: scorecards.length,
       improve_ticks: { count: improveTicks.length, avg_reward: avgReward(improveTicks) },
       brain: { count: brainScorecards.length, avg_reward: avgReward(brainScorecards) },
+      orb: {
+        failures: orbFailures.length,
+        recent_failures: recentOrbFailures.length,
+        window_days: orbWindowDays,
+      },
     },
   };
 
@@ -173,6 +189,41 @@ function mineProofPolicy(history, opts = {}) {
     });
   }
 
+  if (recentOrbFailures.length > 0) {
+    const samples = recentOrbFailures.slice(0, 3).map((row) => {
+      const label = String(row.what_shipped || '').replace(/^orb job failed:\s*/i, '') || 'unlabelled job';
+      const logPath = row.orb_log_path || '.atris/state/orb-runs/index.jsonl';
+      return `${label} (${row.orb_engine || 'unknown'} exit ${row.orb_exit_code}, \`${logPath}\`)`;
+    });
+    const extra = recentOrbFailures.length > samples.length ? `, plus ${recentOrbFailures.length - samples.length} more` : '';
+    lessons.push({
+      id: 'orb-job-failures',
+      status: 'fail',
+      hint_when: null,
+      lesson: `${recentOrbFailures.length} orb job failure${recentOrbFailures.length === 1 ? '' : 's'} landed in the last ${orbWindowDays} days: ${samples.join('; ')}${extra}. Treat each log as an improvement candidate: inspect it, repair \`commands/orb.js\` dispatch or the picked job, then rerun the pick.`,
+      evidence: {
+        source: 'scorecards.orb_failure',
+        window_days: orbWindowDays,
+        failures: recentOrbFailures.map((row) => ({
+          ts: row.ts,
+          label: String(row.what_shipped || '').replace(/^orb job failed:\s*/i, ''),
+          engine: row.orb_engine,
+          exit_code: row.orb_exit_code,
+          log_path: row.orb_log_path,
+          next_task: row.next_task_suggestion,
+        })),
+      },
+    });
+  } else if (orbFailures.length > 0) {
+    lessons.push({
+      id: 'orb-job-failures',
+      status: 'pass',
+      hint_when: null,
+      lesson: `No orb job failures remain in the last ${orbWindowDays} days; the prior failure window aged out.`,
+      evidence: { source: 'scorecards.orb_failure', window_days: orbWindowDays, failures: [] },
+    });
+  }
+
   return {
     schema: 'atris.policy_lessons.v1',
     mined_at: now.toISOString(),
@@ -243,7 +294,7 @@ function syncLessonsMd(root, mined) {
   const today = (mined.mined_at || new Date().toISOString()).split('T')[0];
   const lines = (mined.lessons || []).map((lesson) => ({
     id: lesson.id,
-    line: `- **[${today}] policy-${lesson.id}** — pass — ${lesson.lesson} (mined from ${mined.sources.career_xp_receipts} receipts / ${mined.sources.task_episodes} episodes / ${mined.sources.scorecards} scorecards)`,
+    line: `- **[${today}] policy-${lesson.id}** — ${lesson.status || 'pass'} — ${lesson.lesson} (mined from ${mined.sources.career_xp_receipts} receipts / ${mined.sources.task_episodes} episodes / ${mined.sources.scorecards} scorecards)`,
   }));
   if (!lines.length) return { path: lessonsPath, written: [] };
 

package/lib/pulse.js

@@ -13,14 +13,18 @@
 // command (commands/pulse.js) wires it to the engine and the cron shell.
 
 const fs = require('fs');
+const crypto = require('crypto');
+const os = require('os');
 const path = require('path');
 const { DEFAULT_CLAUDE_RUNNER_MODEL } = require('./runner-command');
+const { readOrbScorecard } = require('./orb-scorecard');
 
 const PULSE_RECEIPT_SCHEMA = 'atris.pulse_tick.v1';
 // Reuse the improve-tick scorecard schema so the brain + policy-lessons see
 // pulse reward as fresh feedback signal (source:'pulse' keeps it attributable).
 const SCORECARD_SCHEMA = 'atris.improve_tick.v1';
 const PULSE_MARKER = 'ATRIS_PULSE_SELF_IMPROVE';
+const LEGACY_STATE_DIRNAME = 'atris-cli-self-improve';
 // Hourly at an off-clock minute (avoid :00/:30 fleet sync). Each tick spawns a
 // real worker + full verify, so default conservative; raise with --cadence.
 const DEFAULT_CADENCE_CRON = '23 * * * *';
@@ -47,6 +51,77 @@ function pulseLockDir(root) {
   return path.join(stateDir(root), 'pulse.lock');
 }
 
+// --- install slot identity ---
+
+function safeSlugPart(value) {
+  const cleaned = String(value || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return cleaned || 'repo';
+}
+
+function pulseRepoSlug(root) {
+  const absoluteRoot = path.resolve(root || process.cwd());
+  const base = safeSlugPart(path.basename(absoluteRoot));
+  const hash = crypto.createHash('sha256').update(absoluteRoot).digest('hex').slice(0, 6);
+  return `${base}-${hash}`;
+}
+
+function pulseStateHome(root, homeDir = os.homedir()) {
+  return path.join(homeDir, '.atris', 'overnight', `pulse-${pulseRepoSlug(root)}`);
+}
+
+function pulseMarker(root) {
+  return `ATRIS_PULSE_${pulseRepoSlug(root).toUpperCase().replace(/[^A-Z0-9]+/g, '_')}`;
+}
+
+function legacyPulseStateHome(homeDir = os.homedir()) {
+  return path.join(homeDir, '.atris', 'overnight', LEGACY_STATE_DIRNAME);
+}
+
+function readTickScriptRoot(stateHome) {
+  try {
+    const script = fs.readFileSync(path.join(stateHome, 'tick.sh'), 'utf8');
+    const match = script.match(/^ROOT=(?:"([^"\n]*)"|'([^'\n]*)'|([^\s\n]+))/m);
+    if (!match) return null;
+    return match[1] || match[2] || match[3] || null;
+  } catch {
+    return null;
+  }
+}
+
+function legacyPulseStateMatchesRoot(root, homeDir = os.homedir()) {
+  const legacyStateHome = legacyPulseStateHome(homeDir);
+  const scriptRoot = readTickScriptRoot(legacyStateHome);
+  if (!scriptRoot) return false;
+  return path.resolve(scriptRoot) === path.resolve(root || process.cwd());
+}
+
+function resolvePulseSlot(root, options = {}) {
+  const homeDir = options.homeDir || os.homedir();
+  const stateHome = pulseStateHome(root, homeDir);
+  const marker = pulseMarker(root);
+  const legacyStateHome = legacyPulseStateHome(homeDir);
+  const legacyMatches = legacyPulseStateMatchesRoot(root, homeDir);
+  const hasStateHome = fs.existsSync(stateHome);
+  const activeStateHome = legacyMatches && !hasStateHome ? legacyStateHome : stateHome;
+  const activeMarker = legacyMatches && !hasStateHome ? PULSE_MARKER : marker;
+  const markers = legacyMatches ? [marker, PULSE_MARKER] : [marker];
+  return {
+    slug: pulseRepoSlug(root),
+    stateHome,
+    marker,
+    activeStateHome,
+    activeMarker,
+    legacyStateHome,
+    legacyMarker: PULSE_MARKER,
+    legacyMatches,
+    markers,
+  };
+}
+
 // --- receipt + scorecard building (pure) ---
 
 function buildPulseReceipt(input = {}) {
@@ -65,6 +140,9 @@ function buildPulseReceipt(input = {}) {
     elapsed_ms: input.elapsedMs != null ? input.elapsedMs : null,
     prev_tick_stale: input.prevTickStale != null ? input.prevTickStale : false,
     reward: input.reward != null ? input.reward : null,
+    orb_scorecard: input.orbScorecard || null,
+    improvement_candidates: Array.isArray(input.improvementCandidates) ? input.improvementCandidates : [],
+    orb_ingest_error: input.orbIngestError || null,
   };
 }
 
@@ -83,6 +161,98 @@ function buildPulseScorecardRow(input = {}) {
     model_used: input.model || null,
     task_id: input.taskId || null,
     elapsed_ms: input.elapsedMs != null ? input.elapsedMs : null,
+    orb_scorecard: input.orbScorecard || null,
+    improvement_candidates: Array.isArray(input.improvementCandidates) ? input.improvementCandidates : [],
+  };
+}
+
+function orbRunKey(run = {}) {
+  return [run.ts, run.logPath, run.engine, run.label].map((value) => String(value || '')).join('|');
+}
+
+function orbFailureCandidate(run = {}, mode = 'orb_failure') {
+  const label = String(run.label || 'unlabelled orb job');
+  const engine = String(run.engine || 'unknown engine');
+  const exitCode = Number.isFinite(Number(run.exitCode)) ? Number(run.exitCode) : 1;
+  const logPath = String(run.logPath || '.atris/state/orb-runs/index.jsonl');
+  const orphaned = mode === 'orb_orphan';
+  return {
+    source: 'orb',
+    label,
+    engine,
+    exit_code: exitCode,
+    log_path: logPath,
+    next_task: orphaned
+      ? `investigate orphaned orb job "${label}" from ${engine}; open ${logPath}`
+      : `investigate failed orb job "${label}" from ${engine} exit ${exitCode}; open ${logPath}`,
+  };
+}
+
+function buildOrbFailureScorecardRow(run = {}, mode = 'orb_failure') {
+  const candidate = orbFailureCandidate(run, mode);
+  const orphaned = mode === 'orb_orphan';
+  const parsedTs = Date.parse(String(run.ts || ''));
+  return {
+    schema: SCORECARD_SCHEMA,
+    ts: Number.isFinite(parsedTs) ? new Date(parsedTs).toISOString() : new Date().toISOString(),
+    source: 'orb',
+    member: 'pulse',
+    mode,
+    reward: -1,
+    verify_passed: false,
+    credits_deducted: 0,
+    what_shipped: `orb job ${orphaned ? 'orphaned' : 'failed'}: ${candidate.label}`,
+    files_written: [],
+    model_used: candidate.engine,
+    task_id: null,
+    elapsed_ms: Number.isFinite(Number(run.durationMs)) ? Number(run.durationMs) : null,
+    next_task_suggestion: candidate.next_task,
+    orb_run_key: orbRunKey(run),
+    orb_kind: run.kind || 'unknown',
+    orb_engine: candidate.engine,
+    orb_exit_code: candidate.exit_code,
+    orb_log_path: candidate.log_path,
+    orb_error: run.error || null,
+  };
+}
+
+function orbSummaryForRail(scorecard) {
+  return {
+    days: scorecard.days,
+    picks: scorecard.picks,
+    dispatches: scorecard.dispatches,
+    dispatches_by_kind: scorecard.dispatches_by_kind,
+    dispatches_by_engine: scorecard.dispatches_by_engine,
+    ok: scorecard.ok,
+    fail: scorecard.fail,
+    orphaned: scorecard.orphaned,
+    completion_rate: scorecard.completion_rate,
+    median_duration_ms: scorecard.median_duration_ms,
+  };
+}
+
+function ingestOrbScorecard(root, options = {}) {
+  const scorecard = readOrbScorecard(root, options);
+  const existing = readJsonl(scorecardsPath(root));
+  const seen = new Set(existing.filter((row) => row && row.orb_run_key).map((row) => row.orb_run_key));
+  const written = [];
+  const actionableRuns = [
+    ...scorecard.failures.map((run) => ({ run, mode: 'orb_failure' })),
+    ...scorecard.orphans.map((run) => ({ run, mode: 'orb_orphan' })),
+  ];
+  for (const { run, mode } of actionableRuns) {
+    const row = buildOrbFailureScorecardRow(run, mode);
+    if (seen.has(row.orb_run_key)) continue;
+    appendScorecard(root, row);
+    seen.add(row.orb_run_key);
+    written.push(row);
+  }
+  return {
+    summary: orbSummaryForRail(scorecard),
+    improvement_candidates: actionableRuns.map(({ run, mode }) => orbFailureCandidate(run, mode)),
+    scorecards_written: written.length,
+    written,
+    historical_failures: existing.filter((row) => row && row.source === 'orb' && ['orb_failure', 'orb_orphan'].includes(row.mode)).length + written.length,
   };
 }
 
@@ -130,6 +300,68 @@ function shouldWriteScorecard({ reward } = {}) {
   return reward !== 0;
 }
 
+// --- non-git work detection ---
+//
+// A workspace without .git made producedWork permanently false (git snapshots
+// return an empty delta), so every tick scored 0 regardless of what the engine
+// wrote — the loop was blind, not idle. When git is absent, pulse falls back to
+// a filesystem snapshot: path → mtime+size, excluding churn dirs.
+
+const FS_SNAPSHOT_SKIP = new Set(['.git', 'node_modules', '.atris']);
+const FS_SNAPSHOT_MAX_ENTRIES = 20000;
+
+function fsSnapshot(root) {
+  const entries = new Map();
+  const walk = (dir, rel) => {
+    if (entries.size >= FS_SNAPSHOT_MAX_ENTRIES) return;
+    let names;
+    try {
+      names = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const d of names) {
+      if (entries.size >= FS_SNAPSHOT_MAX_ENTRIES) return;
+      if (FS_SNAPSHOT_SKIP.has(d.name)) continue;
+      const abs = path.join(dir, d.name);
+      const r = rel ? `${rel}/${d.name}` : d.name;
+      if (d.isDirectory()) walk(abs, r);
+      else if (d.isFile()) {
+        try {
+          const st = fs.statSync(abs);
+          entries.set(r, `${st.mtimeMs}:${st.size}`);
+        } catch {}
+      }
+    }
+  };
+  walk(root, '');
+  return entries;
+}
+
+// New or modified files between two fsSnapshots. Deletions are ignored — the
+// signal we need is "did the tick author anything", not a full diff.
+function diffFsSnapshots(before, after) {
+  const changed = [];
+  for (const [rel, sig] of after) {
+    if (before.get(rel) !== sig) changed.push(rel);
+  }
+  return changed.sort();
+}
+
+// The verify default must match the workspace. Defaulting to `npm test` in a
+// root with no package.json guaranteed -1 on any productive tick; a package.json
+// with no "test" script did the same (18 straight -1 ticks in atrisos-backend).
+function defaultVerifyCmd(root) {
+  const pkgPath = path.join(root, 'package.json');
+  if (!fs.existsSync(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg && pkg.scripts && typeof pkg.scripts.test === 'string' ? 'npm test' : null;
+  } catch {
+    return null;
+  }
+}
+
 // --- ghost / stale detection (pure) ---
 
 // Pair started+finished by tick_index; any 'started' with no 'finished' partner
@@ -365,7 +597,9 @@ function buildTickScript(opts = {}) {
   if (!root) throw new Error('buildTickScript: root is required');
   if (!stateHome) throw new Error('buildTickScript: stateHome is required');
   if (!deadlineEpoch) throw new Error('buildTickScript: deadlineEpoch is required');
-  const safeVerify = String(verifyCmd).replace(/'/g, "'\\''");
+  // A null verifyCmd (e.g. non-npm workspace) omits --verify so the tick
+  // resolves the workspace-appropriate default at run time.
+  const safeVerify = verifyCmd == null ? null : String(verifyCmd).replace(/'/g, "'\\''");
   const runnerModelExport = runnerEnvAliasExport({
     genericName: 'ATRIS_RUNNER_MODEL',
     legacyName: 'ATRIS_CLAUDE_MODEL',
@@ -412,6 +646,14 @@ now="$(date +%s)"
 if [ "$now" -ge "$DEADLINE_EPOCH" ]; then
   crontab -l 2>/dev/null | grep -v "$MARKER" | crontab - 2>/dev/null || true
   echo "$(date -Iseconds) pulse expired; removed cron" >> "$LOG_DIR/control.log"
+  expired_at="$(date -Iseconds)"
+  journal_year="$(date +%Y)"
+  journal_day="$(date +%F)"
+  journal_file="$ROOT/atris/logs/$journal_year/$journal_day.md"
+  mkdir -p "$ROOT/atris/logs/$journal_year" || true
+  printf '%s pulse heartbeat expired; renew with: atris pulse install\\n' "$expired_at" >> "$journal_file" || true
+  mkdir -p "$ROOT/.atris/state" || true
+  printf '{"expired_at":"%s","state_home":"%s","renew_command":"atris pulse install"}\\n' "$expired_at" "$STATE" >> "$ROOT/.atris/state/pulse-expired.json" || true
   exit 0
 fi
 
@@ -428,8 +670,26 @@ ${runnerBinExport}
 ${runnerCommandTemplateExport}
 export ATRIS_SKIP_UPDATE_CHECK=1
 
-"$ATRIS" pulse tick --json --verify '${safeVerify}' >> "$log" 2>&1
-echo "done: $(date -Iseconds) exit=$?" >> "$log"
+"$ATRIS" pulse tick --json${safeVerify == null ? '' : ` --verify '${safeVerify}'`} >> "$log" 2>&1
+tick_status=$?
+
+# runDaily no-ops via last_run_date after the first daily run.
+# hourly invocation is safe because repeated calls do no work.
+"$ATRIS" experiments daily >> "$log" 2>&1 || true
+echo "done: $(date -Iseconds) exit=$tick_status" >> "$log"
+
+# Ticks commit locally but nothing reaches the remote without this: push any
+# commits the loop has landed since the last successful push.
+if [ -e "$ROOT/.git" ]; then
+  branch="$(git -C "$ROOT" rev-parse --abbrev-ref HEAD 2>/dev/null)"
+  if [ -n "$branch" ] && [ "$branch" != "HEAD" ]; then
+    ahead="$(git -C "$ROOT" rev-list --count "origin/$branch..$branch" 2>/dev/null || echo 0)"
+    if [ "$ahead" -gt 0 ]; then
+      git -C "$ROOT" push origin "$branch" >> "$log" 2>&1
+      echo "pushed $ahead commit(s) to origin/$branch: $(date -Iseconds)" >> "$log"
+    fi
+  fi
+fi
 `;
 }
 
@@ -443,18 +703,32 @@ module.exports = {
   PULSE_RECEIPT_SCHEMA,
   SCORECARD_SCHEMA,
   PULSE_MARKER,
+  LEGACY_STATE_DIRNAME,
   DEFAULT_CADENCE_CRON,
   STALE_TICK_MS,
   LIVENESS_STALE_MS,
   stateDir,
+  pulseRepoSlug,
+  pulseStateHome,
+  pulseMarker,
+  legacyPulseStateHome,
+  readTickScriptRoot,
+  legacyPulseStateMatchesRoot,
+  resolvePulseSlot,
   pulseReceiptsPath,
   scorecardsPath,
   pulseCounterPath,
   pulseLockDir,
   buildPulseReceipt,
   buildPulseScorecardRow,
+  buildOrbFailureScorecardRow,
   buildInterruptedPulseReceipt,
+  ingestOrbScorecard,
+  orbRunKey,
   scoreTick,
+  fsSnapshot,
+  diffFsSnapshots,
+  defaultVerifyCmd,
   normalizeExpiryDuration,
   shouldWriteScorecard,
   shouldFallbackToAutopilot,