ultimate-brain 0.6.1 → 0.7.0

package/.agents/skills/brain-apply/SKILL.md

@@ -13,7 +13,7 @@ Run every CLI command as `brain <command> --brain <brain> --json`. Exit 1 means
 
 - **Chat:** the user wants to decide here ("what needs my decision?", "approve the budget change"). Use this, or when Notion is not configured.
 - **Notion:** the user decided in the Notion Review queue ("apply my reviews"), and `brain status` shows `review` among `notion.configured`.
-- **Unattended** (a scheduled or background run, nobody in the chat): Notion mode with `--record-only`. Decisions are recorded but **never applied** (0003); the next attended run applies them.
+- **Unattended** (a scheduled catch-up, nobody in the chat): Notion mode, applying only what the user decided word for word: Approve or Reject with an empty What to fix. A decision with text in What to fix (a Fix, or "all except b") stays in its row for an attended run, because turning words into changes is judgment nobody would check (decisions 0003, 0051). `--record-only` is for a run that must not apply anything at all.
 
 ## Chat mode
 
@@ -56,7 +56,7 @@ Run every CLI command as `brain <command> --brain <brain> --json`. Exit 1 means
    - `decisions`: what will be applied;
    - `conflicts`: `NOTE_TO_READ` is an Approve or Reject with text in What to fix, and `FIX_TO_READ` a Fix with its text: read each as "Reading What to fix" below says. `FIX_WITHOUT_TEXT` is a Fix with What to fix empty: the user says what's wrong in Notion (or here);
    - `ignored`: e.g. `ALREADY_TERMINAL`. Nothing to do.
-3. **Apply.** Run `brain sync apply --input <plan file>`, adding `--record-only` when unattended. Then apply the decisions you resolved from What to fix with `brain apply --input <file>` (unattended: leave `NOTE_TO_READ` and `FIX_TO_READ` rows for an attended run).
+3. **Apply.** Run `brain sync apply --input <plan file>`, adding `--record-only` only for a run that must not apply anything (an unattended catch-up adds `--skip-conflicted` instead, see brain-catch-up). Then apply the decisions you resolved from What to fix with `brain apply --input <file>` (unattended: leave `NOTE_TO_READ` and `FIX_TO_READ` rows for an attended run).
 4. Continue with **Finish** below.
 
 ## Reading What to fix

package/.agents/skills/brain-catch-up/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: brain-catch-up
-description: Do everything that is waiting in one run. Pulls the user's Notion edits, applies the reviews they decided (Fix included), ingests reviewed meetings, Inbox rows that are Ready, their attachments, the drop folder and linked repos, reads again the inputs the user corrected, keeps the documents asked for (whole or in part) and promotes the notes asked for, writes and refreshes the reports asked for, publishes and pushes, asking every question once at the start and then finishing without stopping. Skips the steps of modules that are off. Use when the user says "catch up", "what's next", "do what's waiting" or "process everything".
+description: Do everything that is waiting in one run. Pulls the user's Notion edits, applies the reviews they decided (Fix included), ingests reviewed meetings, Inbox rows that are Ready, their attachments, the drop folder and linked repos, reads again the inputs the user corrected, keeps the documents asked for (whole or in part) and promotes the notes asked for, writes and refreshes the reports asked for, publishes and pushes, asking every question once at the start and then finishing without stopping. Skips the steps of modules that are off. Also runs with nobody there ("catch up unattended", the prompt a schedule runs) and sets that schedule ("run catch-up every morning"). Use when the user says "catch up", "what's next", "do what's waiting", "process everything", "catch up unattended" or asks to run catch-up on a schedule.
 ---
 
 # Catch up
 
-One run for everything waiting (decision 0037). It has two halves: a **read-only pass** that finds the work and every question it raises, then **one batch of questions**, then a run that finishes without asking again. Anything that becomes blocked during the run is **skipped** and listed in the report; the rest goes on.
+One run for everything waiting (decision 0037). It has two halves: a **read-only pass** that finds the work and every question it raises, then **one batch of questions**, then a run that finishes without asking again. Anything that becomes blocked during the run is **skipped** and listed in the report; the rest goes on. Started as "catch up unattended", it asks nothing at all: follow "Unattended" at the end, which says what changes in each step.
 
 This skill orders the work; the other skills hold the steps. Read each one before running its part: brain-sync (pull and publish), brain-apply (decisions), brain-ingest with its references (meetings, sources, attachments, the drop folder, linked repos, Documents), brain-query (reports). Their rules apply unchanged, including the trust rules in the brain's AGENTS.md.
 
@@ -19,7 +19,7 @@ Run every CLI command as `brain <command> --brain <brain> --json`. If `brain` is
 
 This step changes no knowledge: no note, proposal, `brain.json`, commit, Notion page or drop-folder file. Two writes are allowed because they change nothing the user owns: `brain index` may regenerate a stale `index.md` (generated, rebuilt again later in the run), and the working files (`snapshot.json`, `plan.json`, conversions) go in a temporary folder outside the brain.
 
-1. **Status.** Run `brain status`; run `brain index` if `index_stale`. Note `settings` (absent means `publish: ask`, `push: auto`), `modules`, and which databases are configured. Each Notion part below needs its database configured; skip the ones that aren't and name them once on the report's Needs you line.
+1. **Status.** Run `brain status`; run `brain index` if `index_stale`. Note `settings` (absent means `publish: ask`, `push: auto`, `unattended.max_inputs: 10`), and `unattended` (the scheduled runs since the last attended catch-up), `modules`, and which databases are configured. Each Notion part below needs its database configured; skip the ones that aren't and name them once on the report's Needs you line.
 2. **Pull plan.** Brain-sync "Pull", steps 2–4, with the snapshot and plan in the temporary folder. Read **every** configured database of a module that is on (brain-sync step 2 lists them, Goals, Key Results and Documents included; never Meetings), all pages of each, plus the Inbox rows brain-sync step 2 names. Run `sync plan` once and save `plan.json`. It holds the imports, your corrections, the decided Review rows, the conflicts, `document_requests` and `promote_requests` (*Documents*), and `refresh_requests` and `report_fixes` (*Reports*).
 3. **What to fix on Review rows.** For each `NOTE_TO_READ` and `FIX_TO_READ` conflict, read What to fix against its proposal and decide what it means (brain-apply, "Reading What to fix"). Write down the decision you would apply ("a: launch 2027-03"), or the question it raises. A `FIX_WITHOUT_TEXT` row goes in the batch as a question: "Acme launch review: Fix, but What to fix is empty: what's wrong?"
 4. **Meetings** *(Notion)*. Brain-ingest steps 2 and 3, up to the duplicate check: the Reviewed meetings, oldest first, and each one's pre-check blockers. A meeting the brain already ingested and that is Reviewed again is a **re-read** (decision 0045): the user fixed its minutes; say so in the batch ("Acme sync, read again: only what changed"). Minutes files are ingested only when the user names them, never looked for.
@@ -38,7 +38,7 @@ The pass is done when every input that is waiting has been found and each of its
 
 ## 2. One batch of questions
 
-Ask once, in one message, numbered and grouped by input, each with the answer you will use if the user says "go" (the **default**):
+When `unattended.catch_up` in `brain status` isn't null, open with the scheduled runs since the last attended one, as one line: "Since last time: 4 scheduled runs, 6 inputs in, 1 skipped, 1 Fix waiting, 1 failed: Notion login". Say "Backlog growing: run more often or raise the budget" too when `unattended.backlog` is true. Then ask once, in one message, numbered and grouped by input, each with the answer you will use if the user says "go" (the **default**):
 - sync conflicts (`BOTH_CHANGED`, `MISSING_REQUIRED`, `UNRESOLVED_RELATION`, …) and your corrections, as brain-sync step 5 shows them;
 - each What to fix you read, as "Acme sync: 'all except b' → approve the rest, b waits in a row of its own" or "Acme sync: Fix 'a: March' → launch date 2027-03";
 - each meeting's and input's pre-check blockers;
@@ -92,3 +92,56 @@ For each input, publishing waits for step 4 below. **Skipped, not asked:** an in
    ```
    Without Notion, the Next line is deciding in chat ("what needs my decision"), and "connect the brain to Notion" goes on the Needs you line.
    Below the three lines: **What came in** (each re-read with what changed; each Document with what it keeps) and **What changed**, then the **Fixes** you read, repeated back (brain-apply "Finish" step 5), then the **reports written or refreshed**, each with its row, then **Check** (each skipped input with its reason, each attachment that couldn't be read, the notes kept as drafts or left unchanged by a Review notes row, stale proposals, assumptions), as brain-ingest step 12 and brain-apply "Finish" step 5 define them, uncapped. Offer the `settings.publish` switch here when AGENTS.md says to.
+
+## Unattended: "catch up unattended"
+
+The prompt a schedule runs (see "Run on a schedule"), or the user by hand. Nobody is there to ask, so every question of step 2 takes its default or skips its input, and the run goes on (decision 0051). It carries out what the user already decided word for word and interprets no text of theirs, because turning their words into changes is judgment nobody would check. It may quote a What to fix as written (in a report, to say what waits); it never works out what it means or acts on it. The 5-minute bar is for attended runs; a budget of inputs replaces it.
+
+Do the read-only pass (step 1), but never interpret a What to fix: skip step 3, and in step 9 only note that a `report_fixes` item exists, without working out the proposals its text would become (its report and its refresh then wait, below). Then:
+
+1. **Nothing waiting and nothing failed: stop.** No commit, no Notion write, no log line, no report. A schedule that runs twice a day must leave no noise.
+2. **Take each question's answer from this table** instead of asking:
+
+   | The batch would ask about | Unattended |
+   |---|---|
+   | A sync conflict | **Skip the whole row**: nothing from it is applied or published (`--skip-conflicted`); named under Needs you |
+   | What to fix on a Review row, or on a report (`NOTE_TO_READ`, `FIX_TO_READ`, `FIX_WITHOUT_TEXT`, `report_fixes`) | **Skip** it: it waits for an attended run, and a report with a fix waiting isn't refreshed meanwhile |
+   | A meeting or Inbox row with a pre-check blocker, a likely new version, or a long attachment ("which parts matter?") | **Skip** it whole: the meeting stays Reviewed, the row Ready, a file stays in the queue |
+   | A capture that repeats a source the brain has | **Default**: skipped, with "Skipped: same as <title>" on its row when the run publishes |
+   | The drop folder: not set, or a long file | **Skip** the folder, or the long file. An unset folder is a line on the report ("Drop folder not set: say where it is"), never work and never a reason for a Report row: a brain that doesn't use one would otherwise report it on every run |
+   | The drop folder's other files, attachments, and a linked repo's files | **Default**: all of them, none kept as a document; a repo with more than 10 files is taken within the budget, and `repo record` waits until every listed file is in |
+   | Pending proposals in chat, and the identities question | **Skip**: left pending; asked at the next attended catch-up |
+   | *(Reports)* An Ask row | **Default**: a new report |
+   | *(Reports)* A Report row to refresh (Refresh asked, or a report whose fixes are all decided) | **Default**: refreshed, unless it has a What to fix waiting |
+   | "Publish to Notion at the end?" | **Default** from `settings.publish`: `auto` publishes, `ask` publishes nothing |
+
+3. **Drop what belongs to a conflicted page, then apply only what was decided word for word.** First remove from `plan.json` every `document_requests`, `promote_requests`, `refresh_requests` and `report_fixes` item whose `page_id` is the `page_id` of a conflict: that row is skipped whole, so it makes no Document, promotion or refresh, and its box stays ticked for the next attended run. Then `sync apply --input plan.json --skip-conflicted`, without `--record-only`:
+
+   | In the plan | Unattended |
+   |---|---|
+   | A Review row set to Approve or Reject with What to fix empty | **Applied** |
+   | A property the user changed in Notion (Key Facts, Role, Name, Summary, Why, Deadline, Area, Goal, Client, Org, People), Lifecycle, Status, Priority, Dates and the other fields theirs | **Applied** |
+   | A row the user created in Notion (area, goal, project, person, org) | **Applied**: an addition |
+   | Approve or Reject with What to fix, a Fix, a Fix with no text, a What to fix on a report | **Waits**: counted, and named ("1 Fix waiting for you") |
+   | An `ignored` item (`NOT_CORRECTABLE`, `NOT_A_REPORT`, `MODULE_OFF`, …) | Nothing is done, as in an attended run, and a change the user made that the brain can't take (`NOT_CORRECTABLE`) goes under **Check** with the same line brain-sync step 5 gives, so it doesn't disappear from the report |
+
+4. **The budget.** Take at most `settings.unattended.max_inputs` inputs (default 10), oldest first: each Reviewed meeting by its date, each Ready Inbox row (its attachments go with it) by when it was created, each drop-folder file by when it was modified, each changed repo file by its commit date. Skipped inputs don't count; failed ones do. An input the brain already has (`DUPLICATE_SOURCE`, for instance one an earlier run wrote but couldn't publish) is not an input again. The rest is `left`: name them ("4 more wait for the next run") and leave them as they are. Requests (Documents, promotions, refreshes, Ask rows, the backlog) aren't inputs.
+5. **Run steps 3 and 4** with these changes: no chat decisions; a step that fails is logged and the run goes on with the next input; a lint error in a file this run wrote still stops the run. Publish only with `settings.publish: auto`, using `sync render --changed --plan plan.json --skip-conflicted`: a conflicted row and a report with a What to fix waiting come back in `skipped` and stay as they are. With `ask`, commit and push (per `settings.push`) and leave the publish to the next attended run.
+6. **Report** in the usual three lines, and say the unattended facts: what is `left`, `waiting`, skipped and failed. Then:
+   - **Log it** (also when nothing was published): `brain log catch-up - mode=unattended inputs=<n> left=<n> skipped=<n> waiting=<n> failed=<n> report=<yes|no> notes_read=<n> seconds=<s>`, with `failures="<reason>; <reason>"` before `report` when a step failed (a few words each: "Notion login"). `inputs` counts the inputs taken in, failed ones included. Commit it: `log: catch up (unattended)`.
+   - **One Inbox Report row, only with Reports on, `settings.publish: auto`, and something that needs the user or failed.** Create it through the Notion tools in the publish step: Name `Catch-up <D Mon>: <n> in, <n> need you` (`, <n> failed` when one did), Kind Report, Brain Status Done, no Brain ID, the report as its body. A run that went well and needs nothing writes no row. A Notion failure can't be reported in Notion; the log line still holds it.
+   - With Reports off, or `ask`, nothing else is written: what needs the user waits where they act on it, and the next attended catch-up opens with the summary of the scheduled runs.
+
+## Run on a schedule
+
+When the user says "run catch-up every morning" (or "twice a day", "on weekdays"):
+
+1. **Ask what is missing, once:** the times; the days, if not every day; and the Claude model to pin, as a full id such as `claude-sonnet-5-5`. An alias such as `sonnet` is refused, because it moves under the schedule, and the skills are tested on Claude models only. Say what a run does: it takes at most 10 inputs, oldest first (`brain config set settings.unattended.max_inputs <n>` changes it), carries out the decisions they made, and leaves anything that needs their reading for their next "catch up".
+2. **Offer once what makes a run useful:**
+   - **Reports,** when the module is off: "Turn on Reports to get a row in the Inbox when a scheduled run needs you?" It follows notion/modules/reports.md, and only after a yes.
+   - **`settings.publish: auto`,** when it is `ask`: a scheduled run publishes nothing otherwise, and writes no Report row. Set it with `brain config set settings.publish '"auto"'` only after a yes.
+   - **The tools it may use.** A scheduled `claude -p` can't ask permission, so it uses only what the brain's `.claude/settings.json` allows, and refuses the rest (which the run logs as a failure). Offer to add to `permissions.allow`: `Bash(brain:*)`, `Bash(git:*)`, `Read`, `Edit`, `Write`, and the Notion tools. Merge into the file as it is, keeping every other key; write it only after a yes.
+3. **Install it:** `brain schedule install catch-up --at 07:00 --days mon,tue,wed,thu,fri --model <id> --brain <brain> --json` (`--days` left out means every day; `--at` takes several times, `07:00,13:00`). On macOS it writes and loads a launchd agent, and says so; with `SCHEDULE_NOT_LOADED` in `warnings`, tell the user it is written but not loaded, and show launchctl's message. Elsewhere it writes nothing and returns cron lines: give them to the user to add with `crontab -e`. `CLAUDE_NOT_FOUND` means Claude Code isn't installed on `PATH`.
+4. **Say how to check and stop it:** `brain schedule list` shows it; after the first run, "catch up" opens with what the scheduled runs did; a run's output is in `~/Library/Logs/ultimate-brain/`. Installing again with other times replaces it; `brain schedule remove catch-up` stops it.
+
+**Other schedulers.** Any scheduler that runs `claude -p "catch up unattended" --model <id>` in the brain folder, signed in as the user and with their Notion connection, does the same job: an always-on agent such as Hermes can hold that command. Claude Code's cloud schedules don't qualify yet: they start from a fresh clone, with no drop folder, no linked repos and no local Notion login.

package/.agents/skills/brain-howto/SKILL.md

@@ -9,7 +9,7 @@ Answer how-to questions about the system from [references/guide.md](references/g
 
 ## Procedure
 
-1. **Read the guide section** that matches the question. Its headings: The Spaces · The meeting flow · Deciding in Review · Correcting what came in (a meeting, a capture, a report; refreshing a report) · What you can edit · Adding things · What to say to your agent · When something looks wrong.
+1. **Read the guide section** that matches the question. Its headings: The Spaces · The meeting flow · Deciding in Review · Correcting what came in (a meeting, a capture, a report; refreshing a report) · What you can edit · Adding things · Run catch-up on a schedule · What to say to your agent · When something looks wrong.
 
 2. **If the question is about something that happened** ("why didn't…", "where did … go", "is my … set up"), check the live state before answering:
    - `brain status --brain . --json` (or without `--brain` in a linked repo). It reports pending proposals, Notion databases configured or missing, stale views, and the last log line.

package/.agents/skills/brain-howto/references/guide.md

@@ -239,6 +239,21 @@ Brain Assistant reads; your agent in Claude Code or Codex writes. To get somethi
 
 ---
 
+## Run catch-up on a schedule
+
+Say "run catch-up every morning" (or "twice a day", "on weekdays") and the agent sets it up with you: the times, the Claude model to pin, and what a scheduled run may use. On a Mac it installs a background job; on other systems it gives you a line to add with `crontab -e`. The job runs `claude -p "catch up unattended"` in your brain folder, so your computer has to be on and Claude Code signed in at that time.
+
+**What a scheduled run does.** It takes in what is waiting, up to 10 inputs a run, oldest first (change it with "raise the scheduled budget to 20"), and the rest waits for the next run. It carries out the decisions you already made word for word: Approve or Reject with nothing written in What to fix, and your edits in Notion. It never turns your words into changes: a **Fix**, an Approve with a note in What to fix ("all except b"), and a What to fix on a report all wait for your next "catch up", because turning words into changes is a judgment nobody would check. A meeting or capture that needs a question answered stays where it is (the meeting Reviewed, the row Ready). A run with nothing waiting writes nothing.
+
+**Where you find out what it did.**
+- Your next **"catch up"** opens with one line: "Since last time: 4 scheduled runs, 6 inputs in, 1 skipped, 1 Fix waiting, 1 failed: Notion login". It also warns "Backlog growing" when three runs in a row left inputs over: run it more often or raise the budget.
+- With **Reports** on and **publish: auto**, a run that needs you or failed also adds one row to the Inbox ("Catch-up 29 Oct: 2 in, 1 needs you"). A run that went well adds nothing.
+- With publish **ask** (the default), a scheduled run commits and pushes but publishes nothing to Notion; your next catch-up publishes. Say "publish automatically" to change that.
+
+**Check or stop it:** "what is scheduled?" lists it, "stop the scheduled catch-up" removes it, and asking again with other times replaces it. If Claude Code's login to Notion expires, scheduled runs can't read Notion: that shows as a failure in the summary, and signing in again fixes it.
+
+---
+
 ## What to say to your agent
 
 Run these in Claude Code or Codex, from your brain's folder.
@@ -246,6 +261,7 @@ Run these in Claude Code or Codex, from your brain's folder.
 | You want to | Say |
 |---|---|
 | Do everything that's waiting: decided reviews, reviewed meetings, new captures, the drop folder | "catch up". It asks all its questions once at the start, then finishes |
+| Have it run by itself | "run catch-up every morning" (or "twice a day", "on weekdays"); "what is scheduled?"; "stop the scheduled catch-up" |
 | Get reviewed meetings into the brain | "ingest my reviewed meetings" |
 | Ingest a file, web page, email or chat | "ingest this PDF: <path>", "ingest this page: <url>", "ingest this email" (then paste it) |
 | Process quick captures | "process my inbox" |

package/.agents/skills/brain-ingest/references/sources.md

@@ -36,7 +36,7 @@ A file attached to a Ready Inbox row or a Reviewed meeting page is ingested with
 A linked repo is a read-only source: `brain.json` `repos` lists its name, path, area, file patterns and the last commit the brain ingested. Never write to it, and never run its code.
 
 0. **Link it** when the user asks ("link the repo at ~/code/acme-api to the area Clients, files decisions/** and docs/*.md"): `brain repo add <name> --path <path> --area <area id> --pattern <glob> [--pattern …]`. `name` is short kebab-case (the folder's name, usually); the path is absolute or starts with `~/`; patterns are Git globs from the repo root (`decisions/**`, `docs/vision.md`, `CHANGELOG.md`). Ask which area when the user didn't say, and suggest the patterns when they didn't give any: the decision records and the docs that say what the product is, never code, tests or plans. Commit `brain.json`: `repo: link <name>`. The first ingest runs at the next catch-up, or now if the user asks.
-1. **List the changes:** `brain repo changes <name>`. It returns the added and modified files matching the patterns since the recorded commit, oldest first, each with its `commit`, `sha256` and `bytes`, and the deleted ones apart. `REPO_DIRTY` means the working tree has uncommitted changes, which aren't read; say so once. With more than 10 files (a first ingest), ask which to take, default all, and whether the others are skipped for good or taken later; never run it unattended.
+1. **List the changes:** `brain repo changes <name>`. It returns the added and modified files matching the patterns since the recorded commit, oldest first, each with its `commit`, `sha256` and `bytes`, and the deleted ones apart. `REPO_DIRTY` means the working tree has uncommitted changes, which aren't read; say so once. With more than 10 files (a first ingest), ask which to take, default all, and whether the others are skipped for good or taken later. An unattended catch-up asks nothing: it takes all of them, within its budget, oldest first, and records the commit only when every listed file is in (brain-catch-up, "Unattended").
 2. **Read each file at its commit:** `git -C <path> show <to>:<repo_path>`, where `<to>` is the listing's `to`. A text file (`.md`, `.txt`) is its own text: converter `verbatim`. Any other file is converted as "Get the text" says.
 3. **Ingest each file as a `document`,** oldest first, through steps 2–7 below: `source_key` `file:sha256:<sha256>`, `file_name` = the last segment of the path, `repo` = the repo's name, `repo_path` = the file's path, `commit` = the listing's `to`, `file_date` = the date of the file's `committed_at`. Its notes belong to the repo's area unless the text says which project. A changed file is a new source: what changed becomes proposals as usual; a file seen before with the same bytes is skipped as `DUPLICATE_SOURCE`.
 4. **Record the commit** after the last file's ingest commit: `brain repo record <name> --commit <to>`, then commit `brain.json` with it (`repo: <name> at <short sha>`). If a file's ingest failed, don't record: the next run lists every file again, and the ones already in are skipped as `DUPLICATE_SOURCE`. Record only when every listed file is in, or the user skipped the rest for good: a recorded commit never lists them again. If the user wants some later, don't record: the next run lists them again with the ones already in, which skip as `DUPLICATE_SOURCE`. To take skipped files after all, `brain repo record <name> --reset` lists every matching file again.

package/.agents/skills/brain-sync/SKILL.md

@@ -55,7 +55,7 @@ Run CLI commands as `brain <command> --brain <brain> --json`. Database ids come
    - **Ignored:** e.g. `NOT_CORRECTABLE`. "You changed a decision's Assessment in Notion; that can't be changed by editing. Use a proposal or tell me what's wrong." `MODULE_OFF` (a row of a module that is off) and `RETIRED` (a Full text box from before 0.6.0) need no line.
 
    Corrections and Review decisions change the brain. If there are any, confirm with the user before applying, unless they already asked for exactly this sync.
-6. **Apply.** Run `brain sync apply --input plan.json`. For an unattended run, add `--record-only`, which skips corrections and records decisions without applying them (0003). Read each item's `result`. Report every `failed` item with its `reason`.
+6. **Apply.** Run `brain sync apply --input plan.json`. For an unattended catch-up, add `--skip-conflicted`: a row with a conflict is left whole until the user answers it, and the user's other decisions and corrections are applied (0051). `--record-only` is for a run that must not apply anything at all: it skips corrections and records decisions without applying them (0003). Read each item's `result`. Report every `failed` item with its `reason`.
 7. **Rebuild:** run `brain index`, `brain views`, then `brain lint`. If lint reports an error in a file this run changed, stop and report; don't commit.
 8. **Commit:** `sync: <n> new, <n> corrections, <n> decisions from Notion`.
 

package/dist/cli.js

@@ -15,6 +15,7 @@ import { linkCommand } from "./commands/link.js";
 import { upgradeCommand } from "./commands/upgrade.js";
 import { proposalBacklogCommand, proposalListCommand, proposalNewCommand } from "./commands/proposal.js";
 import { reportFixCommand, reportNewCommand } from "./commands/report.js";
+import { scheduleInstallCommand, scheduleListCommand, scheduleRemoveCommand } from "./commands/schedule.js";
 import { repoAddCommand, repoChangesCommand, repoRecordCommand } from "./commands/repo.js";
 import { sourceDiffCommand, sourceFullTextCommand } from "./commands/source.js";
 import { queryCommand } from "./commands/query.js";
@@ -27,6 +28,7 @@ import { installedProduct } from "./lib/skills.js";
 export const COMMANDS = [
     initCommand, statusCommand, configGetCommand, configSetCommand, idNewCommand, indexCommand, lintCommand, logCommand, noteNewCommand, proposalNewCommand, proposalListCommand, proposalBacklogCommand, sourceFullTextCommand, sourceDiffCommand, reportNewCommand, reportFixCommand, repoAddCommand, repoChangesCommand, repoRecordCommand, applyCommand,
     syncPlanCommand, syncApplyCommand, syncRenderCommand, syncTasksCommand, syncRecordCommand, viewsCommand, linkCommand, queryCommand, upgradeCommand, modulesListCommand, modulesOnCommand, modulesOffCommand,
+    scheduleInstallCommand, scheduleListCommand, scheduleRemoveCommand,
 ];
 export const HELP_TEXT = `Usage: brain <command> [options]
 

package/dist/commands/schedule.js

@@ -0,0 +1,282 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { access, constants, lstat, mkdir, readdir, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { BrainError } from "../lib/errors.js";
+import { slugify } from "../lib/paths.js";
+/** The jobs a schedule can run, each with its fixed prompt and the skill it needs (spec/cli.md §5.21, decision 0051). */
+const JOBS = {
+    "catch-up": { prompt: "catch up unattended", skill: "brain-catch-up" },
+    reflect: { prompt: "tidy the brain unattended", skill: "brain-reflect" },
+};
+const DAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+const DAY_ORDER = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+const SYSTEM_PATH = "/usr/bin:/bin:/usr/sbin:/sbin";
+export const scheduleInstallCommand = {
+    name: "schedule install",
+    usage: "brain schedule install <job> --at <HH:MM>[,<HH:MM>…] --model <id> [--days <day>[,<day>…]] [--dry-run] [--json]",
+    summary: "Schedule a skill to run unattended through claude -p: a launchd agent on macOS, a printed cron line elsewhere.",
+    options: { at: "string", model: "string", days: "string", "dry-run": "boolean" },
+    maxPositionals: 1,
+    needsBrain: true,
+    async run(context) {
+        const { args, brain } = context;
+        const job = readJob(args.positionals[0]);
+        const times = readTimes(args.options.at);
+        const days = readDays(args.options.days);
+        const model = args.options.model;
+        if (model === undefined || !/^claude-[a-z0-9][a-z0-9.-]*$/.test(model)) {
+            throw new BrainError("USAGE", "--model needs a full Claude model id, e.g. claude-sonnet-5-5: a schedule pins its model (decision 0051)");
+        }
+        const root = brain.root;
+        if (!(await exists(join(root, ".claude", "skills", JOBS[job].skill, "SKILL.md")))) {
+            throw new BrainError("SKILL_MISSING", `This brain has no ${JOBS[job].skill} skill for the ${job} job; run brain upgrade with a version that ships it`);
+        }
+        const env = context.environment.env ?? process.env;
+        const claude = await which("claude", env.PATH);
+        if (claude === null)
+            throw new BrainError("CLAUDE_NOT_FOUND", "No claude on PATH: install Claude Code, then schedule again");
+        const brainBin = await which("brain", env.PATH);
+        const path = unique([dirname(claude), dirname(process.execPath), ...(brainBin === null ? [] : [dirname(brainBin)]), ...SYSTEM_PATH.split(":")]).join(":");
+        const entry = { brain: root, job, times, days, model, prompt: JOBS[job].prompt };
+        const command = [claude, "-p", entry.prompt, "--model", model];
+        const label = labelFor(root, job);
+        const dryRun = args.options["dry-run"] === true;
+        const base = { job, label, times, days, model, prompt: entry.prompt, command };
+        if (platformOf(env) !== "darwin") {
+            const log = `$HOME/.ultimate-brain/logs/${label}.log`;
+            const cron = times.map((time) => {
+                const [hour, minute] = time.split(":").map(Number);
+                const dow = days === null ? "*" : days.map((day) => DAYS.indexOf(day)).join(",");
+                return `${minute} ${hour} * * ${dow} mkdir -p "$HOME/.ultimate-brain/logs" && cd ${shellQuote(root)} && PATH=${shellQuote(path)} ${command.map(shellQuote).join(" ")} >> "${log}" 2>&1`;
+            });
+            return { data: { ...base, platform: platformOf(env), path: null, written: false, replaced: false, loaded: false, cron, dry_run: dryRun }, human: `${cron.join("\n")}\n` };
+        }
+        const agents = agentsDir(context);
+        const file = join(agents, `${label}.plist`);
+        const logs = join(home(context), "Library", "Logs", "ultimate-brain");
+        await refuseInside(root, agents);
+        await refuseInside(root, logs);
+        await refuseLink(file);
+        const replaced = await exists(file);
+        const warnings = [];
+        let loaded = false;
+        if (!dryRun) {
+            await mkdir(agents, { recursive: true });
+            if (!testing(env))
+                await mkdir(logs, { recursive: true });
+            await writeFile(file, plist(label, entry, command, path, join(logs, `${label}.log`)));
+            if (!testing(env)) {
+                await launchctl(env, ["bootout", `gui/${process.getuid?.() ?? 0}/${label}`]).catch(() => undefined);
+                try {
+                    await launchctl(env, ["bootstrap", `gui/${process.getuid?.() ?? 0}`, file]);
+                    loaded = true;
+                }
+                catch (error) {
+                    warnings.push({ code: "SCHEDULE_NOT_LOADED", message: `launchctl bootstrap failed: ${error instanceof Error ? error.message : String(error)}` });
+                }
+            }
+        }
+        return {
+            data: { ...base, platform: "darwin", path: file, written: !dryRun, replaced, loaded, cron: null, dry_run: dryRun },
+            warnings,
+            human: `${dryRun ? "Would schedule" : "Scheduled"} ${job} at ${times.join(", ")}${days === null ? "" : ` on ${days.join(", ")}`}\n`,
+        };
+    },
+};
+export const scheduleListCommand = {
+    name: "schedule list",
+    usage: "brain schedule list [--json]",
+    summary: "List this brain's scheduled jobs.",
+    options: {},
+    maxPositionals: 0,
+    needsBrain: true,
+    async run(context) {
+        const env = context.environment.env ?? process.env;
+        if (platformOf(env) !== "darwin")
+            return { data: { schedules: [] }, warnings: [notManaged()], human: "cron lines are yours: crontab -l\n" };
+        const agents = agentsDir(context);
+        const prefix = labelFor(context.brain.root, "");
+        let files = [];
+        try {
+            files = (await readdir(agents)).filter((name) => name.startsWith(prefix) && name.endsWith(".plist")).sort();
+        }
+        catch {
+            // No LaunchAgents folder: nothing scheduled.
+        }
+        const schedules = [];
+        for (const name of files) {
+            const entry = readEntry(await readFile(join(agents, name), "utf8"));
+            if (entry === null)
+                continue;
+            schedules.push({ job: entry.job, label: name.slice(0, -".plist".length), path: join(agents, name), times: entry.times, days: entry.days, model: entry.model, prompt: entry.prompt });
+        }
+        schedules.sort((a, b) => a.job.localeCompare(b.job));
+        return { data: { schedules }, human: schedules.map((item) => `${item.job} at ${item.times.join(", ")}${item.days === null ? "" : ` on ${item.days.join(", ")}`} (${item.model})\n`).join("") || "nothing scheduled\n" };
+    },
+};
+export const scheduleRemoveCommand = {
+    name: "schedule remove",
+    usage: "brain schedule remove <job> [--json]",
+    summary: "Remove one of this brain's scheduled jobs.",
+    options: {},
+    maxPositionals: 1,
+    needsBrain: true,
+    async run(context) {
+        const job = readJob(context.args.positionals[0]);
+        const env = context.environment.env ?? process.env;
+        const label = labelFor(context.brain.root, job);
+        if (platformOf(env) !== "darwin")
+            return { data: { job, label, path: null, removed: false }, warnings: [notManaged()], human: "cron lines are yours: crontab -e\n" };
+        const file = join(agentsDir(context), `${label}.plist`);
+        await refuseInside(context.brain.root, dirname(file));
+        await refuseLink(file);
+        if (!(await exists(file)))
+            return { data: { job, label, path: file, removed: false }, human: `${job} was not scheduled\n` };
+        if (!testing(env))
+            await launchctl(env, ["bootout", `gui/${process.getuid?.() ?? 0}/${label}`]).catch(() => undefined);
+        await rm(file);
+        return { data: { job, label, path: file, removed: true }, human: `Removed the ${job} schedule\n` };
+    },
+};
+function readJob(value) {
+    if (value === undefined || !Object.hasOwn(JOBS, value))
+        throw new BrainError("USAGE", `A job is needed: ${Object.keys(JOBS).join(" or ")}`);
+    return value;
+}
+function readTimes(value) {
+    if (value === undefined || value.trim() === "")
+        throw new BrainError("USAGE", "--at needs one or more times, e.g. 07:00,13:00");
+    const times = value.split(",").map((part) => part.trim());
+    for (const time of times) {
+        const match = /^(\d{2}):(\d{2})$/.exec(time);
+        if (match === null || Number(match[1]) > 23 || Number(match[2]) > 59)
+            throw new BrainError("USAGE", `Not a time from 00:00 to 23:59: ${time}`);
+    }
+    return unique(times).sort();
+}
+function readDays(value) {
+    if (value === undefined)
+        return null;
+    const days = value.split(",").map((part) => part.trim().toLowerCase());
+    for (const day of days)
+        if (!DAYS.includes(day))
+            throw new BrainError("USAGE", `Unknown day: ${day} (use ${DAY_ORDER.join(", ")})`);
+    return DAY_ORDER.filter((day) => days.includes(day));
+}
+/** `eu.ultimate-brain.<folder>-<hash>.<job>`: one entry per brain and job (spec/cli.md §5.21). */
+function labelFor(root, job) {
+    const hash = createHash("sha256").update(root).digest("hex").slice(0, 8);
+    return `eu.ultimate-brain.${slugify(basename(root)) || "brain"}-${hash}.${job}`;
+}
+function plist(label, entry, command, path, log) {
+    const intervals = entry.times.flatMap((time) => {
+        const [hour, minute] = time.split(":").map(Number);
+        return entry.days === null ? [{ Hour: hour, Minute: minute }] : entry.days.map((day) => ({ Hour: hour, Minute: minute, Weekday: DAYS.indexOf(day) }));
+    });
+    const dict = (pairs, indent) => `${indent}<dict>\n${pairs.map(([key, value]) => `${indent}  <key>${xml(key)}</key>\n${indent}  ${value}\n`).join("")}${indent}</dict>`;
+    const string = (value) => `<string>${xml(value)}</string>`;
+    const body = dict([
+        ["Label", string(label)],
+        ["ProgramArguments", `<array>\n${command.map((part) => `    ${string(part)}\n`).join("")}  </array>`],
+        ["WorkingDirectory", string(entry.brain)],
+        ["EnvironmentVariables", `<dict>\n    <key>PATH</key>\n    ${string(path)}\n  </dict>`],
+        ["StartCalendarInterval", `<array>\n${intervals.map((interval) => `${dict(Object.entries(interval).map(([key, value]) => [key, `<integer>${value}</integer>`]), "    ")}\n`).join("")}  </array>`],
+        ["StandardOutPath", string(log)],
+        ["StandardErrorPath", string(log)],
+        ["RunAtLoad", "<false/>"],
+        ["ultimate-brain", string(JSON.stringify(entry))],
+    ], "");
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n${body}\n</plist>\n`;
+}
+function readEntry(text) {
+    const match = /<key>ultimate-brain<\/key>\s*<string>([^<]*)<\/string>/.exec(text);
+    if (match === null)
+        return null;
+    try {
+        return JSON.parse(unxml(match[1]));
+    }
+    catch {
+        return null;
+    }
+}
+const xml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+const unxml = (value) => value.replaceAll("&quot;", '"').replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
+const shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+const unique = (values) => [...new Set(values)];
+const notManaged = () => ({ code: "SCHEDULE_NOT_MANAGED", message: "cron lines are yours: crontab -l" });
+function platformOf(env) {
+    return env.UB_SCHEDULE_PLATFORM ?? process.platform;
+}
+/** With UB_LAUNCH_AGENTS_DIR set (tests), launchctl is never called and no log folder is made. */
+function testing(env) {
+    return env.UB_LAUNCH_AGENTS_DIR !== undefined;
+}
+function home(context) {
+    return context.environment.homeDirectory ?? homedir();
+}
+function agentsDir(context) {
+    const env = context.environment.env ?? process.env;
+    return env.UB_LAUNCH_AGENTS_DIR ?? join(home(context), "Library", "LaunchAgents");
+}
+async function which(name, path) {
+    for (const dir of (path ?? "").split(delimiter).filter(Boolean)) {
+        const candidate = resolve(dir, name);
+        try {
+            await access(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Not here; try the next folder.
+        }
+    }
+    return null;
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function refuseLink(file) {
+    try {
+        if ((await lstat(file)).isSymbolicLink())
+            throw new BrainError("OUTSIDE_ROOT", `${file} is a symbolic link; remove it, then schedule again`);
+    }
+    catch (error) {
+        if (error instanceof BrainError)
+            throw error;
+    }
+}
+async function launchctl(env, args) {
+    await promisify(execFile)((await which("launchctl", env.PATH)) ?? "/bin/launchctl", [...args]);
+}
+/** A schedule writes nothing in the brain (spec/cli.md §5.21): refuse a folder that resolves inside it, links followed. */
+async function refuseInside(root, folder) {
+    const brain = await realpath(root);
+    let existing = resolve(folder);
+    const rest = [];
+    for (;;) {
+        try {
+            existing = await realpath(existing);
+            break;
+        }
+        catch {
+            const parent = dirname(existing);
+            if (parent === existing)
+                break;
+            rest.unshift(basename(existing));
+            existing = parent;
+        }
+    }
+    const target = join(existing, ...rest);
+    const inside = relative(brain, target);
+    if (!isAbsolute(inside) && inside !== ".." && !inside.startsWith(`..${sep}`)) {
+        throw new BrainError("OUTSIDE_ROOT", `${folder} is inside the brain; a schedule writes nothing there`);
+    }
+}

package/dist/commands/status.js

@@ -8,6 +8,7 @@ import { describeErrors, loadSchemas } from "../lib/schemas.js";
 import { isRecord } from "../lib/input.js";
 import { databaseId, modulesOf } from "../lib/modules.js";
 import { expandPath, linkedRepos, workTreeTop } from "../lib/repos.js";
+import { unattendedRuns } from "../lib/runs.js";
 const NOTE_TYPES = ["area", "project", "person", "org", "meeting", "decision", "question", "concept", "source", "view", "goal", "memory", "reference"];
 const PROPOSAL_STATUSES = ["pending", "approved", "edited", "rejected", "applied", "closed"];
 /** `brain status` (spec/cli.md §5.2). */
@@ -64,6 +65,7 @@ export const statusCommand = {
             notion,
             modules: modulesOf(brain.config),
             settings,
+            unattended: await unattendedRuns(brain.root),
             repos,
             index_stale: currentIndex !== index,
             views_stale: viewStale,
@@ -83,8 +85,13 @@ function readNotion(config) {
     return { configured, missing, tasks_database: typeof tasks.database === "string" && tasks.database !== "" };
 }
 function readSettings(config) {
-    const settings = config.settings;
-    return { publish: isRecord(settings) && settings.publish === "auto" ? "auto" : "ask", push: isRecord(settings) && settings.push === "remind" ? "remind" : "auto" };
+    const settings = isRecord(config.settings) ? config.settings : {};
+    const unattended = isRecord(settings.unattended) ? settings.unattended : {};
+    return {
+        publish: settings.publish === "auto" ? "auto" : "ask",
+        push: settings.push === "remind" ? "remind" : "auto",
+        unattended: { max_inputs: typeof unattended.max_inputs === "number" ? unattended.max_inputs : 10 },
+    };
 }
 async function findLastLogLine(root) {
     let entries;

package/dist/commands/sync.js

@@ -10,13 +10,13 @@ export const syncPlanCommand = {
         throw new BrainError("USAGE", "sync plan needs --input"); const workspace = await Workspace.open(brain); const plan = buildPlan(workspace, parseSnapshot(await readJsonInput(input, "sync plan"))); return { data: plan, human: `${plan.create.length} creates, ${plan.updates.length} updates, ${plan.corrections.length} corrections\n` }; },
 };
 export const syncApplyCommand = {
-    name: "sync apply", usage: "brain sync apply --input <plan|-> [--record-only] [--dry-run] [--json]", summary: "Apply a sync plan using atomic per-item writes.", options: { input: "string", "record-only": "boolean", "dry-run": "boolean" }, maxPositionals: 0, needsBrain: true,
+    name: "sync apply", usage: "brain sync apply --input <plan|-> [--record-only] [--skip-conflicted] [--dry-run] [--json]", summary: "Apply a sync plan using atomic per-item writes.", options: { input: "string", "record-only": "boolean", "skip-conflicted": "boolean", "dry-run": "boolean" }, maxPositionals: 0, needsBrain: true,
     async run({ args, brain, now }) { const input = args.options.input; if (input === undefined)
-        throw new BrainError("USAGE", "sync apply needs --input"); const workspace = await Workspace.open(brain); const data = applyPlan(workspace, parsePlan(await readJsonInput(input, "sync apply")), now, args.options["record-only"] === true); const warnings = lintWarnings(workspace.warnings()); const dryRun = args.options["dry-run"] === true; if (!dryRun)
+        throw new BrainError("USAGE", "sync apply needs --input"); const workspace = await Workspace.open(brain); const data = applyPlan(workspace, parsePlan(await readJsonInput(input, "sync apply")), now, args.options["record-only"] === true, args.options["skip-conflicted"] === true); const warnings = lintWarnings(workspace.warnings()); const dryRun = args.options["dry-run"] === true; if (!dryRun)
         await workspace.commit(data.log, now); const { log: _log, ...output } = data; const failed = Number(data.summary.failed ?? 0); return { data: { dry_run: dryRun, ...output }, warnings, exitCode: failed > 0 ? 1 : 0, human: `${failed} failed items\n` }; },
 };
 export const syncRenderCommand = {
-    name: "sync render", usage: "brain sync render (--changed | --ids <id>[,<id>…]) [--plan <plan.json>] [--json]", summary: "Render Notion payloads without writing.", options: { changed: "boolean", ids: "string", plan: "string" }, maxPositionals: 0, needsBrain: true,
+    name: "sync render", usage: "brain sync render (--changed | --ids <id>[,<id>…]) [--plan <plan.json> [--skip-conflicted]] [--json]", summary: "Render Notion payloads without writing.", options: { changed: "boolean", ids: "string", plan: "string", "skip-conflicted": "boolean" }, maxPositionals: 0, needsBrain: true,
     async run({ args, brain, now }) {
         const changed = args.options.changed === true;
         const idsText = args.options.ids;
@@ -30,15 +30,40 @@ export const syncRenderCommand = {
                     throw new BrainError("UNKNOWN_ID", `No note with id ${id}`);
         const held = new Map();
         const planPath = args.options.plan;
-        if (planPath !== undefined)
-            for (const item of parsePlan(await readJsonInput(planPath, "sync render")).conflicts)
+        const skipConflicted = args.options["skip-conflicted"] === true;
+        if (skipConflicted && planPath === undefined)
+            throw new BrainError("USAGE", "--skip-conflicted needs --plan");
+        const plan = planPath === undefined ? undefined : parsePlan(await readJsonInput(planPath, "sync render"));
+        if (plan !== undefined)
+            for (const item of plan.conflicts)
                 if (item.code === "BOTH_CHANGED" && typeof item.brain_id === "string" && typeof item.property === "string") {
                     const set = held.get(item.brain_id) ?? new Set();
                     set.add(item.property);
                     held.set(item.brain_id, set);
                 }
         const data = render(workspace, now, ids, held);
-        return { data: { items: data.items, errors: data.errors }, warnings: data.warnings, exitCode: data.errors.length > 0 ? 1 : 0, human: `${data.items.length} payloads\n` };
+        // --skip-conflicted (cli §5.14.4, 0051): a conflicted row, and a report with a What to fix nobody has read, are held back whole.
+        const withheld = new Map();
+        const conflictedPages = new Set();
+        if (skipConflicted && plan !== undefined) {
+            for (const item of plan.conflicts) {
+                if (typeof item.brain_id === "string")
+                    withheld.set(item.brain_id, "ROW_CONFLICTED");
+                conflictedPages.add(String(item.page_id));
+            }
+            for (const item of plan.report_fixes)
+                if (!withheld.has(item.report))
+                    withheld.set(item.report, "FIX_WAITING");
+        }
+        const skipped = [];
+        const items = data.items.filter((item) => {
+            const reason = withheld.get(item.id) ?? (item.page_id !== null && conflictedPages.has(item.page_id) ? "ROW_CONFLICTED" : undefined);
+            if (reason === undefined)
+                return true;
+            skipped.push({ id: item.id, reason });
+            return false;
+        });
+        return { data: { items, errors: data.errors, skipped }, warnings: data.warnings, exitCode: data.errors.length > 0 ? 1 : 0, human: `${items.length} payloads\n` };
     },
 };
 export const syncTasksCommand = {

package/dist/lib/errors.js

@@ -8,6 +8,8 @@ export const EXIT_CODES = {
     BRAIN_CONFIG_INVALID: 3,
     SCHEMA_VERSION_UNSUPPORTED: 3,
     UNRELEASED_BUILD: 3,
+    CLAUDE_NOT_FOUND: 3,
+    SKILL_MISSING: 3,
     INPUT_UNREADABLE: 4,
     INPUT_INVALID: 4,
     UNKNOWN_ID: 4,

package/dist/lib/lint.js

@@ -304,6 +304,15 @@ function deferredPair(note, other, id) {
     const excluded = (proposal) => list(record(proposal.attributes.decision).exclude).some((entry) => record(entry).note === id);
     return (note.attributes.deferred_from === other.id && excluded(other)) || (other.attributes.deferred_from === note.id && excluded(note));
 }
+/** Every note id a note's frontmatter references, by the fields lint's `missing-ref` checks, plus `relations` targets and `timeline` sources (spec/cli.md §5.14.3). */
+export function referencedIds(attributes) {
+    const values = Object.entries(attributes).filter(([key]) => REFERENCE_KEYS.has(key)).map(([, value]) => value);
+    for (const relation of list(attributes.relations))
+        values.push(record(relation).target);
+    for (const entry of list(attributes.timeline))
+        values.push(record(entry).source);
+    return values.flatMap((value) => collectIds(value));
+}
 function collectIds(value, out = []) {
     if (typeof value === "string") {
         if (ID.test(value))

package/dist/lib/log.js

@@ -28,6 +28,55 @@ export async function appendLog(root, now, entries) {
     await appendFile(target, entries.map((entry) => `${formatLogLine(now, entry)}\n`).join(""));
     return path;
 }
+/** Read one line written by formatLogLine (spec/cli.md §3.9); null for anything else. */
+export function parseLogLine(line) {
+    const head = /^- (\S+) ([a-z][a-z0-9-]*) (\S+) /.exec(line);
+    if (head === null)
+        return null;
+    let position = head[0].length;
+    const title = readQuoted(line, position);
+    if (title === null)
+        return null;
+    position = title.end;
+    const pairs = {};
+    while (position < line.length) {
+        const key = /^ ([^\s=]+)=/.exec(line.slice(position));
+        if (key === null)
+            return null;
+        position += key[0].length;
+        if (line[position] === '"') {
+            const value = readQuoted(line, position);
+            if (value === null)
+                return null;
+            pairs[key[1]] = value.text;
+            position = value.end;
+        }
+        else {
+            const end = line.indexOf(" ", position);
+            pairs[key[1]] = line.slice(position, end === -1 ? line.length : end);
+            position = end === -1 ? line.length : end;
+        }
+    }
+    return { timestamp: head[1], op: head[2], id: head[3], title: title.text, pairs };
+}
+function readQuoted(line, start) {
+    if (line[start] !== '"')
+        return null;
+    let text = "";
+    for (let index = start + 1; index < line.length; index += 1) {
+        const char = line[index];
+        if (char === '"')
+            return { text, end: index + 1 };
+        if (char === "\\") {
+            const next = line[index + 1];
+            text += next === "n" ? "\n" : next === "r" ? "\r" : (next ?? "");
+            index += 1;
+        }
+        else
+            text += char;
+    }
+    return null;
+}
 function quote(value) {
     const escaped = value
         .replaceAll("\\", "\\\\")

package/dist/lib/runs.js

@@ -0,0 +1,70 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parseLogLine } from "./log.js";
+/**
+ * The unattended catch-up runs since the last attended one, read from the log (spec/cli.md §3.9, §5.2; decision 0051).
+ * Counts that repeat from run to run (an input still skipped, a Fix still waiting) come from the latest run only.
+ */
+export async function unattendedRuns(root) {
+    const lines = await catchUpLines(root);
+    const unattended = (line) => line.pairs.mode === "unattended";
+    let lastAttended = -1;
+    lines.forEach((line, index) => { if (!unattended(line))
+        lastAttended = index; });
+    const since = lines.slice(lastAttended + 1);
+    const recent = lines.filter(unattended).slice(-3);
+    const backlog = recent.length === 3 && recent.every((line) => count(line, "left") > 0);
+    if (since.length === 0)
+        return { catch_up: null, backlog };
+    const latest = since.at(-1);
+    const failures = [];
+    for (const line of since) {
+        for (const reason of (line.pairs.failures ?? "").split(";").map((part) => part.trim()).filter(Boolean))
+            if (!failures.includes(reason))
+                failures.push(reason);
+    }
+    return {
+        catch_up: {
+            since: lastAttended === -1 ? null : lines[lastAttended].timestamp,
+            runs: since.length,
+            inputs: since.reduce((sum, line) => sum + count(line, "inputs"), 0),
+            failed: since.reduce((sum, line) => sum + count(line, "failed"), 0),
+            failures,
+            left: count(latest, "left"),
+            skipped: count(latest, "skipped"),
+            waiting: count(latest, "waiting"),
+            last: latest.timestamp,
+        },
+        backlog,
+    };
+}
+function count(line, key) {
+    const value = Number(line.pairs[key]);
+    return Number.isInteger(value) && value >= 0 ? value : 0;
+}
+/** Every `catch-up` line, oldest first, across the month files. An unreadable file is passed over: status is diagnostic. */
+async function catchUpLines(root) {
+    let files;
+    try {
+        files = (await readdir(join(root, "log"))).filter((entry) => /^\d{4}-\d{2}\.md$/.test(entry)).sort();
+    }
+    catch {
+        return [];
+    }
+    const lines = [];
+    for (const file of files) {
+        let text;
+        try {
+            text = await readFile(join(root, "log", file), "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const raw of text.split("\n")) {
+            const line = parseLogLine(raw);
+            if (line !== null && line.op === "catch-up")
+                lines.push(line);
+        }
+    }
+    return lines;
+}

package/dist/lib/sync.js

@@ -7,6 +7,7 @@ import { generateId, TYPE_PREFIX } from "./ids.js";
 import { assertStagedValid, checkNoteInput, stageNotes } from "./note-new.js";
 import { compareCodePoints } from "./notes.js";
 import { splitParts } from "./parts.js";
+import { referencedIds } from "./lint.js";
 import { loadSchemas } from "./schemas.js";
 import { formatDate, formatTimestamp, normalizeTimestamp } from "./time.js";
 import { lineDiff } from "./diff.js";
@@ -368,6 +369,15 @@ function planInbox(workspace, row, out) {
         if (typeof text === "string" && text.trim() !== "" && text !== last?.text)
             out.report_fixes.push({ page_id: row.page_id, report: note.id, text });
     }
+    // An unattended run's Report row has no Brain ID and holds no report (cli §5.14.2, §6.1).
+    if (typeof brainId !== "string" || brainId === "") {
+        const reason = modules.reports ? "NOT_A_REPORT" : "MODULE_OFF";
+        if (property(row.properties, "Refresh asked") === true || property(row.properties, "Refresh") === true)
+            out.ignored.push(ignoredRow(row, reason, "Refresh asked"));
+        const text = property(row.properties, "What to fix");
+        if (typeof text === "string" && text.trim() !== "")
+            out.ignored.push(ignoredRow(row, reason, "What to fix"));
+    }
     if (property(row.properties, "Document asked") !== true)
         return;
     if (!modules.documents) {
@@ -570,17 +580,61 @@ export function parsePlan(input) {
     assertNoProblems(problems);
     return { ...p, document_requests: p.document_requests ?? [], promote_requests: p.promote_requests ?? [], refresh_requests: p.refresh_requests ?? [], report_fixes: p.report_fixes ?? [], as_of: normalizeTimestamp(p.as_of) };
 }
-export function applyPlan(workspace, plan, now, recordOnly) {
+export function applyPlan(workspace, input, now, recordOnly, skipConflicted = false) {
     const create = [];
     const updates = [];
     const dependencyFailures = new Set();
+    // --skip-conflicted (cli §5.14.3, 0051): a row with a conflict is skipped whole, and so is a create that depends on a skipped one.
+    const conflictedIds = new Set(skipConflicted ? input.conflicts.map((item) => item.brain_id).filter((id) => typeof id === "string") : []);
+    const conflictedPages = new Set(skipConflicted ? input.conflicts.map((item) => item.page_id) : []);
+    // The skip closure is computed before any create runs, so a dependent create is skipped whatever its place in the plan.
+    // It is by position in the plan, so a create that names no id of its own (cli §5.5) is covered too; only an id can be referred to.
+    const skippedAt = new Set();
+    if (skipConflicted) {
+        const skippedIds = new Set();
+        const skip = (index) => { skippedAt.add(index); const id = input.create[index].id; if (id !== undefined)
+            skippedIds.add(id); };
+        input.create.forEach((item, index) => { const page = isRecord(item.frontmatter) ? item.frontmatter.notion : undefined; if ((item.id !== undefined && conflictedIds.has(item.id)) || (typeof page === "string" && conflictedPages.has(page)))
+            skip(index); });
+        for (let grew = true; grew;) {
+            grew = false;
+            input.create.forEach((item, index) => { if (!skippedAt.has(index) && relationsOf(item.frontmatter).some((id) => skippedIds.has(id))) {
+                skip(index);
+                grew = true;
+            } });
+        }
+    }
+    const rowSkipped = { result: "skipped", reason: "ROW_CONFLICTED", changed: [] };
+    const plan = { ...input, updates: [], corrections: [], decisions: [] };
+    const skippedUpdates = [];
+    const skippedCorrections = [];
+    const skippedDecisions = [];
+    for (const update of input.updates)
+        if (conflictedIds.has(String(update.id)))
+            skippedUpdates.push({ id: update.id, ...rowSkipped });
+        else
+            plan.updates.push(update);
+    for (const correction of input.corrections)
+        if (conflictedIds.has(correction.target))
+            skippedCorrections.push({ target: correction.target, field: correction.field, ...rowSkipped });
+        else
+            plan.corrections.push(correction);
+    for (const decision of input.decisions)
+        if (conflictedIds.has(decision.proposal))
+            skippedDecisions.push({ proposal: decision.proposal, action: decision.action, ...rowSkipped });
+        else
+            plan.decisions.push(decision);
     for (let index = 0; index < plan.create.length; index += 1) {
         const item = plan.create[index];
         const checkpoint = workspace.checkpoint();
+        if (skippedAt.has(index)) {
+            create.push({ id: item.id, ...rowSkipped });
+            continue;
+        }
         try {
             if (item.id !== undefined && workspace.get(item.id) !== undefined)
                 throw new Error("ID_IN_USE");
-            const depends = references(item.frontmatter).some((id) => dependencyFailures.has(id));
+            const depends = relationsOf(item.frontmatter).some((id) => dependencyFailures.has(id));
             if (depends)
                 throw new Error("DEPENDENCY_FAILED");
             const staged = stageNotes(workspace, [item], () => `/create/${index}`, { now, lifecycle: String(item.lifecycle ?? "draft") });
@@ -640,11 +694,13 @@ export function applyPlan(workspace, plan, now, recordOnly) {
         ...updates.filter((item) => item.result === "applied").map((item) => ({ op: "sync-update", id: String(item.id), title: String(workspace.get(String(item.id))?.attributes.title ?? item.id) })),
         ...(correctionApply?.log ?? []), ...(decisionApply.log ?? []),
     ];
-    return { create, updates, corrections, decisions: decisionResult, document_requests: plan.document_requests, promote_requests: plan.promote_requests, refresh_requests: plan.refresh_requests, report_fixes: plan.report_fixes, conflicts: plan.conflicts, ignored: plan.ignored, summary: summarize([...create, ...updates, ...corrections, ...decisionResult].map((item) => ({ ...item }))), log };
+    updates.push(...skippedUpdates);
+    const correctionsOut = [...corrections, ...skippedCorrections];
+    const decisionsOut = [...decisionResult, ...skippedDecisions];
+    return { create, updates, corrections: correctionsOut, decisions: decisionsOut, document_requests: plan.document_requests, promote_requests: plan.promote_requests, refresh_requests: plan.refresh_requests, report_fixes: plan.report_fixes, conflicts: plan.conflicts, ignored: plan.ignored, summary: summarize([...create, ...updates, ...correctionsOut, ...decisionsOut].map((item) => ({ ...item }))), log };
 }
-function references(value) { if (Array.isArray(value))
-    return value.flatMap(references); if (isRecord(value))
-    return Object.values(value).flatMap(references); return typeof value === "string" && /^(area|gol|prj|per|org|mtg|dec|que|con|ref|src|mem)-/.test(value) ? [value] : []; }
+/** The ids a create references (cli §5.14.3): free text such as a summary never counts. */
+function relationsOf(frontmatter) { return isRecord(frontmatter) ? referencedIds(frontmatter) : []; }
 function summarize(items) { const result = { applied: 0, closed: 0, recorded: 0, corrected: 0, skipped: 0, failed: 0 }; for (const item of items)
     if (typeof item.result === "string" && Object.hasOwn(result, item.result))
         result[item.result] += 1; return result; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultimate-brain",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "CLI for an AI-assisted Markdown and Git second brain",
   "license": "MIT",
   "keywords": [

package/spec/schemas/brain.schema.json

@@ -61,6 +61,19 @@
             "remind"
           ],
           "default": "auto"
+        },
+        "unattended": {
+          "description": "Unattended catch-up (decision 0051, spec/schema.md §12, cli.md §6.1).",
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "max_inputs": {
+              "description": "Inputs one unattended run takes in, oldest first.",
+              "type": "integer",
+              "minimum": 1,
+              "default": 10
+            }
+          }
         }
       }
     },

package/templates/brain/AGENTS.md

@@ -49,7 +49,7 @@ Each operation has a skill; follow it end to end:
 7. **Dated, not "current".** Write facts as timeless, dated ("as of 2026-12-03"), or as pointers ("status: see Notion"). Volatile status (task state, project status, priority) lives in Notion.
 8. **Cite canonical notes.** `index.md` and the views are navigation; cite the note or source they point to.
 9. **Answering is read-only.** Answering the user's questions from the brain writes nothing; save an answer to the brain only when the user asks. A report the user asks for is stored as a dated view in `reports/` and published, never as knowledge: it is never ingested or cited as a source (decision 0043).
-10. **Unattended runs add, never apply.** With no user present, an agent may add drafts and proposals; applying proposals waits for the user.
+10. **Unattended runs add, and apply only what you decided word for word.** With no user present, an agent adds drafts and proposals and carries out decisions you already made (Approve, Reject, your edits in Notion); it never interprets a What to fix, a Fix or an "all except …", and never decides anything itself. Those wait for an attended run.
 
 ## Reading notes