atris 3.57.2 → 3.57.4

package/atris/skills/engines/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: engines
-description: "Dispatch work to an installed terminal agent or named Atris engine profile. Supports Atris Fast, Claude, Codex, Cursor, Fable, Composer, Haiku, Devin, Grok, and Antigravity (agy). Triggers on: use codex, use cursor, use devin, use grok, use agy, use antigravity, use fable, use claude, use atris, engine, dispatch to, worker agent, second opinion build."
-version: 1.4.1
+description: "Dispatch work to an installed terminal agent or named Atris engine profile. Supports Atris Fast, Claude, Codex, Cursor, Fable, Composer, Haiku, Devin, Grok, and Antigravity (agy). Triggers on: use codex, use cursor, use devin, use grok, use agy, use antigravity, use gemini, gemini session, use fable, use claude, use atris, engine, dispatch to, worker agent, second opinion build."
+version: 1.4.2
 tags:
   - engines
   - claude
@@ -14,6 +14,7 @@ tags:
   - grok
   - agy
   - antigravity
+  - gemini
   - atris
   - orchestration
 ---
@@ -50,7 +51,7 @@ Raw spawns are not the default because they skip Atris receipts, watch, and coac
 | Haiku | `claude -p "<prompt>" --model claude-haiku-4-5` | Fast validation and bounded read-only checks. |
 | Devin | `devin -p --permission-mode dangerous -- "<prompt>"` (run from the target repo) | Default permission mode is read-only for writes — build work NEEDS `--permission-mode dangerous`, so only run it in an isolated worktree. Also `devin cloud` for sessions that outlive this machine. Supports `--model swe-1.7` |
 | Grok | `grok --always-approve -p "<prompt>"` (run from the target repo) | Headless single-turn via `-p`; default model grok-4.6. Very fast on lookups (~5-10s, reads MAP first). Great for quick second opinions; use `--best-of-n <N>` for tricky bounded builds. Uses grok.com login |
-| Antigravity | `agy --mode accept-edits -p "<prompt>"` | `agy` executor profile. Use `--mode plan --sandbox` for read-only review and `--model <id>` to pin a model. |
+| Antigravity | `agy --mode accept-edits --add-dir "$PWD" -p "<prompt>"` (run from the target repo) | `agy` executor profile; also answers to "gemini". **`--add-dir` is mandatory for writes** — without it agy edits its own scratch folder (`~/.gemini/antigravity-cli/scratch/`) and the project never changes, which looks like a silent failure (verified live 2026-08-28). Use `--mode plan --sandbox` for read-only review, `--model <id>` to pin a model, and `--dangerously-skip-permissions` if a build still stalls on an approval prompt. |
 
 Headless dispatch permissions (verified 2026-08-11): `codex exec`, `grok`, and `cursor-agent` are allowlisted in `~/.claude/settings.json` so fresh and one-shot sessions can dispatch without a human approval click. A cold session that gets "requires approval" on an engine command means that allowlist regressed.
 

package/atris/skills/x-search/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: x-search
 description: "X/Twitter search via xAI Grok API. Use when user wants to search tweets, monitor topics, find viral posts, or run social listening. Costs 5 credits per search. Triggers on x search, tweet search, twitter search, social listening, revenue intel, viral tweets."
-version: 2.2.0
+version: 2.3.0
 tags:
   - x-search
   - social
@@ -21,15 +21,19 @@ login
     |
    x-search QUERY (5 credits)
     |
-   write one Apply (claimable)
+   stdout only unless --save
+        |
+       rich ephemeral --> one apply next-step, no files
+       --save + rich --> brief + pack + one Apply
+       --save + thin --> refuse, no files, exit 2
     |
    stop
 ```
 
 1. Login: stored login, then `atris login --agent` if needed. Never paste tokens. Never `/auth/cli`.
-2. Search: `atris x-search "QUERY"`. Always billed (5 credits). Empty or failed search refunds.
-3. One Apply: name a product change plus a receipt that can fail. If missing, the CLI writes a fill-this stub and a next-line. Search still exits 0.
-4. Stop. Empty or failed search does not owe an Apply.
+2. Search: `atris x-search "QUERY"`. Always billed (5 credits). Prints to stdout. Rich ephemeral prints one apply next-step and writes nothing. Empty or failed search refunds and writes nothing.
+3. `--save` only when you want a brief. Rich results (a number-with-units or a named mechanism) file the brief, mint `atris/experiments/x-search-<slug>/`, and write one Apply that names that pack and the keep rule. Thin `--save` prints `thin: no number or named mechanism. no brief.` and writes nothing.
+4. Stop. Thin, empty, or failed search does not print the ephemeral apply next-step.
 
 ## Customer path (preferred)
 
@@ -38,6 +42,7 @@ Logged-in customers should use the CLI. Same auth and billing as `atris youtube
 ```bash
 atris x-search "MCP agents"
 atris x-search "MCP agents" --limit 5 --days 2
+atris x-search "MCP agents" --save
 atris x-search person --name "Leah Bonvissuto" --handle leahbon
 atris x-search --help
 ```
@@ -245,6 +250,7 @@ npm install -g atris && atris login
 
 # Preferred: CLI
 atris x-search "AI agents" --limit 10 --days 7
+atris x-search "AI agents" --save
 atris x-search person --name "John Doe" --handle johndoe --company Acme
 
 # Raw API (debug)

package/atris/skills/youtube/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: youtube
 description: "YouTube discovery and learning. Get watch permalinks with atris youtube search QUERY (free, local ytsearch/yt-dlp). On 429 the CLI already retries; use cached rows if printed, else STOP. Never run --paid after a 429. --paid only when the user explicitly asked to buy permalinks (5 credits). After a URL is picked, atris youtube notes URL (free, ephemeral unless --save). atris youtube process only to store knowledge (5 credits). Never paste tokens. Never /auth/cli. Mint with atris login --agent from a stored login. Never summarize a video from model memory. Triggers on: youtube search, find videos, paid youtube search, any youtube.com or youtu.be link, youtube, video, watch this, notes on this."
-version: 2.11.0
+version: 2.12.0
 tags:
   - youtube
   - research
@@ -24,8 +24,10 @@ search QUERY (free)
              do not run --paid
     |
    pick a URL --> notes URL (free, ephemeral unless --save)
-    |                 --save files the brief + apply stub
+    |                 rich ephemeral prints one apply next-step, no files
+    |                 --save files brief + pack-named apply when notes have a number or named mechanism; thin --save refuses
     |            or teach URL [--section N] (one chapter: claim numbers, named mechanisms, one check; free unless --save)
+    |                 next --section refuses until recap/skip
     |
    write one Apply (claimable) before process
     |
@@ -39,8 +41,8 @@ never paste tokens, never /auth/cli
 1. Get watch permalinks: `atris youtube search QUERY` (free).
 2. If 429: wait/retry is already in the CLI. If it prints cached rows, use those. If it prints `youtube rate-limited local search. do not use --paid as a fallback; retry later.`, STOP. Do not run `--paid`.
 3. `--paid` only when the user explicitly asked to buy permalinks. The CLI hard-refuses `--paid` when the free cache still has a fresh same-query hit.
-4. `atris youtube notes URL` after a URL is picked (free). Notes is ephemeral unless `--save`.
-5. Write one Apply (change + receipt) before `atris youtube process`. Process still requires a filled Apply (so you `--save`, fill Apply, then process).
+4. `atris youtube notes URL` after a URL is picked (free). Notes is ephemeral unless `--save`. Rich ephemeral prints one apply next-step and writes no files. Rich `--save` files the brief and mints `atris/experiments/notes-<id>/`; thin `--save` (no number-with-units and no named mechanism) refuses with no brief and exit 2. Do not auto `--paid`.
+5. Write one Apply (change + receipt) before `atris youtube process`. Process still requires a filled Apply (so you `--save` a rich brief, fill Apply, then process).
 6. Never paste tokens. Never `/auth/cli`. Mint with `atris login --agent` from a stored login.
 
 If the user says "find videos", "search youtube", or "get youtube links" → search. If they say "learn from", "notes on", "alpha", or "rabbit hole" → notes. If they say "process", "store", "add to knowledge" → process. "Buy permalinks" or "paid search" is the only ask that unlocks `--paid`.

package/ax

@@ -4020,7 +4020,10 @@ async function runSelfTest(options = {}) {
     try {
       await chat({
         mode: 'fast',
-        cwd: os.tmpdir(),
+        // A stray .atris under os.tmpdir() (left by a concurrent run) makes the
+        // walk-up detector treat temp as a workspace, flipping this offline
+        // check into local mode. Pin a path with no workspace ancestor.
+        cwd: '/nonexistent/ax-non-workspace',
         input: Readable.from(['hi\n', 'exit\n']),
         output: chatOutput,
         runtimeHealth: async () => {

package/bin/atris.js

@@ -583,7 +583,7 @@ function showHelpAll() {
   console.log('  revisions  - show possible human revisions after atris-assisted landings');
   console.log('  search     - Search workspace memory (atris search <keyword>)');
   console.log('  clean      - Housekeeping (stale tasks, archive journals, broken refs)');
-  console.log('  close      - track open loops with deadlines and daily escalation');
+  console.log('  close      - keep ten active loops and park the rest with their history');
   console.log('  harvest    - Find bugs and next actions from receipts, run logs, and thinking');
   console.log('  verify     - Validate work is done (tests, MAP.md, changes)');
   console.log('  slop       - Deterministic slop detector: frontend/prose tells, dead code (slop dead --exports)');

package/commands/close.js

@@ -23,6 +23,7 @@ const FAILED_TASK_BATCH_PREFIX = 'tasks:failed:';
 const PROBE_TIMEOUT_MS = 60 * 1000;
 const PROBE_HOLD_GAP_MS = 60 * 60 * 1000;
 const PROBE_STOP_AFTER_FAILED_CHECKS = 2;
+const MAX_OPEN_FLAGS = 10;
 
 function ledgerPath(cwd = process.cwd()) {
   return path.join(cwd, LEDGER_RELATIVE_PATH);
@@ -144,6 +145,15 @@ function foldEvents(events, options = {}) {
       flag.why = event.why || '';
     } else if (event.kind === 'snoozed') {
       flag.snoozed_until = event.until || null;
+    } else if (event.kind === 'parked') {
+      flag.status = 'parked';
+      flag.parked_at = event.parked_at || eventTime(event);
+      flag.why = normalizeSpaces(event.why || 'parked by request');
+    } else if (event.kind === 'reopened') {
+      flag.status = 'open';
+      flag.reopened_at = eventTime(event);
+      delete flag.parked_at;
+      delete flag.why;
     } else if (event.kind === 'escalated') {
       const day = event.day || (event.at ? String(event.at).slice(0, 10) : null);
       if (day && !flag.escalated_days.includes(day)) flag.escalated_days.push(day);
@@ -223,6 +233,12 @@ function openFlags(cwd = process.cwd(), options = {}) {
   return foldEvents(readEvents(cwd), options).filter((flag) => flag.status === 'open');
 }
 
+function parkedFlags(cwd = process.cwd(), options = {}) {
+  return foldEvents(readEvents(cwd), options)
+    .filter((flag) => flag.status === 'parked')
+    .sort((a, b) => (parseDate(b.parked_at) || 0) - (parseDate(a.parked_at) || 0));
+}
+
 function ownerWaitRank(flag) {
   return /^(you|me|operator|human|keshav)$/.test(String(flag.owner || '').toLowerCase()) ? 0 : 1;
 }
@@ -264,6 +280,16 @@ function listLine(flag) {
   return parts.join(', ');
 }
 
+function parkedLine(flag) {
+  const what = trimSentenceEnd(flag.what.toLowerCase());
+  const day = flag.parked_at ? String(flag.parked_at).slice(0, 10) : 'unknown date';
+  return `${what}, parked ${day}, ${trimSentenceEnd(flag.why || 'parked by request').toLowerCase()}`;
+}
+
+function migratedParkLine(flag) {
+  return `parked ${trimSentenceEnd(flag.what).toLowerCase()}: ${trimSentenceEnd(flag.why).toLowerCase()}.`;
+}
+
 function sweepLine(flag) {
   const what = trimSentenceEnd(flag.what.toLowerCase());
   const closeCondition = trimSentenceEnd(flag.close_condition.toLowerCase());
@@ -325,9 +351,12 @@ function publicFlag(flag) {
 }
 
 function printHelp() {
-  console.log('usage: atris close <add|list|done|dissolve|snooze|sweep|scan|check>');
-  console.log('add "<what>" [--owner x] [--lane life|business|code] [--ttl 7] [--when "<condition>"] [--source y] [--probe "<cmd that fails now>"]');
+  console.log('usage: atris close <add|list|park|parked|reopen|done|dissolve|snooze|sweep|scan|check>');
+  console.log('add "<what>" [--owner x] [--lane life|business|code] [--ttl 7] [--when "<condition>"] [--source y] [--probe "<cmd that fails now>"] [--replace <id>]');
   console.log('list [--json] [--lane x]');
+  console.log('park <id> [--why "..."]');
+  console.log('parked [--json]');
+  console.log('reopen <id> [--replace <id>]');
   console.log('done <id> [--proof "..."]  (a probed incident closes only after its probe holds)');
   console.log('check [id] [--json]  (run live probes; failing probe = old theory still live)');
   console.log('dissolve <id> --why "..."');
@@ -336,6 +365,58 @@ function printHelp() {
   console.log('scan [--json]');
 }
 
+function appendParkedEvent(flag, cwd, now, why, options = {}) {
+  const at = now.toISOString();
+  const event = {
+    kind: 'parked',
+    at,
+    id: flag.id,
+    parked_at: at,
+    why: normalizeSpaces(why || 'parked by request'),
+  };
+  if (options.automatic) event.automatic = true;
+  appendEvent(event, cwd);
+  return {
+    id: flag.id,
+    what: flag.what,
+    parked_at: at,
+    why: event.why,
+  };
+}
+
+function slotCapError(flags) {
+  const fullest = flags
+    .slice()
+    .sort(compareOpenFlags)
+    .slice(0, 3)
+    .map((flag) => trimSentenceEnd(flag.what).toLowerCase())
+    .join(', ');
+  const names = fullest ? ` the fullest loops are ${fullest}.` : '';
+  return new Error(`ten open loops is the cap.${names} park one first or use --replace <id>`);
+}
+
+function makeRoomForOpenFlag(cwd, now, replaceId, incomingWhat) {
+  const flags = openFlags(cwd, { now });
+  const hasReplacement = replaceId !== undefined;
+  if (hasReplacement && (replaceId === true || !normalizeSpaces(replaceId))) {
+    throw new Error('--replace needs an id');
+  }
+  if (!hasReplacement) {
+    if (flags.length >= MAX_OPEN_FLAGS) throw slotCapError(flags);
+    return null;
+  }
+  if (flags.length > MAX_OPEN_FLAGS) throw slotCapError(flags);
+
+  const replacement = flags.find((flag) => flag.id === replaceId);
+  if (!replacement) throw new Error(`${replaceId} is not open`);
+  return appendParkedEvent(
+    replacement,
+    cwd,
+    now,
+    `replaced to make room for ${trimSentenceEnd(incomingWhat).toLowerCase()}`
+  );
+}
+
 function commandAdd(args, context = {}) {
   const { positional, options } = parseArgs(args);
   const what = normalizeSpaces(positional.join(' '));
@@ -366,6 +447,8 @@ function commandAdd(args, context = {}) {
     probeExit = result.exit_code;
   }
 
+  makeRoomForOpenFlag(context.cwd, now, options.replace, what);
+
   const openedAt = now.toISOString();
   const event = {
     kind: 'opened',
@@ -461,21 +544,88 @@ function commandCheck(args, context = {}) {
   return anyFailing ? 1 : 0;
 }
 
+function hasRunnableNextAction(flag) {
+  if (flag.probe) return true;
+  return /\b(accept|add|approve|book|build|call|check|choose|close|confirm|deploy|dissolve|email|fix|merge|pay|publish|reply|resolve|retry|review|run|send|ship|sign|test|update|verify|write)\b/.test(canonicalWhat(flag.what));
+}
+
+function hasMachineCheckableClose(flag) {
+  if (flag.probe) return true;
+  if (canonicalWhat(flag.close_condition).includes('source store resolves')) return true;
+  return /^(experiment|lesson|mission|pulse|task|usage|watch):/.test(canonicalWhat(flag.source));
+}
+
+function migrationReason(flag, duplicateIds) {
+  if (ownerWaitRank(flag) === 0) return 'waiting on a human';
+  if (!hasRunnableNextAction(flag)) return 'no runnable next action';
+  if (!hasMachineCheckableClose(flag)) return 'no machine-checkable close condition';
+  if (duplicateIds.has(flag.id)) return 'duplicates another open loop';
+  return '';
+}
+
+function compareOldestFlags(a, b) {
+  const aOpened = parseDate(a.opened_at) || 0;
+  const bOpened = parseDate(b.opened_at) || 0;
+  if (aOpened !== bOpened) return aOpened - bOpened;
+  return a.id.localeCompare(b.id);
+}
+
+function migrateOpenSlots(cwd = process.cwd(), now = new Date(), options = {}) {
+  const flags = openFlags(cwd, { now });
+  const excess = flags.length - MAX_OPEN_FLAGS;
+  const shouldWrite = options.dryRun !== true && options.write !== false && options.readOnly !== true;
+  if (excess <= 0 || !shouldWrite) return [];
+
+  const byWhat = new Map();
+  for (const flag of flags) {
+    const key = canonicalWhat(flag.what);
+    if (!byWhat.has(key)) byWhat.set(key, []);
+    byWhat.get(key).push(flag);
+  }
+  const duplicateIds = new Set(
+    Array.from(byWhat.values())
+      .filter((group) => group.length > 1)
+      .flat()
+      .map((flag) => flag.id)
+  );
+
+  const preferred = [];
+  const fallback = [];
+  for (const flag of flags.slice().sort(compareOldestFlags)) {
+    const why = migrationReason(flag, duplicateIds);
+    if (why) preferred.push({ flag, why });
+    else fallback.push({ flag, why: 'oldest loop above the active slot cap' });
+  }
+
+  return preferred.concat(fallback).slice(0, excess).map(({ flag, why }) => (
+    appendParkedEvent(flag, cwd, now, why, { automatic: true })
+  ));
+}
+
 function commandList(args, context = {}) {
   const { options } = parseArgs(args);
   const lane = options.lane ? String(options.lane).toLowerCase() : null;
   if (lane && !VALID_LANES.has(lane)) throw new Error('lane must be business, life, or code');
 
+  const now = context.now ? new Date(context.now) : new Date();
+  const autoClosed = autoCloseResolvedTaskReviewFlags(context.cwd, now);
+  const autoParked = migrateOpenSlots(context.cwd, now);
   let flags = openFlags(context.cwd, { now: context.now });
   if (lane) flags = flags.filter((flag) => flag.lane === lane);
   flags.sort(compareOpenFlags);
 
   if (options.json) {
-    printJson({ open: flags.map(publicFlag) });
+    const payload = { open: flags.map(publicFlag) };
+    if (autoClosed.length > 0) payload.auto_closed = autoClosed.map(publicTaskReviewClosed);
+    if (autoParked.length > 0) payload.auto_parked = autoParked;
+    printJson(payload);
     return 0;
   }
 
+  autoClosed.forEach((item) => console.log(taskReviewClosedLine(item)));
+  autoParked.forEach((flag) => console.log(migratedParkLine(flag)));
   if (flags.length === 0) {
+    if (autoClosed.length > 0) return 0;
     console.log('nothing open.');
     return 0;
   }
@@ -484,6 +634,50 @@ function commandList(args, context = {}) {
   return 0;
 }
 
+function commandPark(args, context = {}) {
+  const { positional, options } = parseArgs(args);
+  const id = positional[0];
+  if (!id) throw new Error('id is required');
+  const flag = requireOpenFlag(id, context);
+  const now = context.now ? new Date(context.now) : new Date();
+  const why = options.why === true ? undefined : options.why;
+  appendParkedEvent(flag, context.cwd, now, why);
+  console.log(`parked ${id}`);
+  return 0;
+}
+
+function commandParked(args, context = {}) {
+  const { options } = parseArgs(args);
+  const flags = parkedFlags(context.cwd, { now: context.now });
+  if (options.json) {
+    printJson({ parked: flags.map(publicFlag) });
+    return 0;
+  }
+  if (flags.length === 0) {
+    console.log('nothing parked.');
+    return 0;
+  }
+  flags.forEach((flag) => console.log(parkedLine(flag)));
+  return 0;
+}
+
+function commandReopen(args, context = {}) {
+  const { positional, options } = parseArgs(args);
+  const id = positional[0];
+  if (!id) throw new Error('id is required');
+  const flag = parkedFlags(context.cwd, { now: context.now }).find((item) => item.id === id);
+  if (!flag) throw new Error(`${id} is not parked`);
+  const now = context.now ? new Date(context.now) : new Date();
+  makeRoomForOpenFlag(context.cwd, now, options.replace, flag.what);
+  appendEvent({
+    kind: 'reopened',
+    at: now.toISOString(),
+    id,
+  }, context.cwd);
+  console.log(`reopened ${id}`);
+  return 0;
+}
+
 function requireOpenFlag(id, context = {}) {
   const flag = openFlags(context.cwd, { now: context.now }).find((item) => item.id === id);
   if (!flag) throw new Error(`${id} is not open`);
@@ -559,6 +753,8 @@ function commandSnooze(args, context = {}) {
 // one escalated event per overdue flag per day, return the resulting state.
 function sweepState(cwd = process.cwd(), now = new Date(), options = {}) {
   const today = isoDateOnly(now);
+  const autoClosed = autoCloseResolvedTaskReviewFlags(cwd, now);
+  const autoParked = migrateOpenSlots(cwd, now, options);
   let flags = openFlags(cwd, { now });
   const overdue = flags.filter((flag) => flag.overdue).sort(compareSweepFlags);
   const escalatedToday = [];
@@ -578,24 +774,39 @@ function sweepState(cwd = process.cwd(), now = new Date(), options = {}) {
   }
 
   flags = openFlags(cwd, { now });
-  return { open: flags.length, overdue, escalated_today: escalatedToday };
+  const result = { open: flags.length, overdue, escalated_today: escalatedToday };
+  if (autoClosed.length > 0) result.auto_closed = autoClosed;
+  if (autoParked.length > 0) result.auto_parked = autoParked;
+  return result;
 }
 
 function commandSweep(args, context = {}) {
   const { options } = parseArgs(args);
   const now = context.now ? new Date(context.now) : new Date();
-  const { open, overdue, escalated_today: escalatedToday } = sweepState(context.cwd, now);
+  const {
+    open,
+    overdue,
+    escalated_today: escalatedToday,
+    auto_closed: autoClosed = [],
+    auto_parked: autoParked = [],
+  } = sweepState(context.cwd, now);
 
   if (options.json) {
-    printJson({
+    const payload = {
       open,
       overdue: overdue.length,
       escalated_today: escalatedToday,
-    });
+    };
+    if (autoClosed.length > 0) payload.auto_closed = autoClosed.map(publicTaskReviewClosed);
+    if (autoParked.length > 0) payload.auto_parked = autoParked;
+    printJson(payload);
     return 0;
   }
 
+  autoClosed.forEach((item) => console.log(taskReviewClosedLine(item)));
+  autoParked.forEach((flag) => console.log(migratedParkLine(flag)));
   if (overdue.length === 0) {
+    if (autoClosed.length > 0) return 0;
     console.log('nothing is overdue.');
     return 0;
   }
@@ -830,7 +1041,11 @@ function taskSource(task) {
 
 function taskResolved(task) {
   const status = normalizeSpaces(task && task.status).toLowerCase();
-  return status === 'done' || status === 'accepted';
+  const review = reviewObject(task);
+  const metadata = task && task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  const approval = normalizeSpaces(review.approval_status || metadata.approval_status).toLowerCase();
+  return ['done', 'accepted', 'closed'].includes(status)
+    || ['accepted', 'approved', 'done', 'closed'].includes(approval);
 }
 
 function reviewObject(task) {
@@ -938,7 +1153,15 @@ function shortText(text, maxLength = 70) {
   return clipped || value.slice(0, maxLength).trim();
 }
 
-function appendOpenedFromSource({ what, owner = 'operator', lane = 'code', ttlDays = 3, source }, cwd, now) {
+function appendOpenedFromSource({
+  what,
+  owner = 'operator',
+  lane = 'code',
+  ttlDays = 3,
+  source,
+  probe,
+  closeCondition = 'the source store resolves it',
+}, cwd, now) {
   const event = {
     kind: 'opened',
     at: now.toISOString(),
@@ -948,25 +1171,79 @@ function appendOpenedFromSource({ what, owner = 'operator', lane = 'code', ttlDa
     lane: VALID_LANES.has(lane) ? lane : 'code',
     opened_at: now.toISOString(),
     ttl_days: Number(ttlDays) || 3,
-    close_condition: 'the source store resolves it',
+    close_condition: normalizeSpaces(closeCondition) || 'the source store resolves it',
     source,
   };
+  const normalizedProbe = normalizeSpaces(probe || '');
+  if (normalizedProbe) event.probe = normalizedProbe;
   appendEvent(event, cwd);
   return event;
 }
 
-function appendClosedFromSource(flag, cwd, now, note) {
+function upsertSourceFlag(candidate, cwd = process.cwd(), options = {}) {
+  const now = options.now ? new Date(options.now) : new Date();
+  const source = normalizeSpaces(candidate && candidate.source);
+  if (!source) throw new Error('source is required');
+
+  const flags = openFlags(cwd, { now });
+  const existing = flags.find((flag) => flag.source === source);
+  if (!existing && flags.length >= MAX_OPEN_FLAGS) {
+    return { filed: false, refreshed: false, reason: 'full' };
+  }
+
+  const event = appendOpenedFromSource({ ...candidate, source }, cwd, now);
+  return { filed: true, refreshed: Boolean(existing), event };
+}
+
+function appendClosedFromSource(flag, cwd, now, note, proof = RESOLVED_IN_SOURCE_PROOF) {
   const event = {
     kind: 'closed',
     at: now.toISOString(),
     id: flag.id,
-    proof: RESOLVED_IN_SOURCE_PROOF,
+    proof,
   };
   if (note) event.note = note;
   appendEvent(event, cwd);
   return event;
 }
 
+function taskReviewFlag(flag) {
+  return flag && flag.source && flag.source.startsWith('task:')
+    && canonicalWhat(flag.what).includes('has waited in review too long');
+}
+
+function autoCloseResolvedTaskReviewFlags(cwd = process.cwd(), now = new Date()) {
+  const tasksById = latestById(readTaskProjection(cwd));
+  if (tasksById.size === 0) return [];
+
+  const closed = [];
+  const flags = foldEvents(readEvents(cwd), { now })
+    .filter((flag) => flag.status === 'open' || flag.status === 'parked')
+    .filter(taskReviewFlag);
+  for (const flag of flags) {
+    const watchedTaskId = flag.source.slice('task:'.length);
+    const task = tasksById.get(watchedTaskId);
+    if (!task || !taskResolved(task)) continue;
+    const ref = taskRef(task) || watchedTaskId;
+    const proof = `task ${ref.toLowerCase()} is closed in task projection`;
+    const event = appendClosedFromSource(flag, cwd, now, null, proof);
+    closed.push({ flag, event, task_ref: ref });
+  }
+  return closed;
+}
+
+function taskReviewClosedLine(item) {
+  return `auto-closed review reminder for task ${item.task_ref.toLowerCase()}.`;
+}
+
+function publicTaskReviewClosed(item) {
+  return {
+    id: item.event.id,
+    task_ref: item.task_ref,
+    proof: item.event.proof,
+  };
+}
+
 function scanState(cwd = process.cwd(), options = {}) {
   const now = options.now ? new Date(options.now) : new Date();
   const tasks = readTaskProjection(cwd);
@@ -1256,6 +1533,9 @@ function run(args = [], context = {}) {
     }
     if (subcommand === 'add') return commandAdd(rest, context);
     if (subcommand === 'list') return commandList(rest, context);
+    if (subcommand === 'park') return commandPark(rest, context);
+    if (subcommand === 'parked') return commandParked(rest, context);
+    if (subcommand === 'reopen') return commandReopen(rest, context);
     if (subcommand === 'done') return commandDone(rest, context);
     if (subcommand === 'dissolve') return commandDissolve(rest, context);
     if (subcommand === 'snooze') return commandSnooze(rest, context);
@@ -1277,6 +1557,8 @@ module.exports = {
   closeIdForWhat,
   foldEvents,
   openFlags,
+  parkedFlags,
+  upsertSourceFlag,
   ledgerPath,
   readEvents,
   sweepLine,

package/commands/integrations.js

@@ -443,8 +443,16 @@ async function gmailTriage(options = {}) {
   const accountId = resolveGmailAccountId(options.accountId);
   const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 25;
   const messages = await gmailInbox({ accountId, limit, quiet: true });
+  // The hourly pass rereads the newest window, so without this filter a message
+  // gets one row per hour it lingers and counts measure dwell time, not preference.
+  const seen = new Set(
+    readGmailVerdicts({ root: options.root, filePath: options.filePath, account: accountId, limit: null })
+      .map((row) => row.message_id),
+  );
+  const fresh = messages.filter((message) => !seen.has(String(message.id || message.message_id || '')));
+  const skipped = messages.length - fresh.length;
   const ts = new Date().toISOString();
-  const rows = messages.map((message) => {
+  const rows = fresh.map((message) => {
     const { verdict, reason } = gmailTriageVerdict(message, { details: true });
     return {
       ts,
@@ -460,7 +468,8 @@ async function gmailTriage(options = {}) {
 
   const keepCount = rows.filter((row) => row.verdict === 'keep').length;
   const archiveCount = rows.length - keepCount;
-  console.log(`gmail triage recorded ${keepCount} keep and ${archiveCount} archive verdict${rows.length === 1 ? '' : 's'}.`);
+  const skippedNote = skipped > 0 ? ` (${skipped} already judged)` : '';
+  console.log(`gmail triage recorded ${keepCount} keep and ${archiveCount} archive verdict${rows.length === 1 ? '' : 's'}${skippedNote}.`);
   return rows;
 }
 

package/commands/mission.js

@@ -978,11 +978,6 @@ function loadMissionMap(root = process.cwd()) {
   return map;
 }
 
-function hasLocalMissionState(root = process.cwd()) {
-  return readJsonLines(statePaths(root).missionsJsonl)
-    .some((mission) => mission && mission.id && mission.cloud !== true);
-}
-
 const LIVE_MISSION_TICK_MS = 24 * 60 * 60 * 1000;
 
 function isLiveInFlightMission(mission, now = Date.now(), root = process.cwd()) {
@@ -1024,19 +1019,15 @@ function speakMissionDoor(args = [], root = resolveWorkspaceRoot()) {
   if (live) {
     return statusMission(asJson ? [live.id, '--json'] : [live.id]);
   }
-  if (isFreshWorkspace(root) || hasLocalMissionState(root)) {
-    const code = speakFirstMinute({
-      root,
-      fresh: isFreshWorkspace(root),
-      asJson,
-    });
-    process.exitCode = code;
-    return code;
-  }
-  return require('./human-missions').currentMissionCommand(args, {
+  // Nothing running in this folder: same two spoken lines as bare atris.
+  // A finished or account-global mission from another room is not the live card.
+  const code = speakFirstMinute({
     root,
-    fallbackOnMissing: true,
+    fresh: isFreshWorkspace(root),
+    asJson,
   });
+  process.exitCode = code;
+  return code;
 }
 
 function terminalNextAction(status) {