atris 3.58.6 → 3.58.7

package/commands/drive.js

@@ -9,6 +9,7 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const rsi = require('../lib/rsi-record');
 
 const BIN = path.join(__dirname, '..', 'bin', 'atris.js');
 
@@ -73,9 +74,31 @@ async function driveCommand(argv) {
     return 0;
   }
 
+  // Dream-RSI: one drive run is one bounded improvement attempt. Recorded
+  // only when the workspace has the recorder; a recording failure never
+  // changes the run or its exit code.
+  const rsiLog = (m) => process.stderr.write(`rsi: ${m}\n`);
+  const rsiAttempt = dryRun ? null : rsi.beginAttempt(cwd, { lane: rsi.IMPROVE_LANE, engine: 'claude', log: rsiLog });
+  const rsiBefore = rsiAttempt ? rsi.gitSnapshot(cwd) : null;
+  const rsiT0 = Date.now();
+  const rsiFinish = (outcome) => {
+    if (!rsiAttempt) return;
+    const delta = rsi.gitDelta(cwd, rsiBefore);
+    rsi.finishAttempt(cwd, rsiAttempt, {
+      commits: delta.commits,
+      files: delta.files,
+      elapsed_s: Math.round((Date.now() - rsiT0) / 100) / 10,
+      engine_calls: 1,
+      verify: 'skipped',
+      ...outcome,
+    }, { log: rsiLog });
+  };
+
+  try {
   const doctor = runAtris(['mission', 'doctor', '--json'], cwd);
   const report = parseJsonLoose(doctor.stdout);
   if (!report || !Array.isArray(report.findings)) {
+    rsiFinish({ status: 'failed', reason: 'mission doctor returned no parseable findings' });
     console.error('drive: mission doctor returned no parseable findings.');
     if (doctor.stderr) console.error(doctor.stderr.slice(0, 500));
     return 1;
@@ -167,6 +190,11 @@ async function driveCommand(argv) {
   };
   if (!dryRun) appendState(cwd, record);
 
+  rsiFinish({
+    status: fixed.length ? 'shipped' : 'nothing',
+    reason: `${fixed.length} auto-fixed, ${disengagements.length} still need a human`.slice(0, 200),
+  });
+
   if (json) { console.log(JSON.stringify({ ok: true, ...record }, null, 2)); return 0; }
 
   console.log(`drive tick: ${report.checked_count} missions checked, ${report.findings.length} findings`);
@@ -182,6 +210,10 @@ async function driveCommand(argv) {
   }
   console.log(`  next: atris drive status · fix the ✋ list · re-run atris drive`);
   return disengagements.length > 0 ? 0 : 0;
+  } catch (err) {
+    rsiFinish({ status: 'failed', reason: String(err && err.message ? err.message : err).slice(0, 200) });
+    throw err;
+  }
 }
 
 module.exports = { driveCommand };

package/commands/improve.js

@@ -30,6 +30,7 @@ const close = require('./close');
 const { readUsage } = require('../lib/usage');
 const { knownCommands } = require('../lib/known-commands');
 const { treeHashFor } = require('../lib/tree-hash');
+const rsi = require('../lib/rsi-record');
 
 /**
  * Expand a leading `~` to the real home directory for LOCAL filesystem
@@ -735,6 +736,68 @@ function runLocalFallback(opts = {}) {
   };
 }
 
+// --- Dream-RSI attempt recording -----------------------------------------
+// A shipping tick (mode full, not dry-run) is one bounded attempt at
+// improving the workspace. When the workspace has the recorder
+// (backend/scripts/rsi/record.py), wrap the tick in open -> finish so the
+// attempt lands in .atris/state/rsi/attempts.jsonl. Recording never changes
+// the tick's result or exit code.
+
+function improveAttemptOutcome(result, { workspace, before, elapsedMs }) {
+  const s = (result && result.summary) || {};
+  const delta = rsi.gitDelta(workspace, before);
+  const files = [...new Set([...(Array.isArray(s.files) ? s.files : []), ...delta.files])].slice(0, 200);
+  const landed = files.length > 0 || delta.commits > 0 || Boolean(s.shipped);
+  const verify = s.verify === true ? 'pass' : s.verify === false ? 'fail' : 'skipped';
+  let status;
+  if (!result || !result.ok || s.error || verify === 'fail') status = 'failed';
+  else if (landed) status = 'shipped';
+  else status = 'nothing';
+  const reason = status === 'failed'
+    ? String(result.error || s.error || 'tick failed').slice(-200)
+    : String(s.shipped || result.reason || 'nothing to do').slice(0, 200);
+  return {
+    status,
+    verify,
+    commits: delta.commits,
+    files,
+    elapsed_s: Math.round(elapsedMs / 100) / 10,
+    engine_calls: 1,
+    reason,
+  };
+}
+
+async function runImprove(opts = {}, deps = {}) {
+  const workspace = opts.workspace || process.cwd();
+  const log = deps.log || (() => {});
+  // Local receipt writes expand a leading ~; the recorder check must too, or
+  // a `~/...` workspace would never see its own backend/scripts/rsi/record.py.
+  const rsiRoot = expandHome(workspace);
+  const shippingTick = (opts.mode || 'full') === 'full' && !opts.dryRun;
+  const attempt = shippingTick
+    ? rsi.beginAttempt(rsiRoot, { lane: rsi.IMPROVE_LANE, engine: rsi.engineFromModel(opts.model) || 'claude', log })
+    : null;
+  if (!attempt) return runImproveCore(opts, deps);
+  const startedMs = Date.now();
+  const before = rsi.gitSnapshot(rsiRoot);
+  try {
+    const result = await runImproveCore(opts, deps);
+    rsi.finishAttempt(rsiRoot, attempt, improveAttemptOutcome(result, { workspace: rsiRoot, before, elapsedMs: Date.now() - startedMs }), { log });
+    return result;
+  } catch (err) {
+    rsi.finishAttempt(rsiRoot, attempt, {
+      status: 'failed',
+      verify: 'skipped',
+      commits: 0,
+      files: [],
+      elapsed_s: Math.round((Date.now() - startedMs) / 100) / 10,
+      engine_calls: 1,
+      reason: String(err && err.message || err).slice(-200),
+    }, { log });
+    throw err;
+  }
+}
+
 /**
  * Run one improvement tick. Dependency-injected so tests can fake the
  * network (apiRequestJson), auth (loadCredentials), the local fallback,
@@ -743,7 +806,7 @@ function runLocalFallback(opts = {}) {
  * Returns a structured result:
  *   { ok, source: 'api'|'local'|'none', reason, summary?, scorecardPath?, local?, apiResult?, error? }
  */
-async function runImprove(opts = {}, deps = {}) {
+async function runImproveCore(opts = {}, deps = {}) {
   const apiFn = deps.apiRequestJson || apiRequestJson;
   const loadCreds = deps.loadCredentials || loadCredentials;
   const localFn = deps.runLocalFallback || runLocalFallback;
@@ -989,6 +1052,8 @@ function isRevisionSignalFile(file) {
 const REVISION_WINDOW_MS = REVISION_WINDOW_HOURS * 60 * 60 * 1000;
 const AGENT_TRAILER_MARKERS = [
   'atris-builder[bot]',
+  'night@atris.ai',
+  'devin',
   'claude',
   'cursor',
   'codex',
@@ -1406,6 +1471,7 @@ async function run(argv = [], deps = {}) {
 module.exports = {
   run,
   runImprove,
+  runImproveCore,
   parseImproveArgs,
   buildImprovePayload,
   summarizeImproveResponse,

package/commands/land.js

@@ -58,6 +58,102 @@ function worktreeWithinReapGrace(worktreePath, now = Date.now()) {
   return typeof mtime === 'number' && now - mtime < WORKTREE_REAP_GRACE_MS;
 }
 
+function canonicalPath(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+}
+
+function gitCommonDir(root) {
+  for (const args of [['rev-parse', '--path-format=absolute', '--git-common-dir'], ['rev-parse', '--git-common-dir']]) {
+    const res = runGit(args, { cwd: root, check: false });
+    if (res.status === 0 && res.stdout.trim()) return path.resolve(root, res.stdout.trim());
+  }
+  return '';
+}
+
+function headRefName(headFile) {
+  try {
+    const m = /^ref: refs\/heads\/(.+)$/.exec(fs.readFileSync(headFile, 'utf8').trim());
+    return m ? m[1] : '';
+  } catch {
+    return '';
+  }
+}
+
+// Branch checkouts straight from .git/worktrees/<id>/HEAD plus the main
+// checkout's HEAD — the live truth, not the board snapshot. A `worktree add`
+// still in flight (or a half-registered entry) can leave a branch checked out
+// in a directory the snapshot never saw, and git's own `branch -D` refusal
+// only consults registrations whose gitdir link is already written.
+// pendingFresh marks a fresh registration whose HEAD file does not exist yet:
+// an add mid-flight that has not named its branch.
+function liveCheckouts(root, now = Date.now()) {
+  const bound = new Map();
+  let pendingFresh = false;
+  const common = gitCommonDir(root);
+  if (!common) return { bound, pendingFresh };
+  if (path.basename(common) === '.git') {
+    const name = headRefName(path.join(common, 'HEAD'));
+    const mainPath = path.dirname(common);
+    if (name && fs.existsSync(mainPath)) bound.set(name, { path: mainPath, adminDir: common });
+  }
+  let ids = [];
+  try {
+    ids = fs.readdirSync(path.join(common, 'worktrees'));
+  } catch {
+    return { bound, pendingFresh };
+  }
+  for (const id of ids) {
+    const adminDir = path.join(common, 'worktrees', id);
+    let stat;
+    try {
+      stat = fs.statSync(adminDir);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+    const headFile = path.join(adminDir, 'HEAD');
+    const name = headRefName(headFile);
+    if (!name) {
+      if (!fs.existsSync(headFile) && now - stat.mtimeMs < WORKTREE_REAP_GRACE_MS) pendingFresh = true;
+      continue;
+    }
+    let wtPath = null;
+    try {
+      wtPath = path.dirname(fs.readFileSync(path.join(adminDir, 'gitdir'), 'utf8').trim());
+    } catch {
+      // gitdir unwritten or lost: cannot prove which directory is the
+      // checkout, so the branch stays claimed — fail safe, prune's job.
+    }
+    if (wtPath && !fs.existsSync(wtPath)) continue;
+    bound.set(name, { path: wtPath, adminDir });
+  }
+  return { bound, pendingFresh };
+}
+
+// The branch's own reflog records when `worktree add -b` (or `git branch`)
+// created it. While an add is in flight a just-created target branch is very
+// likely the checkout being wired up right now — keep it for this pass.
+function branchCreatedWithinGrace(root, name, now = Date.now()) {
+  const res = runGit(['reflog', 'show', '--date=unix', name], { cwd: root, check: false });
+  if (res.status !== 0) return false;
+  const lines = res.stdout.split(/\r?\n/).filter(Boolean);
+  const m = /@\{(\d+)\}/.exec(lines[lines.length - 1] || '');
+  return Boolean(m) && now - Number(m[1]) * 1000 < WORKTREE_REAP_GRACE_MS;
+}
+
+// One receipt line for a branch kept because a live checkout claims it:
+// fresh checkouts name the grace, older ones name where the branch is in use.
+function checkoutKeepLine(name, bound, now) {
+  if (worktreeWithinReapGrace(bound.path || bound.adminDir, now)) {
+    return bound.path ? `${bound.path} (fresh_worktree_grace)` : `branch ${name} (fresh_worktree_grace)`;
+  }
+  return `branch ${name} (checked out in ${bound.path || 'a worktree'})`;
+}
+
 function listBranches(root, base = '') {
   // With a base, ask git for ahead counts in the same single spawn
   // (%(ahead-behind:) needs git >= 2.41; on failure we retry without it and
@@ -151,7 +247,12 @@ function collectBoard(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_S
   const worktrees = [];
   const all = listWorktrees(root);
   for (const wt of all.slice(1)) {
-    const branch = (wt.branch || '').replace(/^refs\/heads\//, '');
+    const rawBranch = (wt.branch || '').replace(/^refs\/heads\//, '');
+    // 'detached' is a marker, not a name: left as-is it reads as a real branch
+    // name (hiding the worktree's own commits and, in reap, pushing the word
+    // "detached" into the delete list). Treat it as no branch so the worktree
+    // is asked directly what it holds.
+    const branch = rawBranch === 'detached' ? '' : rawBranch;
     // light mode skips the full `git status` per worktree, the banner summary
     // never reads dirty counts, only worktree mtimes for staleness.
     const counts = (light ? null : statusCounts(wt.path)) || { staged: 0, unstaged: 0, untracked: 0 };
@@ -376,8 +477,25 @@ function reap(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_STALE_HOU
   };
   if (targetNames.size === 0 && worktreeTargets.length === 0) return receipt;
   if (dryRun) {
+    // The preview must match the real pass: a branch still checked out in a
+    // worktree the board missed is kept, not listed as deleted. A checkout
+    // that is itself a removal target would be gone first, so it still reads
+    // as deletable here.
+    const live = liveCheckouts(root, now);
+    const targetPaths = new Set(worktreeTargets.map((w) => canonicalPath(w.path)));
     receipt.removedWorktrees = worktreeTargets.map((w) => w.path);
-    receipt.deletedBranches = [...targetNames];
+    receipt.deletedBranches = [...targetNames].filter((name) => {
+      const bound = live.bound.get(name);
+      if (bound && !(bound.path && targetPaths.has(canonicalPath(bound.path)))) {
+        receipt.keptWorktrees.push(checkoutKeepLine(name, bound, now));
+        return false;
+      }
+      if (!bound && live.pendingFresh && branchCreatedWithinGrace(root, name, now)) {
+        receipt.keptWorktrees.push(`branch ${name} (fresh_worktree_grace)`);
+        return false;
+      }
+      return true;
+    });
     return receipt;
   }
 
@@ -406,9 +524,17 @@ function reap(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_STALE_HOU
     (w) => targetNames.has(w.branch) || (includeDetached && w.state === 'detached')
   );
   for (const w of survivingWorktreeTargets) {
+    // The grace check ran at scan time, and a bundle build can sit between it
+    // and removal — an engine that booted mid-sweep refreshes the directory
+    // mtime in that gap. Stat once more at removal time, the cheapest place
+    // to never be wrong about freshness.
+    if (worktreeWithinReapGrace(w.path)) {
+      receipt.keptWorktrees.push(`${w.path} (fresh_worktree_grace)`);
+      if (w.branch) targetNames.delete(w.branch);
+      continue;
+    }
     // Salvage-then-remove, never keep-because-dirty: patches + untracked
-    // copies bank everything force-remove would destroy. The fresh-worktree
-    // grace was already applied when candidates were selected.
+    // copies bank everything force-remove would destroy.
     if (w.dirty > 0 && !salvageWorktree(w, dir, receipt)) {
       // could not fully back up what force-remove would destroy, keep it,
       // and say why: a bare path in the receipt reads as an unexplained
@@ -430,7 +556,21 @@ function reap(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_STALE_HOU
     }
   }
 
+  // Re-scan after removals: worktrees just removed freed their branches, and
+  // anything still bound is checked out in a directory that exists — the
+  // board snapshot may have missed it entirely (a `worktree add` mid-flight),
+  // and git's own -D refusal only reads fully wired registrations.
+  const live = liveCheckouts(root, now);
   for (const name of targetNames) {
+    const bound = live.bound.get(name);
+    if (bound) {
+      receipt.keptWorktrees.push(checkoutKeepLine(name, bound, now));
+      continue;
+    }
+    if (live.pendingFresh && branchCreatedWithinGrace(root, name, now)) {
+      receipt.keptWorktrees.push(`branch ${name} (fresh_worktree_grace)`);
+      continue;
+    }
     const entry = board.branches.find((b) => b.name === name);
     // the board is a snapshot; an agent may have committed since it was
     // taken. A branch that moved is left alone, the next reap sees the

package/commands/learn.js

@@ -420,6 +420,10 @@ function logDirect(jsonStr, deps = {}) {
   }
 }
 
+function leftoverClaimableInsight(insight) {
+  return /^\[claimable\]/i.test(String(insight || '').trim());
+}
+
 /**
  * Harvest learnings from journal Notes sections.
  * Scans recent journals for lines that look like insights.
@@ -450,13 +454,14 @@ function harvestFromJournals(deps = {}) {
   // Scan last 7 journals for Notes section entries
   const candidates = [];
   for (const logPath of allLogs.slice(0, 7)) {
-    const content = fs.readFileSync(logPath, 'utf8');
+    const content = fs.readFileSync(logPath, 'utf8').replace(/\r\n/g, '\n');
     const notesMatch = content.match(/## Notes\n([\s\S]*?)(?=\n## |$)/);
     if (notesMatch && notesMatch[1].trim()) {
       const lines = notesMatch[1].trim().split('\n').filter(l => l.startsWith('- '));
       for (const line of lines) {
         // Strip bullet and optional timestamp prefix
         const insight = line.replace(/^- (\d{2}:\d{2} \u2014 )?/, '').trim();
+        if (leftoverClaimableInsight(insight)) continue;
         if (insight.length > 10) {
           candidates.push({ insight, source: path.basename(logPath) });
         }

package/commands/member.js

@@ -10,6 +10,7 @@ const { defaultObjectiveRunner } = require('../lib/default-runner');
 const { readJson, writeJson } = require('../lib/json-file');
 const { hasFlag, readFlag, readNumberFlag } = require('../lib/arg-parser');
 const { ensureMemberBundle, memberBundlePresent } = require('../lib/member-scaffold');
+const { memberProcessPrompt, MEMBER_PROCESS_PATH } = require('../lib/member-context');
 
 function findWorkspaceBusinessId(startDir = process.cwd()) {
   let dir = path.resolve(startDir);
@@ -462,6 +463,7 @@ function missionPurpose(paths) {
 }
 
 const MEMBER_RUN_RUNNABLE_STATUSES = new Set(['planning', 'running', 'ready']);
+const MISSION_TERMINAL_STATUSES = new Set(['complete', 'stopped', 'failed']);
 
 function memberRunMissionMap() {
   try {
@@ -928,12 +930,11 @@ function memberPing(name, ...args) {
     process.exit(2);
   }
   const missionMod = require('./mission');
-  const terminal = new Set(['complete', 'stopped', 'failed']);
   const candidates = [
     ...missionMod.listMissions(process.cwd()),
     ...missionMod.listWorktreeRollupMissions(process.cwd()),
   ]
-    .filter((m) => m && m.owner === name && !terminal.has(m.status))
+    .filter((m) => m && m.owner === name && !MISSION_TERMINAL_STATUSES.has(m.status))
     .sort((a, b) => String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || '')));
 
   const taskNote = pingClaimedTaskDialogue(name, text, from);
@@ -4216,6 +4217,7 @@ function memberActivate(name) {
 
   const content = fs.readFileSync(activePath, 'utf8');
   const fm = parseFrontmatter(content) || {};
+  const sharedProcess = memberProcessPrompt(process.cwd());
 
   console.log('');
   console.log(`Activating: ${fm.name || name} (${fm.role || 'no role'})`);
@@ -4298,7 +4300,8 @@ function memberActivate(name) {
 
   console.log('');
   console.log(`Member "${fm.name || name}" activated.`);
-  console.log(`Tell your agent: "You are the ${fm.role || name}. Read team/${name}/MEMBER.md."`);
+  const identityPath = path.relative(process.cwd(), activePath);
+  console.log(`Tell your agent: "You are the ${fm.role || name}. Read ${sharedProcess ? `${MEMBER_PROCESS_PATH}, then ` : ''}${identityPath}. Stay inside this member's permissions."`);
 }
 
 // --- UPGRADE subcommand ---
@@ -4707,6 +4710,49 @@ function memberGoalFromMission(name, ...args) {
     );
     return;
   }
+  if (MISSION_TERMINAL_STATUSES.has(lowerCompact(runtime.status || ''))) {
+    // A finished mission must not mint or re-point an active goal; that recreated the
+    // stale-goal defect class (OBL-1961, OBL-2212, OBL-2232) after every retire. --force
+    // cannot bypass this, it only widens the existing-goal match on a living mission.
+    const staleGoals = state.goals.filter((goal) => (
+      goal.source === 'mission' && goal.status === 'active'
+      && runtime.id && goal.mission_id === runtime.id
+    ));
+    const staleList = staleGoals.map((goal) => goal.title || goal.id).join('; ');
+    const ask = staleGoals.length
+      ? `Mission ${runtime.id || compactSentence(runtimeFocus, 88)} is ${runtime.status}, so its active goal is stale. Retire ${compactSentence(staleList, 140)} by setting its status in goals.json, or start a living mission and run: atris member goal-from-mission ${name} --force`
+      : `Mission ${runtime.id || compactSentence(runtimeFocus, 88)} is ${runtime.status}. Start a living mission, then run: atris member goal-from-mission ${name} --force`;
+    const logPath = appendMemberGoalLog(paths.memberDir, name, 'Member goal-from-mission blocked', {
+      ask,
+      mission_id: runtime.id || '',
+      mission_status: runtime.status || '',
+      stale_goals: staleGoals.map((goal) => goal.id),
+    });
+    printJsonOrText(
+      {
+        ok: true,
+        action: 'needs_user',
+        member: name,
+        needs_user: true,
+        ask,
+        stale_goals: staleGoals,
+        mission: {
+          north_star: purpose.northStar,
+          runtime_id: runtime.id || null,
+          runtime_status: runtime.status || null,
+          runtime_next: runtime.next || null,
+        },
+        mission_file: paths.missionFile,
+        log_path: logPath,
+      },
+      [
+        `Blocked for ${name}: mission ${runtime.id || 'in now.md'} is ${runtime.status}, a finished mission cannot drive an active goal.`,
+        `Ask: ${ask}`,
+      ],
+      asJson,
+    );
+    return;
+  }
   // The title IS the mission focus, no boilerplate prefix; the acceptance list already
   // says "one bounded step" and the why carries the full sentence.
   const title = compactSentence(runtimeFocus, 96);
@@ -4977,7 +5023,8 @@ function fallbackProposalForGoal(goal, context = {}) {
   };
 }
 
-function proposalPromptForGoal(goal, context = {}) {
+function proposalPromptForGoal(goal, context = {}, cwd = process.cwd()) {
+  const sharedProcess = memberProcessPrompt(cwd);
   const files = (context?.evidence?.goal_files?.files || [])
     .filter((file) => file.exists && file.excerpt)
     .slice(0, 4)
@@ -5005,6 +5052,7 @@ function proposalPromptForGoal(goal, context = {}) {
     },
   };
   return [
+    ...(sharedProcess ? [sharedProcess, ''] : []),
     'You generate the next bounded Atris member experiment.',
     'Read the JSON context and return only JSON with keys: title, proof_target, next_step, verifier, stop_rule.',
     'The next_step must be adaptive to the goal/evidence, concrete, receipt-backed, and safe for one bounded tick.',
@@ -5058,10 +5106,11 @@ async function callAtris2ProposalLlm(goal, context = {}) {
   const injected = injectedLlmProposal();
   if (injected) return injected;
   if (process.env.ATRIS_MEMBER_PROPOSAL_LLM !== '1') return null;
+  const prompt = proposalPromptForGoal(goal, context, process.cwd());
   try {
     const { postTurn } = require('../ax');
     const output = { isTTY: false, write() { return true; } };
-    const result = await postTurn(proposalPromptForGoal(goal, context), {
+    const result = await postTurn(prompt, {
       mode: process.env.ATRIS_MEMBER_PROPOSAL_LLM_MODE || 'fast',
       route: 'local',
       cwd: process.cwd(),
@@ -5761,6 +5810,7 @@ function emptyObjectiveGeneratorProposal(extra = {}) {
     updated_at: stampIso(),
     status: extra.status || 'empty',
     advisory_only: true,
+    auto_task_eligible: extra.auto_task_eligible !== false,
     world_model_used: false,
     llm_source: extra.llm_source || null,
     llm_error: extra.llm_error || null,
@@ -5893,8 +5943,8 @@ function fallbackObjectiveGeneratorProposal(graph, recommendations, transferPatt
     ),
     suggested_member: member,
     suggested_patterns: objectivePatternMatches(transferPatterns, proposedObjective),
-  }, { status: 'ok', llm_error: 'llm_not_configured', world_model_used: true });
-  return proposal || emptyObjectiveGeneratorProposal({ status: 'llm_not_configured', llm_error: 'llm_not_configured' });
+  }, { status: 'ok', llm_error: 'llm_not_configured', world_model_used: true, auto_task_eligible: false });
+  return proposal || emptyObjectiveGeneratorProposal({ status: 'llm_not_configured', llm_error: 'llm_not_configured', auto_task_eligible: false });
 }
 
 function objectiveGeneratorPrompt(graph, recommendations, transferPatterns = []) {
@@ -6056,7 +6106,7 @@ async function runObjectiveGeneratorWake(name, paths, { execute = false } = {})
       proposal = emptyObjectiveGeneratorProposal({ status: llm.error === 'invalid_json' ? 'parse_error' : 'llm_error', llm_source: llm.source, llm_error: llm.error });
       proposal.world_model_used = true;
     } else {
-      reason = 'heuristic_objective_proposal_written';
+      reason = execute ? 'heuristic_objective_proposal_written' : 'heuristic_objective_proposal_dry_run';
       proposal = fallbackObjectiveGeneratorProposal(graph, recommendations, transferPatterns);
     }
   }
@@ -6065,7 +6115,7 @@ async function runObjectiveGeneratorWake(name, paths, { execute = false } = {})
     proposal.suggested_patterns = objectivePatternMatches(transferPatterns, proposal.proposed_objective);
   }
 
-  if (execute && proposal?.status === 'ok' && Number(proposal.overall_score) > 7) {
+  if (execute && proposal?.status === 'ok' && proposal.auto_task_eligible !== false && Number(proposal.overall_score) > 7) {
     createdTask = createAutoObjectiveTask(proposal);
     proposal.created_task = createdTask.ok ? {
       id: createdTask.task_id || null,
@@ -6081,7 +6131,8 @@ async function runObjectiveGeneratorWake(name, paths, { execute = false } = {})
   }
 
   const proposalsPath = objectiveGeneratorProposalsPath(root);
-  if (execute) {
+  const proposalsWritten = Boolean(execute);
+  if (proposalsWritten) {
     fs.mkdirSync(path.dirname(proposalsPath), { recursive: true });
     fs.writeFileSync(proposalsPath, JSON.stringify(proposal, null, 2) + '\n', 'utf8');
   }
@@ -6111,6 +6162,7 @@ async function runObjectiveGeneratorWake(name, paths, { execute = false } = {})
     llm_successful: Boolean(llm?.source && llm?.proposal && proposal.status === 'ok'),
     llm_error: llm?.error || proposal.llm_error || null,
     proposals_path: path.relative(root, proposalsPath),
+    proposals_written: proposalsWritten,
     task_creation_threshold: 7,
     task_created: Boolean(createdTask?.ok),
     created_task: proposal.created_task,
@@ -6128,7 +6180,7 @@ async function runObjectiveGeneratorWake(name, paths, { execute = false } = {})
     score: proposal.overall_score || '',
     task: proposal.created_task?.ref || '',
     receipt: path.relative(root, receiptPath),
-    output: path.relative(root, proposalsPath),
+    output: proposalsWritten ? path.relative(root, proposalsPath) : '',
   });
 
   return {
@@ -7817,6 +7869,7 @@ const WAKE_REASON_TEXT = {
   auto_improver_task_create_failed: 'it found an improvement but could not put the task on the board',
   heuristic_cross_domain_proof_written: 'it wrote a cross-domain proof using its built-in heuristics',
   heuristic_objective_proposal_written: 'it drafted an objective proposal using its built-in heuristics',
+  heuristic_objective_proposal_dry_run: 'it previewed an objective proposal using its built-in heuristics, without writing it',
   install_requires_clean_git: 'installing needs a clean git tree first',
   insufficient_world_model_data: 'its world model is too thin to act on yet',
   llm_json_parse_failed: 'the model reply did not parse, so it stopped rather than act on garbage',
@@ -9232,6 +9285,7 @@ async function memberCommand(subcommand, ...args) {
 }
 
 module.exports = {
+  proposalPromptForGoal,
   memberCommand,
   findAllMembers,
   findWorkspaceBusinessId,