atris 3.38.0 → 3.41.0

package/commands/member.js

@@ -7,6 +7,8 @@ const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 const { runAliveTick } = require('../lib/member-alive');
 const { defaultObjectiveRunner } = require('../lib/default-runner');
+const { readJson, writeJson } = require('../lib/json-file');
+const { hasFlag, readFlag, readNumberFlag } = require('../lib/arg-parser');
 
 function findWorkspaceBusinessId(startDir = process.cwd()) {
   let dir = path.resolve(startDir);
@@ -93,27 +95,6 @@ function parseConfirmFlag(flags) {
   return joined.match(/--confirm[=\s]+["']?([^"']+)["']?/)?.[1] || '';
 }
 
-function hasFlag(args, name) {
-  return args.includes(name);
-}
-
-function readFlag(args, name, fallback = '') {
-  const prefix = `${name}=`;
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === name && args[i + 1] && !String(args[i + 1]).startsWith('--')) return args[i + 1];
-    if (String(arg).startsWith(prefix)) return String(arg).slice(prefix.length).replace(/^["']|["']$/g, '');
-  }
-  return fallback;
-}
-
-function readNumberFlag(args, name, fallback = null) {
-  const raw = readFlag(args, name, '');
-  if (!raw) return fallback;
-  const value = Number(raw);
-  return Number.isFinite(value) ? value : null;
-}
-
 function readRepeatedFlag(args, name) {
   const values = [];
   const prefix = `${name}=`;
@@ -365,17 +346,12 @@ function emptyMemberGoals(name) {
 }
 
 function loadMemberGoals(name, paths = memberPaths(name)) {
-  if (!fs.existsSync(paths.goalsJson)) return emptyMemberGoals(name);
-  try {
-    const parsed = JSON.parse(fs.readFileSync(paths.goalsJson, 'utf8'));
-    return {
-      ...emptyMemberGoals(name),
-      ...parsed,
-      goals: Array.isArray(parsed.goals) ? parsed.goals : [],
-    };
-  } catch {
-    return emptyMemberGoals(name);
-  }
+  const parsed = readJson(paths.goalsJson, {}) || {};
+  return {
+    ...emptyMemberGoals(name),
+    ...parsed,
+    goals: Array.isArray(parsed.goals) ? parsed.goals : [],
+  };
 }
 
 function activeGoal(goalsState, goalId = '') {
@@ -1411,7 +1387,7 @@ function taskIsClosed(task) {
 
 function taskProjectionRows() {
   const projectionPath = path.join(process.cwd(), '.atris', 'state', 'tasks.projection.json');
-  const projection = readJsonIfExists(projectionPath);
+  const projection = readJson(projectionPath);
   return Array.isArray(projection?.tasks) ? projection.tasks : [];
 }
 
@@ -1511,7 +1487,7 @@ function sortEvidenceCandidates(candidates) {
 
 function readTaskProjectionEvidence(name) {
   const projectionPath = path.join(process.cwd(), '.atris', 'state', 'tasks.projection.json');
-  const projection = readJsonIfExists(projectionPath);
+  const projection = readJson(projectionPath);
   const tasks = taskProjectionRows();
   const candidates = sortEvidenceCandidates(
     tasks
@@ -1663,7 +1639,7 @@ function latestActionableUserLine(thread) {
 function readMemberRoomEvidence(name) {
   const roots = [path.join(process.cwd(), '.obelisk', 'threads')];
   const projectsPath = path.join(os.homedir(), '.obelisk', 'projects.json');
-  const projects = readJsonIfExists(projectsPath);
+  const projects = readJson(projectsPath);
   if (Array.isArray(projects)) {
     const cwd = path.resolve(process.cwd());
     const project = projects.find((item) => item?.path && path.resolve(item.path) === cwd && item.id);
@@ -1676,7 +1652,7 @@ function readMemberRoomEvidence(name) {
     for (const item of listThreadJsonFiles(root)) {
       if (seen.has(item.path)) continue;
       seen.add(item.path);
-      const thread = readJsonIfExists(item.path);
+      const thread = readJson(item.path);
       files_checked += 1;
       const context = thread?.atrisContext || {};
       const linkedTasks = Array.isArray(context.linkedTasks) ? context.linkedTasks : [];
@@ -1717,11 +1693,11 @@ function readMemberRoomEvidence(name) {
 }
 
 function readRecentWakeReceiptEvidence(name) {
-  const latestLoop = readJsonIfExists(memberLoopPaths(name).latestPath);
+  const latestLoop = readJson(memberLoopPaths(name).latestPath);
   const receiptPath = Array.isArray(latestLoop?.tick_receipts)
     ? latestLoop.tick_receipts.slice().reverse().find(Boolean)
     : null;
-  const latestWake = receiptPath ? readJsonIfExists(receiptPath) : null;
+  const latestWake = receiptPath ? readJson(receiptPath) : null;
   return {
     latest_loop_path: memberLoopPaths(name).latestPath,
     latest_loop_status: latestLoop?.status || null,
@@ -1863,7 +1839,7 @@ function problemSignalSources(root = process.cwd()) {
 
 function rowsFromProblemSignalSource(source) {
   if (source.kind === 'jsonl') return readJsonlRowsIfExists(source.path, 80);
-  const row = readJsonIfExists(source.path);
+  const row = readJson(source.path);
   return row ? [row] : [];
 }
 
@@ -1984,7 +1960,7 @@ function readMemberSignalSourceConfig(root = process.cwd()) {
     path.join(root, '.atris', 'member-signal-sources.json'),
   ];
   for (const configPath of candidates) {
-    const config = readJsonIfExists(configPath);
+    const config = readJson(configPath);
     if (config && typeof config === 'object') return { config, configPath };
   }
   return { config: null, configPath: null };
@@ -2839,7 +2815,7 @@ function installMemberAliveCron(name, args = []) {
     stop_command: `atris member alive ${name} --uninstall`,
     error,
   };
-  writeJsonFile(paths.latestPath, payload);
+  writeJson(paths.latestPath, payload);
   printJsonOrText(payload, [
     `${dryRun ? 'Would install' : installed ? 'Installed' : 'Install failed'} hourly alive loop: ${name}`,
     `Cron: ${crontabLine}`,
@@ -2907,14 +2883,6 @@ function writeMemberLoopReceipt(name, payload) {
   return receiptPath;
 }
 
-function readJsonIfExists(filePath) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
 function isPidAlive(pid) {
   const numeric = Number(pid);
   if (!Number.isFinite(numeric) || numeric <= 0) return false;
@@ -2926,11 +2894,6 @@ function isPidAlive(pid) {
   }
 }
 
-function writeJsonFile(filePath, payload) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2) + '\n', 'utf8');
-}
-
 function safeReadText(filePath, maxBytes = 250000) {
   try {
     const stat = fs.statSync(filePath);
@@ -2941,14 +2904,6 @@ function safeReadText(filePath, maxBytes = 250000) {
   }
 }
 
-function safeReadJson(filePath) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
 function repoRelative(root, filePath) {
   return path.relative(root, filePath).replace(/\\/g, '/');
 }
@@ -3162,7 +3117,7 @@ function autoImproverTaskWaitingForHuman(task, status) {
 
 function collectAutoImproverTaskSignals(root) {
   const projectionPath = path.join(root, '.atris', 'state', 'tasks.projection.json');
-  const projection = safeReadJson(projectionPath);
+  const projection = readJson(projectionPath);
   const tasks = Array.isArray(projection?.tasks) ? projection.tasks : [];
   const openStatuses = new Set(['open', 'todo', 'claimed', 'doing', 'in_progress', 'review', 'blocked']);
   const staleTasks = [];
@@ -3476,7 +3431,7 @@ function autoImproverTaskIsActionable(task) {
 }
 
 function findExistingAutoImproverTask(title) {
-  const projection = safeReadJson(path.join(process.cwd(), '.atris', 'state', 'tasks.projection.json'));
+  const projection = readJson(path.join(process.cwd(), '.atris', 'state', 'tasks.projection.json'));
   const tasks = Array.isArray(projection?.tasks) ? projection.tasks : [];
   const key = lowerCompact(stripAutoImproverTitleNoise(title));
   if (!key) return null;
@@ -3554,9 +3509,9 @@ function createAutoImproverTask(candidate, receiptPath) {
 
 function writeAutoImproverReceipt(name, payload, receiptPath = null) {
   const finalReceiptPath = receiptPath || path.join(process.cwd(), 'atris', 'runs', `auto-improver-dogfood-${fileSafeStamp()}.json`);
-  writeJsonFile(finalReceiptPath, payload);
+  writeJson(finalReceiptPath, payload);
   const latestPath = path.join(process.cwd(), '.atris', 'state', 'auto-improver-dogfood-latest.json');
-  writeJsonFile(latestPath, { ...payload, receipt_path: finalReceiptPath });
+  writeJson(latestPath, { ...payload, receipt_path: finalReceiptPath });
   return { receiptPath: finalReceiptPath, latestPath };
 }
 
@@ -3646,7 +3601,7 @@ async function runAutoImproverWake(name, paths, { execute = false, confirmed = f
         : 'No bounded prevented-fire task was created yet.',
     },
   };
-  const previousLatest = safeReadJson(path.join(process.cwd(), '.atris', 'state', 'auto-improver-dogfood-latest.json'));
+  const previousLatest = readJson(path.join(process.cwd(), '.atris', 'state', 'auto-improver-dogfood-latest.json'));
   const finalWrite = writeAutoImproverReceipt(name, payload, plannedReceiptPath);
   // A no-op scan identical to the previous tick earns a receipt but not a journal entry —
   // the cadence loop was appending the same "found: N, prevented: 0" row every ~4 minutes
@@ -3731,7 +3686,7 @@ function acquireMemberLoopLease(name, { runId, ttlMs }) {
     return writeLease();
   } catch (error) {
     if (error.code !== 'EEXIST') throw error;
-    const active = readJsonIfExists(paths.lockPath);
+    const active = readJson(paths.lockPath);
     const expired = active && Number(active.expires_at_ms || 0) <= nowMs;
     const deadPid = active && !isPidAlive(active.pid);
     if (active && (expired || deadPid)) {
@@ -3749,7 +3704,7 @@ function acquireMemberLoopLease(name, { runId, ttlMs }) {
 }
 
 function refreshMemberLoopLease(paths, lease, ttlMs) {
-  writeJsonFile(paths.lockPath, {
+  writeJson(paths.lockPath, {
     ...lease,
     heartbeat_at: stampIso(),
     expires_at_ms: Date.now() + ttlMs,
@@ -3757,7 +3712,7 @@ function refreshMemberLoopLease(paths, lease, ttlMs) {
 }
 
 function releaseMemberLoopLease(paths, lease) {
-  const active = readJsonIfExists(paths.lockPath);
+  const active = readJson(paths.lockPath);
   if (!active || active.run_id !== lease.run_id || active.pid !== lease.pid) return;
   fs.rmSync(paths.lockPath, { force: true });
 }
@@ -3772,11 +3727,11 @@ function activeMemberLoopLease(lease) {
 function archiveMemberLoopState(name) {
   const paths = memberLoopPaths(name);
   const archivedAt = stampIso();
-  const previousLease = readJsonIfExists(paths.lockPath);
+  const previousLease = readJson(paths.lockPath);
   const activeLease = activeMemberLoopLease(previousLease);
   fs.mkdirSync(paths.stateDir, { recursive: true });
   if (activeLease) {
-    writeJsonFile(paths.stopPath, {
+    writeJson(paths.stopPath, {
       schema: 'atris.member_loop_stop.v1',
       member: name,
       requested_at: archivedAt,
@@ -3801,7 +3756,7 @@ function archiveMemberLoopState(name) {
     stop_path: paths.stopPath,
     latest_path: paths.latestPath,
   };
-  writeJsonFile(paths.latestPath, payload);
+  writeJson(paths.latestPath, payload);
   return payload;
 }
 
@@ -4323,6 +4278,16 @@ function memberUpgrade(name) {
 
 // --- PUSH subcommand ---
 
+function readMemberPushBusinessBinding(root = process.cwd()) {
+  const file = path.join(root, '.atris', 'business.json');
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (e) {
+    throw new Error(`Failed to read .atris/business.json: ${e.message || e}`);
+  }
+}
+
 async function memberPush(name) {
   if (!name) {
     console.error('Usage: atris member push <name>');
@@ -4346,6 +4311,9 @@ async function memberPush(name) {
   const content = fs.readFileSync(memberFile, 'utf8');
   const fm = parseFrontmatter(content);
   const existingAgentId = fm && fm['agent-id'];
+  const taskDb = require('../lib/task-db');
+  const binding = readMemberPushBusinessBinding(taskDb.workspaceRoot());
+  const businessId = String(binding && (binding.business_id || binding.id) || '').trim();
 
   if (existingAgentId) {
     console.log(`Pushing member "${name}" to cloud (updating agent ${existingAgentId})...`);
@@ -4353,7 +4321,9 @@ async function memberPush(name) {
     console.log(`Pushing member "${name}" to cloud (creating new agent)...`);
   }
 
-  const businessId = findWorkspaceBusinessId();
+  if (!businessId) {
+    console.log('no business binding found; run `atris business init "<name>" --here` to bind this workspace.');
+  }
   const endpoint = businessId
     ? `/agent/import-member?business_id=${encodeURIComponent(businessId)}`
     : '/agent/import-member';
@@ -7295,52 +7265,218 @@ function workspaceSnapshot(name = null, paths = null) {
   }
 }
 
+// Shared mission summary every wake decision carries. The mission-gate and generalist
+// rules coerce a falsy North Star to null (pre-gate we cannot trust the mission file yet).
+function wakeMissionSummary(purpose, { coerceNorthStarNull = false } = {}) {
+  return {
+    north_star: coerceNorthStarNull ? (purpose.northStar || null) : purpose.northStar,
+    runtime_id: purpose.runtimeMission.id || null,
+    runtime_status: purpose.runtimeMission.status || null,
+    runtime_next: purpose.runtimeMission.next || null,
+  };
+}
+
+// Merge a rule's verdict (decision/reason/ask/next_command + who owns it) with the
+// context every decision reports. Key order matters: callers serialize this to JSON.
+function composeWakeDecision(ctx, verdict) {
+  const result = {
+    decision: verdict.decision,
+    reason: verdict.reason,
+    needs_user: Boolean(verdict.needs_user),
+    ask: verdict.ask || null,
+    next_command: verdict.next_command,
+    state: ctx.state,
+    goal: verdict.goal,
+    current_experiment: verdict.current_experiment,
+  };
+  if ('autonomous_problem' in verdict) result.autonomous_problem = verdict.autonomous_problem;
+  result.checks = ctx.checks;
+  result.mission = verdict.mission || wakeMissionSummary(ctx.purpose);
+  result.steering = ctx.steering;
+  result.evidence = ctx.evidence;
+  result.workspace = ctx.workspace;
+  return result;
+}
+
+// Rule: a generalist with a meaningful mission processes dropped domain files before
+// anything else. Fires before evidence collection, so it returns a complete decision
+// with its own checks and no workspace snapshot.
+function wakeRuleGeneralistDomainFile(name, { purpose, steering, state, goal, current }) {
+  if (lowerCompact(name) !== 'generalist' || !purpose.meaningful) return null;
+  const domainFile = findUnprocessedGeneralistDomainFile(process.cwd());
+  if (!domainFile) return null;
+  return {
+    decision: 'process_domain_file',
+    reason: `generalist_domain_scan:${domainFile.status}`,
+    needs_user: false,
+    ask: null,
+    next_command: `atris member wake ${name} --execute --domain-file ${domainFile.path} --json`,
+    state,
+    goal: goal || null,
+    current_experiment: current || null,
+    checks: {
+      has_member: true,
+      has_mission: true,
+      mission_meaningful: true,
+      has_goal: Boolean(goal),
+      has_open_experiment: Boolean(current),
+      has_unprocessed_domain_file: true,
+      domain_scan_window_minutes: 60,
+      checked_existing_tasks: false,
+    },
+    mission: wakeMissionSummary(purpose, { coerceNorthStarNull: true }),
+    steering,
+    evidence: {
+      generalist_domain_scan: domainFile,
+      task_projection: null,
+      nearest_open_loop: null,
+    },
+    workspace: null,
+    domain_file: domainFile,
+  };
+}
+
+// Rule: a member without a meaningful mission asks the operator before waking itself.
+function wakeRuleMissionGate(ctx) {
+  if (ctx.purpose.meaningful) return null;
+  return {
+    decision: 'ask',
+    reason: 'mission_missing_or_placeholder',
+    needs_user: true,
+    ask: `Define atris/team/${ctx.name}/MISSION.md with a concrete North Star before this member wakes itself.`,
+    next_command: `edit atris/team/${ctx.name}/MISSION.md`,
+    goal: ctx.goal || null,
+    current_experiment: ctx.current || null,
+    mission: wakeMissionSummary(ctx.purpose, { coerceNorthStarNull: true }),
+  };
+}
+
+// Rule: log-error discovery that asks for a task gets one opened autonomously.
+function wakeRuleAutonomousErrorTask(ctx) {
+  const discoveredTask = ctx.evidence.problem_discovery?.selected || null;
+  if (!discoveredTask) return null;
+  if (discoveredTask.source !== 'log_error_scan' || discoveredTask.autonomous_action !== 'create_task') return null;
+  return {
+    decision: 'create_task',
+    reason: 'autonomous_error_discovery:log_error_scan',
+    next_command: discoveredTask.next_command,
+    goal: ctx.goal || null,
+    current_experiment: ctx.current || null,
+    autonomous_problem: discoveredTask,
+  };
+}
+
+// Rule: no active goal — adopt a discovered problem as the objective, else stop.
+function wakeRuleNeedsGoal(ctx) {
+  if (ctx.goal) return null;
+  const discoveredProblem = ctx.evidence.problem_discovery?.selected || null;
+  if (discoveredProblem) {
+    return {
+      decision: 'set_objective',
+      reason: `autonomous_problem_discovery:${discoveredProblem.source}`,
+      next_command: discoveredProblem.next_command || `atris member wake ${ctx.name} --execute --confirm-autonomy-policy`,
+      goal: null,
+      current_experiment: null,
+      autonomous_problem: discoveredProblem,
+    };
+  }
+  return {
+    decision: 'stop',
+    reason: 'no_active_goal',
+    next_command: `atris member goal-from-mission ${ctx.name}`,
+    goal: null,
+    current_experiment: null,
+    autonomous_problem: null,
+  };
+}
+
+// Rule: a blocked experiment needs operator input before another wake.
+function wakeRuleBlockedExperiment(ctx) {
+  if (!ctx.blocked) return null;
+  return {
+    decision: 'ask',
+    reason: 'blocked_experiment',
+    needs_user: true,
+    ask: ctx.blocked.block?.ask || 'Needs operator input before another wake.',
+    next_command: `atris member review ${ctx.name} ${ctx.blocked.id} --discard --proof "..."`,
+    goal: ctx.goal,
+    current_experiment: ctx.blocked,
+  };
+}
+
+// Rule: an open reviewable proposal parks the member until review. Skip the wait when
+// the only thing "open" is an unreviewable fallback proposal; otherwise the member is
+// parked forever on a gate no reviewer can clear.
+function wakeRuleOpenReviewableProposal(ctx) {
+  if (!ctx.current || experimentIsUnreviewable(ctx.current)) return null;
+  return {
+    decision: 'wait',
+    reason: `open_experiment_${ctx.current.status}`,
+    next_command: `atris member review ${ctx.name} ${ctx.current.id} --accept --proof "..." --value 4`,
+    goal: ctx.goal,
+    current_experiment: ctx.current,
+  };
+}
+
+// Rule: the scored candidate list can steer the wake somewhere other than a tick.
+function wakeRuleScoredNonTickCandidate(ctx) {
+  const selected = ctx.wakeScores.selected;
+  if (!selected || selected.decision === 'tick') return null;
+  const needsUser = selected.decision === 'ask';
+  return {
+    decision: selected.decision,
+    reason: selected.reason,
+    needs_user: needsUser,
+    ask: needsUser ? (selected.ask || `Need operator input for ${selected.title}.`) : null,
+    next_command: selected.next_command,
+    goal: ctx.goal,
+    current_experiment: null,
+  };
+}
+
+// Rule: dirty files inside the member's own scope gate the wake unless forced.
+function wakeRuleDirtyMemberScope(ctx) {
+  if (ctx.workspace.clean_for_member || ctx.force) return null;
+  return {
+    decision: 'wait',
+    reason: 'workspace_dirty_in_member_scope',
+    next_command: `commit/stash files in atris/team/${ctx.name}/ (or member scope) — or rerun: atris member wake ${ctx.name} --force`,
+    goal: ctx.goal,
+    current_experiment: null,
+  };
+}
+
+// Rule: nothing blocks the member, so take the safe next bounded step.
+function wakeRuleSafeBoundedTick(ctx) {
+  return {
+    decision: 'tick',
+    reason: 'safe_next_bounded_step',
+    next_command: `atris member tick ${ctx.name} --goal ${ctx.goal.id}`,
+    goal: ctx.goal,
+    current_experiment: null,
+  };
+}
+
+// Ordered decision list: the first rule that speaks wins. Order is the contract.
+const WAKE_DECISION_RULES = [
+  wakeRuleMissionGate,
+  wakeRuleAutonomousErrorTask,
+  wakeRuleNeedsGoal,
+  wakeRuleBlockedExperiment,
+  wakeRuleOpenReviewableProposal,
+  wakeRuleScoredNonTickCandidate,
+  wakeRuleDirtyMemberScope,
+  wakeRuleSafeBoundedTick,
+];
+
 function wakeDecision(name, paths, { force = false, runtimeKind = memberRuntimeKind(name) } = {}) {
   const purpose = missionPurpose(paths);
   const steering = readSteeringMemory(paths, name);
   const state = loadMemberGoals(name, paths);
   const goal = activeGoal(state);
   const current = memberOpenExperiment(state);
-  const isGeneralist = lowerCompact(name) === 'generalist';
-  if (isGeneralist && purpose.meaningful) {
-    const domainFile = findUnprocessedGeneralistDomainFile(process.cwd());
-    if (domainFile) {
-      return {
-        decision: 'process_domain_file',
-        reason: `generalist_domain_scan:${domainFile.status}`,
-        needs_user: false,
-        ask: null,
-        next_command: `atris member wake ${name} --execute --domain-file ${domainFile.path} --json`,
-        state,
-        goal: goal || null,
-        current_experiment: current || null,
-        checks: {
-          has_member: true,
-          has_mission: true,
-          mission_meaningful: true,
-          has_goal: Boolean(goal),
-          has_open_experiment: Boolean(current),
-          has_unprocessed_domain_file: true,
-          domain_scan_window_minutes: 60,
-          checked_existing_tasks: false,
-        },
-        mission: {
-          north_star: purpose.northStar || null,
-          runtime_id: purpose.runtimeMission.id || null,
-          runtime_status: purpose.runtimeMission.status || null,
-          runtime_next: purpose.runtimeMission.next || null,
-        },
-        steering,
-        evidence: {
-          generalist_domain_scan: domainFile,
-          task_projection: null,
-          nearest_open_loop: null,
-        },
-        workspace: null,
-        domain_file: domainFile,
-      };
-    }
-  }
+  const generalistDecision = wakeRuleGeneralistDomainFile(name, { purpose, steering, state, goal, current });
+  if (generalistDecision) return generalistDecision;
   const rawDirective = steeringWakeDirective(steering, name, goal);
   const directiveClosure = rawDirective ? steeringDirectiveClosure(rawDirective) : null;
   const directive = directiveClosure?.all_closed ? null : rawDirective;
@@ -7383,219 +7519,12 @@ function wakeDecision(name, paths, { force = false, runtimeKind = memberRuntimeK
     next_command: wakeScores.selected.next_command,
   } : null;
 
-  if (!purpose.meaningful) {
-    const ask = `Define atris/team/${name}/MISSION.md with a concrete North Star before this member wakes itself.`;
-    return {
-      decision: 'ask',
-      reason: 'mission_missing_or_placeholder',
-      needs_user: true,
-      ask,
-      next_command: `edit atris/team/${name}/MISSION.md`,
-      state,
-      goal: goal || null,
-      current_experiment: current || null,
-      checks,
-      mission: {
-        north_star: purpose.northStar || null,
-        runtime_id: purpose.runtimeMission.id || null,
-        runtime_status: purpose.runtimeMission.status || null,
-        runtime_next: purpose.runtimeMission.next || null,
-      },
-      steering,
-      evidence,
-      workspace,
-    };
-  }
-
-  const discoveredTask = evidence.problem_discovery?.selected || null;
-  if (discoveredTask?.source === 'log_error_scan' && discoveredTask.autonomous_action === 'create_task') {
-    return {
-      decision: 'create_task',
-      reason: 'autonomous_error_discovery:log_error_scan',
-      needs_user: false,
-      ask: null,
-      next_command: discoveredTask.next_command,
-      state,
-      goal: goal || null,
-      current_experiment: current || null,
-      autonomous_problem: discoveredTask,
-      checks,
-      mission: {
-        north_star: purpose.northStar,
-        runtime_id: purpose.runtimeMission.id || null,
-        runtime_status: purpose.runtimeMission.status || null,
-        runtime_next: purpose.runtimeMission.next || null,
-      },
-      steering,
-      evidence,
-      workspace,
-    };
-  }
-
-  if (!goal) {
-    const discoveredProblem = evidence.problem_discovery?.selected || null;
-    if (discoveredProblem) {
-      return {
-        decision: 'set_objective',
-        reason: `autonomous_problem_discovery:${discoveredProblem.source}`,
-        needs_user: false,
-        ask: null,
-        next_command: discoveredProblem.next_command || `atris member wake ${name} --execute --confirm-autonomy-policy`,
-        state,
-        goal: null,
-        current_experiment: null,
-        autonomous_problem: discoveredProblem,
-        checks,
-        mission: {
-          north_star: purpose.northStar,
-          runtime_id: purpose.runtimeMission.id || null,
-          runtime_status: purpose.runtimeMission.status || null,
-          runtime_next: purpose.runtimeMission.next || null,
-        },
-        steering,
-        evidence,
-        workspace,
-      };
-    }
-    return {
-      decision: 'stop',
-      reason: 'no_active_goal',
-      needs_user: false,
-      ask: null,
-      next_command: `atris member goal-from-mission ${name}`,
-      state,
-      goal: null,
-      current_experiment: null,
-      autonomous_problem: null,
-      checks,
-      mission: {
-        north_star: purpose.northStar,
-        runtime_id: purpose.runtimeMission.id || null,
-        runtime_status: purpose.runtimeMission.status || null,
-        runtime_next: purpose.runtimeMission.next || null,
-      },
-      steering,
-      evidence,
-      workspace,
-    };
+  const ctx = { name, force, purpose, steering, state, goal, current, blocked, evidence, workspace, checks, wakeScores };
+  for (const rule of WAKE_DECISION_RULES) {
+    const verdict = rule(ctx);
+    if (verdict) return composeWakeDecision(ctx, verdict);
   }
-
-  if (blocked) {
-    return {
-      decision: 'ask',
-      reason: 'blocked_experiment',
-      needs_user: true,
-      ask: blocked.block?.ask || 'Needs operator input before another wake.',
-      next_command: `atris member review ${name} ${blocked.id} --discard --proof "..."`,
-      state,
-      goal,
-      current_experiment: blocked,
-      checks,
-      mission: {
-        north_star: purpose.northStar,
-        runtime_id: purpose.runtimeMission.id || null,
-        runtime_status: purpose.runtimeMission.status || null,
-        runtime_next: purpose.runtimeMission.next || null,
-      },
-      steering,
-      evidence,
-      workspace,
-    };
-  }
-
-  // Skip the wait when the only thing "open" is an unreviewable fallback proposal;
-  // otherwise the member is parked forever on a gate no reviewer can clear.
-  if (current && !experimentIsUnreviewable(current)) {
-    return {
-      decision: 'wait',
-      reason: `open_experiment_${current.status}`,
-      needs_user: false,
-      ask: null,
-      next_command: `atris member review ${name} ${current.id} --accept --proof "..." --value 4`,
-      state,
-      goal,
-      current_experiment: current,
-      checks,
-      mission: {
-        north_star: purpose.northStar,
-        runtime_id: purpose.runtimeMission.id || null,
-        runtime_status: purpose.runtimeMission.status || null,
-        runtime_next: purpose.runtimeMission.next || null,
-      },
-      steering,
-      evidence,
-      workspace,
-    };
-  }
-
-  if (wakeScores.selected && wakeScores.selected.decision !== 'tick') {
-    const selected = wakeScores.selected;
-    const needsUser = selected.decision === 'ask';
-    return {
-      decision: selected.decision,
-      reason: selected.reason,
-      needs_user: needsUser,
-      ask: needsUser ? (selected.ask || `Need operator input for ${selected.title}.`) : null,
-      next_command: selected.next_command,
-      state,
-      goal,
-      current_experiment: null,
-      checks,
-      mission: {
-        north_star: purpose.northStar,
-        runtime_id: purpose.runtimeMission.id || null,
-        runtime_status: purpose.runtimeMission.status || null,
-        runtime_next: purpose.runtimeMission.next || null,
-      },
-      steering,
-      evidence,
-      workspace,
-    };
-  }
-
-  if (!workspace.clean_for_member && !force) {
-    return {
-      decision: 'wait',
-      reason: 'workspace_dirty_in_member_scope',
-      needs_user: false,
-      ask: null,
-      next_command: `commit/stash files in atris/team/${name}/ (or member scope) — or rerun: atris member wake ${name} --force`,
-      state,
-      goal,
-      current_experiment: null,
-      checks,
-      mission: {
-        north_star: purpose.northStar,
-        runtime_id: purpose.runtimeMission.id || null,
-        runtime_status: purpose.runtimeMission.status || null,
-        runtime_next: purpose.runtimeMission.next || null,
-      },
-      steering,
-      evidence,
-      workspace,
-    };
-  }
-
-  return {
-    decision: 'tick',
-    reason: 'safe_next_bounded_step',
-    needs_user: false,
-    ask: null,
-    next_command: `atris member tick ${name} --goal ${goal.id}`,
-    state,
-    goal,
-    current_experiment: null,
-    checks,
-    mission: {
-      north_star: purpose.northStar,
-      runtime_id: purpose.runtimeMission.id || null,
-      runtime_status: purpose.runtimeMission.status || null,
-      runtime_next: purpose.runtimeMission.next || null,
-    },
-    steering,
-    evidence,
-    workspace,
-  };
+  return null;
 }
 
 async function runMemberWake(name, { execute = false, confirmed = false, force = false, domainInput = {} } = {}) {
@@ -8029,84 +7958,60 @@ function memberAliveAll(...args) {
   return memberLoopAll('alive', ...args);
 }
 
-async function memberLoop(name, ...args) {
-  if (name === '--all' || name === 'all') return memberLoopAll('loop', ...args);
-  requireMemberDir(name);
-  const asJson = hasFlag(args, '--json');
-  const aliveMode = hasFlag(args, '--alive');
-  const execute = hasFlag(args, '--execute');
-  const confirmed = hasFlag(args, '--confirm-autonomy-policy');
-  const force = hasFlag(args, '--force');
-  const stop = hasFlag(args, '--stop');
-  const status = hasFlag(args, '--status');
-  const agentFlag = String(readFlag(args, '--agent', '') || '').trim().toLowerCase();
-  const agent = agentFlag === 'claude' ? 'claude' : agentFlag === 'codex' ? 'codex' : undefined;
-  const model = String(readFlag(args, '--model', '') || '').trim() || undefined;
-  const operateMaxWall = Math.max(60, Math.min(1800, Number(readNumberFlag(args, '--operate-max-wall', readNumberFlag(args, '--max-wall', 900)))));
-  const autoAcceptLimit = Math.max(1, Math.floor(Number(readNumberFlag(args, '--auto-accept-limit', 8))));
-  const paths = memberLoopPaths(name);
-  fs.mkdirSync(paths.stateDir, { recursive: true });
-
-  if (hasFlag(args, '--install')) {
-    return installMemberAliveCron(name, args);
-  }
-
-  if (hasFlag(args, '--uninstall')) {
-    return uninstallMemberAliveCron(name, args);
-  }
-
-  if (status) {
-    const active = readJsonIfExists(paths.lockPath);
-    const latest = readJsonIfExists(paths.latestPath);
-    const payload = {
-      ok: true,
-      action: 'loop_status',
-      member: name,
-      active: Boolean(active && Number(active.expires_at_ms || 0) > Date.now() && isPidAlive(active.pid)),
-      lease: active || null,
-      latest: latest || null,
-      hourly_alive: memberAliveCronStatus(name, paths),
-      lock_path: paths.lockPath,
-      latest_path: paths.latestPath,
-    };
-    printJsonOrText(payload, [
-      `Loop status: ${name}`,
-      `Active: ${payload.active ? 'yes' : 'no'}`,
-      `Hourly: ${payload.hourly_alive.installed ? 'installed' : payload.hourly_alive.script_exists ? 'script ready' : 'not installed'}`,
-      `Latest: ${latest?.receipt_path ? path.relative(process.cwd(), latest.receipt_path) : 'none'}`,
-    ], asJson);
-    return;
-  }
+// Loop phase: report lease + latest-receipt state without touching anything.
+function memberLoopStatusReport(name, paths, asJson) {
+  const active = readJson(paths.lockPath);
+  const latest = readJson(paths.latestPath);
+  const payload = {
+    ok: true,
+    action: 'loop_status',
+    member: name,
+    active: Boolean(active && Number(active.expires_at_ms || 0) > Date.now() && isPidAlive(active.pid)),
+    lease: active || null,
+    latest: latest || null,
+    hourly_alive: memberAliveCronStatus(name, paths),
+    lock_path: paths.lockPath,
+    latest_path: paths.latestPath,
+  };
+  printJsonOrText(payload, [
+    `Loop status: ${name}`,
+    `Active: ${payload.active ? 'yes' : 'no'}`,
+    `Hourly: ${payload.hourly_alive.installed ? 'installed' : payload.hourly_alive.script_exists ? 'script ready' : 'not installed'}`,
+    `Latest: ${latest?.receipt_path ? path.relative(process.cwd(), latest.receipt_path) : 'none'}`,
+  ], asJson);
+}
 
-  if (stop) {
-    const requestedAt = stampIso();
-    const stopPayload = {
-      schema: 'atris.member_loop_stop.v1',
-      member: name,
-      requested_at: requestedAt,
-      pid: process.pid,
-    };
-    writeJsonFile(paths.stopPath, stopPayload);
-    const receiptPath = writeMemberLoopReceipt(name, {
-      ok: true,
-      action: 'loop_stop',
-      member: name,
-      requested_at: requestedAt,
-      stop_path: paths.stopPath,
-    });
-    printJsonOrText({
-      ok: true,
-      action: 'loop_stop',
-      member: name,
-      stop_path: paths.stopPath,
-      receipt_path: receiptPath,
-    }, [
-      `Stop requested for ${name}.`,
-      `Receipt: ${path.relative(process.cwd(), receiptPath)}`,
-    ], asJson);
-    return;
-  }
+// Loop phase: drop a stop file so the running loop breaks at its next tick boundary.
+function memberLoopRequestStop(name, paths, asJson) {
+  const requestedAt = stampIso();
+  const stopPayload = {
+    schema: 'atris.member_loop_stop.v1',
+    member: name,
+    requested_at: requestedAt,
+    pid: process.pid,
+  };
+  writeJson(paths.stopPath, stopPayload);
+  const receiptPath = writeMemberLoopReceipt(name, {
+    ok: true,
+    action: 'loop_stop',
+    member: name,
+    requested_at: requestedAt,
+    stop_path: paths.stopPath,
+  });
+  printJsonOrText({
+    ok: true,
+    action: 'loop_stop',
+    member: name,
+    stop_path: paths.stopPath,
+    receipt_path: receiptPath,
+  }, [
+    `Stop requested for ${name}.`,
+    `Receipt: ${path.relative(process.cwd(), receiptPath)}`,
+  ], asJson);
+}
 
+// Loop phase: derive the timing plan (tick count, interval, duration, lease ttl) from flags.
+function memberLoopTimingPlan(name, args, { execute, confirmed }) {
   const ticksFlag = readNumberFlag(args, '--ticks', null);
   const minutes = readNumberFlag(args, '--minutes', null);
   const durationSeconds = readNumberFlag(args, '--duration-seconds', readNumberFlag(args, '--seconds', null));
@@ -8137,183 +8042,190 @@ async function memberLoop(name, ...args) {
     forever ? intervalMs + (2 * 60 * 60 * 1000) : durationMs + 60000,
     intervalMs + 60000,
   );
+  return { ticksFlag, hourly, forever, intervalMs, durationMs, ticks, runId, startedAt, ttlMs };
+}
 
-  if (execute && !confirmed) {
-    const receiptPath = writeMemberLoopReceipt(name, {
-      ok: false,
-      action: 'loop',
-      member: name,
-      status: 'blocked',
-      reason: 'execute_requires_confirm_autonomy_policy',
-      mode: 'execute',
-      started_at: startedAt,
-      finished_at: stampIso(),
-    });
-    const payload = {
-      ok: false,
-      action: 'loop',
-      member: name,
-      status: 'blocked',
-      reason: 'execute_requires_confirm_autonomy_policy',
-      receipt_path: receiptPath,
-    };
-    writeJsonFile(paths.latestPath, payload);
-    printJsonOrText(payload, [
-      `Loop blocked for ${name}: execute requires --confirm-autonomy-policy.`,
-      `Receipt: ${path.relative(process.cwd(), receiptPath)}`,
-    ], asJson);
-    process.exitCode = 1;
-    return;
-  }
+// Loop phase: refuse to execute without the autonomy confirmation, with a receipt saying why.
+function memberLoopRefuseUnconfirmed(name, paths, { asJson, startedAt }) {
+  const receiptPath = writeMemberLoopReceipt(name, {
+    ok: false,
+    action: 'loop',
+    member: name,
+    status: 'blocked',
+    reason: 'execute_requires_confirm_autonomy_policy',
+    mode: 'execute',
+    started_at: startedAt,
+    finished_at: stampIso(),
+  });
+  const payload = {
+    ok: false,
+    action: 'loop',
+    member: name,
+    status: 'blocked',
+    reason: 'execute_requires_confirm_autonomy_policy',
+    receipt_path: receiptPath,
+  };
+  writeJson(paths.latestPath, payload);
+  printJsonOrText(payload, [
+    `Loop blocked for ${name}: execute requires --confirm-autonomy-policy.`,
+    `Receipt: ${path.relative(process.cwd(), receiptPath)}`,
+  ], asJson);
+  process.exitCode = 1;
+}
 
-  const lease = acquireMemberLoopLease(name, { runId, ttlMs });
-  if (!lease.acquired) {
-    const receiptPath = writeMemberLoopReceipt(name, {
-      ok: true,
-      action: 'loop',
-      member: name,
-      status: 'skipped',
-      reason: 'loop_already_active',
-      mode: execute ? 'execute' : 'dry_run',
-      active_lease: lease.lease || null,
-      started_at: startedAt,
-      finished_at: stampIso(),
-    });
-    const payload = {
-      ok: true,
-      action: 'loop',
-      member: name,
-      status: 'skipped',
-      reason: 'loop_already_active',
-      ticks: 0,
-      receipt_path: receiptPath,
-      active_lease: lease.lease || null,
-    };
-    writeJsonFile(paths.latestPath, payload);
-    printJsonOrText(payload, [
-      `Loop skipped for ${name}: another loop is active.`,
-      `Receipt: ${path.relative(process.cwd(), receiptPath)}`,
-    ], asJson);
-    return;
-  }
+// Loop phase: another loop holds the lease, so skip this run and leave a receipt behind.
+function memberLoopSkipAlreadyActive(name, paths, lease, { asJson, execute, startedAt }) {
+  const receiptPath = writeMemberLoopReceipt(name, {
+    ok: true,
+    action: 'loop',
+    member: name,
+    status: 'skipped',
+    reason: 'loop_already_active',
+    mode: execute ? 'execute' : 'dry_run',
+    active_lease: lease.lease || null,
+    started_at: startedAt,
+    finished_at: stampIso(),
+  });
+  const payload = {
+    ok: true,
+    action: 'loop',
+    member: name,
+    status: 'skipped',
+    reason: 'loop_already_active',
+    ticks: 0,
+    receipt_path: receiptPath,
+    active_lease: lease.lease || null,
+  };
+  writeJson(paths.latestPath, payload);
+  printJsonOrText(payload, [
+    `Loop skipped for ${name}: another loop is active.`,
+    `Receipt: ${path.relative(process.cwd(), receiptPath)}`,
+  ], asJson);
+}
+
+// Tick phase (alive mode): run the full operate pipeline once and record what it did.
+function memberLoopAliveTick(name, run, index, tickStartedAt) {
+  const { options, state } = run;
+  const alive = runAliveTick(name, {
+    execute: options.execute,
+    confirmed: options.confirmed,
+    force: options.force,
+    agent: options.agent,
+    model: options.model,
+    maxWallSeconds: options.operateMaxWall,
+    autoAcceptLimit: options.autoAcceptLimit,
+    noPrime: index > 0,
+  });
+  const key = `${alive.status || 'alive'}:${alive.reason || 'tick'}`;
+  state.decisions[key] = (state.decisions[key] || 0) + 1;
+  const tick = {
+    tick: index + 1,
+    started_at: tickStartedAt,
+    finished_at: alive.finished_at || stampIso(),
+    ok: alive.ok !== false,
+    decision: alive.status || 'alive_tick',
+    reason: alive.reason || null,
+    executed: options.execute,
+    needs_user: alive.needs_user === true,
+    next_command: alive.next_command || null,
+    has_mission: alive.has_mission === true,
+    has_goal: alive.has_goal === true,
+    has_steering: false,
+    productive: alive.status === 'completed',
+    blocked_on_human: alive.blocked_on_human === true,
+    operate_ok: alive.operate?.ok,
+    auto_accept_accepted: alive.auto_accept?.json?.summary?.accepted ?? alive.auto_accept?.json?.summary?.would_accept,
+    receipt_path: alive.receipt_path || alive.operate?.receipt_path || null,
+    alive,
+  };
+  state.tickResults.push(tick);
+  fs.appendFileSync(state.tickLogPath, JSON.stringify(tick) + '\n', 'utf8');
+}
+
+// Tick phase (wake mode): take one wake decision, record it, and notice a member stuck
+// re-asking the same question so the loop can hand off instead of burning remaining ticks.
+async function memberLoopWakeTick(name, run, index, tickStartedAt) {
+  const { options, state } = run;
+  const wake = await runMemberWake(name, { execute: options.execute, confirmed: options.confirmed, force: options.force });
+  const key = `${wake.decision}:${wake.reason}`;
+  state.decisions[key] = (state.decisions[key] || 0) + 1;
+  const tick = {
+    tick: index + 1,
+    started_at: tickStartedAt,
+    finished_at: stampIso(),
+    ok: true,
+    decision: wake.decision,
+    reason: wake.reason,
+    executed: wake.executed,
+    needs_user: wake.needs_user,
+    next_command: wake.next_command,
+    has_mission: wake.checks?.has_mission === true,
+    has_goal: wake.checks?.has_goal === true,
+    has_steering: wake.checks?.has_steering === true,
+    productive: wake.executed === true
+      || /executed/.test(wake.reason || '')
+      || ['tick', 'close_loop', 'report_proof', 'create_missing_task', 'create_task', 'set_objective'].includes(wake.decision),
+    blocked_on_human: wake.needs_user === true || /^open_experiment_/.test(wake.reason || ''),
+    current_experiment: wake.current_experiment?.id || null,
+    receipt_path: wake.receipt_path,
+  };
+  state.tickResults.push(tick);
+  fs.appendFileSync(state.tickLogPath, JSON.stringify(tick) + '\n', 'utf8');
 
-  fs.rmSync(paths.stopPath, { force: true });
-  const tickLogPath = path.join(process.cwd(), 'atris', 'runs', `${runId}.jsonl`);
-  fs.mkdirSync(path.dirname(tickLogPath), { recursive: true });
-  const tickResults = [];
-  const decisions = {};
-  let stopped = false;
-  let failed = false;
-  // Stop spinning: if the member can do no real work for this many ticks in a row (waiting on a
-  // human review, blocked, or no goal), break early and surface a clear handoff instead of
-  // burning every remaining tick on the same no-op decision.
-  let earlyExit = null;
-  let consecutiveIdle = 0;
-  const idleBreakThreshold = 2;
   // Repeated identical `ask:*` wake decisions (e.g. ask:mission_missing_or_placeholder) mean the
   // member is stuck asking the same question every tick regardless of --execute; the idle
-  // early-exit above only fires in execute mode, so without this a dry-run loop burns every
+  // early-exit only fires in execute mode, so without this a dry-run loop burns every
   // remaining tick re-asking. Reuse the same blocked_on_human handoff once we see the ask repeat.
-  let lastAskKey = null;
-  let consecutiveIdenticalAsk = 0;
-  const identicalAskBreakThreshold = 2;
+  if (wake.decision === 'ask') {
+    if (key === state.lastAskKey) {
+      state.consecutiveIdenticalAsk += 1;
+    } else {
+      state.lastAskKey = key;
+      state.consecutiveIdenticalAsk = 1;
+    }
+    if (state.consecutiveIdenticalAsk >= MEMBER_LOOP_IDENTICAL_ASK_BREAK_THRESHOLD) {
+      state.earlyExit = {
+        after_tick: tick.tick,
+        decision: tick.decision || null,
+        reason: tick.reason || 'idle',
+        needs_user: tick.needs_user === true,
+        blocked_on_human: true,
+        next_command: tick.next_command || null,
+        stop: 'repeated_identical_ask',
+      };
+    }
+  } else {
+    state.lastAskKey = null;
+    state.consecutiveIdenticalAsk = 0;
+  }
+}
+
+// Stop spinning: if the member can do no real work for this many ticks in a row (waiting on a
+// human review, blocked, or no goal), break early and surface a clear handoff instead of
+// burning every remaining tick on the same no-op decision.
+const MEMBER_LOOP_IDLE_BREAK_THRESHOLD = 2;
+const MEMBER_LOOP_IDENTICAL_ASK_BREAK_THRESHOLD = 2;
 
+// Loop phase: control. Hold the lease, honor the stop file, pace ticks by interval, and
+// break early when the member is idling instead of faking activity.
+async function memberLoopRunTicks(name, paths, lease, run) {
+  const { options, plan, state } = run;
   try {
-    for (let index = 0; index < ticks; index += 1) {
+    for (let index = 0; index < plan.ticks; index += 1) {
       if (fs.existsSync(paths.stopPath)) {
-        stopped = true;
+        state.stopped = true;
         break;
       }
-      refreshMemberLoopLease(paths, lease.lease, ttlMs);
+      refreshMemberLoopLease(paths, lease.lease, plan.ttlMs);
       const tickStartedAt = stampIso();
       try {
-        if (aliveMode) {
-          const alive = runAliveTick(name, {
-            execute,
-            confirmed,
-            force,
-            agent,
-            model,
-            maxWallSeconds: operateMaxWall,
-            autoAcceptLimit,
-            noPrime: index > 0,
-          });
-          const key = `${alive.status || 'alive'}:${alive.reason || 'tick'}`;
-          decisions[key] = (decisions[key] || 0) + 1;
-          const tick = {
-            tick: index + 1,
-            started_at: tickStartedAt,
-            finished_at: alive.finished_at || stampIso(),
-            ok: alive.ok !== false,
-            decision: alive.status || 'alive_tick',
-            reason: alive.reason || null,
-            executed: execute,
-            needs_user: alive.needs_user === true,
-            next_command: alive.next_command || null,
-            has_mission: alive.has_mission === true,
-            has_goal: alive.has_goal === true,
-            has_steering: false,
-            productive: alive.status === 'completed',
-            blocked_on_human: alive.blocked_on_human === true,
-            operate_ok: alive.operate?.ok,
-            auto_accept_accepted: alive.auto_accept?.json?.summary?.accepted ?? alive.auto_accept?.json?.summary?.would_accept,
-            receipt_path: alive.receipt_path || alive.operate?.receipt_path || null,
-            alive,
-          };
-          tickResults.push(tick);
-          fs.appendFileSync(tickLogPath, JSON.stringify(tick) + '\n', 'utf8');
+        if (options.aliveMode) {
+          memberLoopAliveTick(name, run, index, tickStartedAt);
         } else {
-        const wake = await runMemberWake(name, { execute, confirmed, force });
-        const key = `${wake.decision}:${wake.reason}`;
-        decisions[key] = (decisions[key] || 0) + 1;
-        const tick = {
-          tick: index + 1,
-          started_at: tickStartedAt,
-          finished_at: stampIso(),
-          ok: true,
-          decision: wake.decision,
-          reason: wake.reason,
-          executed: wake.executed,
-          needs_user: wake.needs_user,
-          next_command: wake.next_command,
-          has_mission: wake.checks?.has_mission === true,
-          has_goal: wake.checks?.has_goal === true,
-          has_steering: wake.checks?.has_steering === true,
-          productive: wake.executed === true
-            || /executed/.test(wake.reason || '')
-            || ['tick', 'close_loop', 'report_proof', 'create_missing_task', 'create_task', 'set_objective'].includes(wake.decision),
-          blocked_on_human: wake.needs_user === true || /^open_experiment_/.test(wake.reason || ''),
-          current_experiment: wake.current_experiment?.id || null,
-          receipt_path: wake.receipt_path,
-        };
-        tickResults.push(tick);
-        fs.appendFileSync(tickLogPath, JSON.stringify(tick) + '\n', 'utf8');
-
-        if (wake.decision === 'ask') {
-          if (key === lastAskKey) {
-            consecutiveIdenticalAsk += 1;
-          } else {
-            lastAskKey = key;
-            consecutiveIdenticalAsk = 1;
-          }
-          if (consecutiveIdenticalAsk >= identicalAskBreakThreshold) {
-            earlyExit = {
-              after_tick: tick.tick,
-              decision: tick.decision || null,
-              reason: tick.reason || 'idle',
-              needs_user: tick.needs_user === true,
-              blocked_on_human: true,
-              next_command: tick.next_command || null,
-              stop: 'repeated_identical_ask',
-            };
-          }
-        } else {
-          lastAskKey = null;
-          consecutiveIdenticalAsk = 0;
-        }
+          await memberLoopWakeTick(name, run, index, tickStartedAt);
         }
       } catch (error) {
-        failed = true;
+        state.failed = true;
         const tick = {
           tick: index + 1,
           started_at: tickStartedAt,
@@ -8321,19 +8233,19 @@ async function memberLoop(name, ...args) {
           ok: false,
           error: error instanceof Error ? error.message : String(error),
         };
-        tickResults.push(tick);
-        fs.appendFileSync(tickLogPath, JSON.stringify(tick) + '\n', 'utf8');
+        state.tickResults.push(tick);
+        fs.appendFileSync(state.tickLogPath, JSON.stringify(tick) + '\n', 'utf8');
         break;
       }
-      if (earlyExit) break;
-      if (execute) {
-        const last = tickResults[tickResults.length - 1];
+      if (state.earlyExit) break;
+      if (options.execute) {
+        const last = state.tickResults[state.tickResults.length - 1];
         if (last && last.productive) {
-          consecutiveIdle = 0;
+          state.consecutiveIdle = 0;
         } else if (last) {
-          consecutiveIdle += 1;
-          if (consecutiveIdle >= idleBreakThreshold) {
-            earlyExit = {
+          state.consecutiveIdle += 1;
+          if (state.consecutiveIdle >= MEMBER_LOOP_IDLE_BREAK_THRESHOLD) {
+            state.earlyExit = {
               after_tick: last.tick,
               decision: last.decision || null,
               reason: last.reason || 'idle',
@@ -8345,12 +8257,19 @@ async function memberLoop(name, ...args) {
           }
         }
       }
-      if (index < ticks - 1 && intervalMs > 0) sleepSync(intervalMs);
+      if (index < plan.ticks - 1 && plan.intervalMs > 0) sleepSync(plan.intervalMs);
     }
   } finally {
     releaseMemberLoopLease(paths, lease.lease);
   }
+}
 
+// Loop phase: result recording. One summary object, one receipt, one latest pointer, one report.
+function memberLoopRecordResult(name, paths, lease, run) {
+  const { options, plan, state } = run;
+  const { execute, aliveMode, asJson } = options;
+  const { hourly, forever, runId, ticks, intervalMs, durationMs, startedAt } = plan;
+  const { tickResults, decisions, stopped, failed, earlyExit, tickLogPath } = state;
   const finishedAt = stampIso();
   const summary = {
     ok: !failed,
@@ -8392,7 +8311,7 @@ async function memberLoop(name, ...args) {
   };
   const receiptPath = writeMemberLoopReceipt(name, summary);
   const payload = { ...summary, receipt_path: receiptPath };
-  writeJsonFile(paths.latestPath, payload);
+  writeJson(paths.latestPath, payload);
   printJsonOrText(payload, [
     `${aliveMode ? 'Alive' : 'Loop'}: ${name}`,
     `Status: ${payload.status}`,
@@ -8404,6 +8323,71 @@ async function memberLoop(name, ...args) {
   ], asJson);
 }
 
+// Driver: the phases above do the work; this reads as setup -> gate -> run -> record.
+async function memberLoop(name, ...args) {
+  if (name === '--all' || name === 'all') return memberLoopAll('loop', ...args);
+  requireMemberDir(name);
+  const asJson = hasFlag(args, '--json');
+  const aliveMode = hasFlag(args, '--alive');
+  const execute = hasFlag(args, '--execute');
+  const confirmed = hasFlag(args, '--confirm-autonomy-policy');
+  const force = hasFlag(args, '--force');
+  const agentFlag = String(readFlag(args, '--agent', '') || '').trim().toLowerCase();
+  const agent = agentFlag === 'claude' ? 'claude' : agentFlag === 'codex' ? 'codex' : undefined;
+  const model = String(readFlag(args, '--model', '') || '').trim() || undefined;
+  const operateMaxWall = Math.max(60, Math.min(1800, Number(readNumberFlag(args, '--operate-max-wall', readNumberFlag(args, '--max-wall', 900)))));
+  const autoAcceptLimit = Math.max(1, Math.floor(Number(readNumberFlag(args, '--auto-accept-limit', 8))));
+  const options = { asJson, aliveMode, execute, confirmed, force, agent, model, operateMaxWall, autoAcceptLimit };
+  const paths = memberLoopPaths(name);
+  fs.mkdirSync(paths.stateDir, { recursive: true });
+
+  if (hasFlag(args, '--install')) {
+    return installMemberAliveCron(name, args);
+  }
+
+  if (hasFlag(args, '--uninstall')) {
+    return uninstallMemberAliveCron(name, args);
+  }
+
+  if (hasFlag(args, '--status')) {
+    return memberLoopStatusReport(name, paths, asJson);
+  }
+
+  if (hasFlag(args, '--stop')) {
+    return memberLoopRequestStop(name, paths, asJson);
+  }
+
+  const plan = memberLoopTimingPlan(name, args, { execute, confirmed });
+
+  if (execute && !confirmed) {
+    return memberLoopRefuseUnconfirmed(name, paths, { asJson, startedAt: plan.startedAt });
+  }
+
+  const lease = acquireMemberLoopLease(name, { runId: plan.runId, ttlMs: plan.ttlMs });
+  if (!lease.acquired) {
+    return memberLoopSkipAlreadyActive(name, paths, lease, { asJson, execute, startedAt: plan.startedAt });
+  }
+
+  fs.rmSync(paths.stopPath, { force: true });
+  const tickLogPath = path.join(process.cwd(), 'atris', 'runs', `${plan.runId}.jsonl`);
+  fs.mkdirSync(path.dirname(tickLogPath), { recursive: true });
+  const state = {
+    tickResults: [],
+    decisions: {},
+    stopped: false,
+    failed: false,
+    earlyExit: null,
+    consecutiveIdle: 0,
+    lastAskKey: null,
+    consecutiveIdenticalAsk: 0,
+    tickLogPath,
+  };
+
+  const run = { options, plan, state };
+  await memberLoopRunTicks(name, paths, lease, run);
+  memberLoopRecordResult(name, paths, lease, run);
+}
+
 async function memberTick(name, ...args) {
   const paths = requireMemberDir(name);
   const asJson = hasFlag(args, '--json');