cortex: a run is the human's call, not the human's keystroke

AGENTS.md

@@ -141,7 +141,7 @@ the `/<verb>` slash commands.
 | `workspace` | The voice — the organism's expressive function: plan/survey workspace + HowTo example authorship (workspace\|howto registers) — WorkspaceDecision (never writes) | `bin/pyauto-brain workspace` |
 | `eyes` | The perceptive function — the organism's sense of its own appearance: survey/review a visualization workspace's figure surface, critiques route to intake/start_dev — EyesSurvey/EyesReviewSurface (never renders, never edits) | `bin/pyauto-brain eyes` |
 | `profiling` | The proprioceptive function — the organism's sense of its own effort: campaign/ingest/triage plans over the autolens_profiling workspace — ProfilingDecision | `bin/pyauto-brain profiling` |
-| `cortex` | The learning function — where the organism finds out what is true: the science check-in over PyAutoCortex ('cortex checkin') — pull every active project through its own sync CLI, score every live run against its pre-registered witness, move what came back to awaiting-ruling, re-render the board and summarise it by project; never submits a run, never writes a ruling | `bin/pyauto-brain cortex` |
+| `cortex` | The learning function — where the organism finds out what is true: the science check-in over PyAutoCortex ('cortex checkin') — pull every active project through its own sync CLI, score every live run against its pre-registered witness, move what came back to awaiting-ruling, re-render the board and summarise it by project; its door never submits a run and never writes a ruling; the agent submits only on the human's ask, and the ruling is the human's word | `bin/pyauto-brain cortex` |
 | `hygiene` | The maintenance function — the organism's sense of its own upkeep: code-quality debt (dev-loop cost + tidiness), delegating fixes — HygieneDecision | `bin/pyauto-brain hygiene` |
 | `clone` | The Mitosis Agent: partition the reference assistant, analyze the domain, emit the CloneDecision; --apply --mode lightweight-seed delegates the seed birth to Build; 'clone sync' patches the reference's generic-file diff onto the born siblings (dry run by default; rejected hunks are a human decision) | `bin/pyauto-brain clone` |
 | `build` | Coordinate execution: consult the vitals faculty, then delegate to PyAutoHands | `bin/pyauto-brain build` |

AUTONOMY.md

@@ -407,9 +407,10 @@ for a science one (`batch plan --kind cortex` writes it). The two surfaces hold
 separate records with separate `review-at:`s, so a member that read the other
 organ's would be reading another shift's grant. The "no record → solo `--auto`"
 rule above is unchanged for dev members and **inapplicable to a cortex member**:
-a science member is never `--auto` — the human submits the run and rules on it,
-so there is no autonomous acknowledgement for a grant to license. A Cortex record
-therefore carries no `heart-ack:` and no `expected-effects:` at all (the Cortex's
+a science member is never `--auto` — a run is submitted only on the human's
+ask and the human rules on it, so there is no autonomous acknowledgement for a
+grant to license. A Cortex record therefore carries no `heart-ack:` and no
+`expected-effects:` at all (the Cortex's
 own `batches/AGENTS.md` drops both: the Heart gates releases, not runs), and
 **their absence there is never read as an unacknowledged RED** — the fields are
 not missing, they do not exist on that schema.

agents/conductors/cortex/AGENTS.md

@@ -6,9 +6,10 @@
 > of record) and answers one question — *where is my science?* — with one
 > command, `checkin`: pull every active project, score every live run, move
 > what came back, re-render the board, push the ledger, summarise by project.
-> It **never submits a run and never writes a ruling**: the run is the human's
-> act, the verdict is the human's word, and the ruling file is the Cortex
-> script's to write.
+> Its door **never submits a run and never writes a ruling**: a run is
+> submitted only on the human's ask (by the human, or by the agent in the
+> session through the project's own sync CLI), the verdict is the human's
+> word, and the ruling file is the Cortex script's to write.
 
 The same split the organism already uses twice — **Heart ↔ vitals**, **Gut ↔
 hygiene**: the organ keeps the state, the conductor reasons over it. The

agents/conductors/cortex/_cortex.py

@@ -6,9 +6,10 @@
 The Cortex holds the state — science phases, their pre-registered witnesses,
 their runs and the rulings of record; this conductor holds the reasoning: it
 renders the Cortex board, grades the gates, admits ready phases into a laptop
-slot and scores what a pull brought back into a packet member. It **never
-submits** and never edits a ruling: the run is the human's act, the verdict is
-theirs, and the `Ruling` line this verb emits is left blank for them.
+slot and scores what a pull brought back into a packet member. Its verbs
+**never submit** and never edit a ruling: a run is submitted only on the
+human's ask (through the project's own sync CLI), the verdict is theirs, and
+the `Ruling` line this verb emits is left blank for them.
 
 The same split as Heart ↔ vitals and Gut ↔ hygiene — the organ keeps the
 state, the conductor reasons over it.
@@ -525,7 +526,7 @@ def _src_url(blob: str, src: str) -> str:
 
 # ------------------------------------------------------------- the payloads ---
 # Every row hands the reader the next command rather than a decision. The
-# science verbs stay the Cortex script's and the run stays the human's.
+# science verbs stay the Cortex script's and a run is only ever the human's ask.
 def _checkin_payload(c: dict) -> str:
     """The paste for the laptop's science chat — the whole door as one
     sentence, naming the stamp it is refreshing *from* so "since last time"
@@ -584,8 +585,8 @@ def _live_payload(r: dict, projects: dict) -> str:
 
 
 def _submit_line(project: str, projects: dict) -> str:
-    """The project's own submit verb, as a human would type it — or the note
-    that says the row has no such verb. Every path comes from the row."""
+    """The project's own submit verb, as it would be typed at the laptop — or
+    the note that says the row has no such verb. Every path comes from the row."""
     row = projects.get(project, {})
     cli, path = (row.get("sync_cli") or ""), (row.get("local_path") or "")
     if cli and path and "submit" in (row.get("sync_verbs") or []):
@@ -597,7 +598,8 @@ def _submit_line(project: str, projects: dict) -> str:
 def launch_payload(r: dict, projects: dict) -> list[str]:
     """The launch lines for a ready phase: the phase, the project's own
     submit verb, and the move that records the job id. No decision rides
-    here — everything decided was decided when the plan was approved."""
+    here — everything decided was decided when the plan was approved; the
+    agent may run these lines itself when the human says go."""
     return [r["rel"], _submit_line(r["project"], projects),
             f"python3 scripts/cortex.py move {r['rel']} submitted "
             "--run <jobid>"]
@@ -2690,8 +2692,9 @@ def build_parser() -> argparse.ArgumentParser:
     ap = argparse.ArgumentParser(
         prog="cortex",
         description="The Cortex Agent — reason over PyAutoCortex: the board, "
-                    "the gates, the check-in. It never submits and never "
-                    "rules.")
+                    "the gates, the check-in. Its verbs never submit and "
+                    "never rule; a run is submitted only on the human's "
+                    "ask.")
     sub = ap.add_subparsers(dest="verb")
 
     def common(p):

agents/conductors/cortex/cortex.sh

@@ -6,9 +6,9 @@
 # Reasons over PyAutoCortex, the organ that holds the science body map, the
 # pre-registered phases and the rulings of record: renders the Cortex board
 # (dashboard.md + dashboard.html, published to Pages), lists what each gated
-# phase is waiting on, and scores what a pull brought back. It never submits a
-# run and never writes a ruling — the run is the human's act and the verdict
-# is theirs.
+# phase is waiting on, and scores what a pull brought back. Its verbs never
+# submit a run and never write a ruling — a run is submitted only on the
+# human's ask, and the verdict is theirs.
 #
 # Usage:
 #   cortex.sh                          # census (default)

skills/COMMANDS.md

@@ -37,7 +37,7 @@ readiness gate, or execution — those belong to the organs.
 | `/workspace` | Workspace Agent | `bin/pyauto-brain workspace` → WorkspaceDecision (plan/survey example authorship) → `start_dev` → `start_workspace` → `ship_workspace` |
 | `/eyes` | Eyes Agent | `bin/pyauto-brain eyes` → survey/review a visualization workspace's figures; render via its `gallery_run.sh`; accepted critiques → `/intake` → `start_dev` |
 | `/profiling` | Profiling Agent | `bin/pyauto-brain profiling` → campaign/ingest/triage plans over the autolens_profiling workspace |
-| `/cortex` | Cortex Agent | `bin/pyauto-brain cortex checkin` → the science check-in over PyAutoCortex: pull every active project, score every live run, move what came back, re-render the board and summarise it by project (`census`/`dashboard`/`gates`/`collect` are the verbs it composes); the run and the ruling stay the human's |
+| `/cortex` | Cortex Agent | `bin/pyauto-brain cortex checkin` → the science check-in over PyAutoCortex: pull every active project, score every live run, move what came back, re-render the board and summarise it by project (`census`/`dashboard`/`gates`/`collect` are the verbs it composes); a run is submitted only on the human's ask; the ruling stays the human's |
 | `/hygiene` | Hygiene Agent | `bin/pyauto-brain hygiene` → perf/tidy/noise/deps/docs/docstrings upkeep plans; delegates fixes to refactor/bug/feature |
 | `/build` | Build Agent | `bin/pyauto-brain build` → vitals faculty → Heart → PyAutoHands |
 | `/health` | Health Agent | `bin/pyauto-brain health` loop → vitals faculty → Heart → GREEN |

skills/cortex/SKILL.md

@@ -6,6 +6,8 @@ description: Check in on the science — run the PyAutoBrain Cortex Agent's one
 # Cortex
 
 Follow [`cortex.md`](cortex.md) exactly: it is the check-in sequence, and the
-individual verbs are its appendix. The conductor reasons; it never submits a
-run and never writes a ruling — the submission and the verdict stay the
-human's.
+individual verbs are its appendix. The conductor reasons; its check-in door
+never submits a run and never writes a ruling. A run is submitted only when the
+human asks for it in the session — then the agent runs the project's own sync
+CLI and records the job id with `cortex.py move`. The verdict stays the
+human's word.

skills/cortex/cortex.md

@@ -64,13 +64,13 @@ then offer the prompts:
   the ruling for approval, then `cortex.py rule`).
 - **still out there** → the project's own `jobs` line.
 - **ready** → the launch lines (the phase, the `submit`, the `move … submitted
-  --run <jobid>`).
+  --run <jobid>`). Run them yourself when the human says go.
 - **gated** → the refs to open.
 
-Never decide a ruling, never submit a job, never edit a phase file by hand:
-every phase edit is `python3 scripts/cortex.py move`, every verdict is
-`python3 scripts/cortex.py rule`, both in the PyAutoCortex checkout, and the
-ruling body is the human's words verbatim.
+Never decide a ruling, never submit a job the human did not ask for, never edit
+a phase file by hand: every phase edit is `python3 scripts/cortex.py move`,
+every verdict is `python3 scripts/cortex.py rule`, both in the PyAutoCortex
+checkout, and the ruling body is the human's words verbatim.
 
 ## The push rule
 
@@ -93,8 +93,13 @@ and nothing for the human to merge. **Never `main` directly, never `--force`.**
 
 ## The rules that do not bend
 
-- **The conductor never submits.** The human runs the project's own sync CLI
-  and records the job id with `cortex.py move <phase> submitted --run <jobid>`.
+- **A run is the human's call, not the human's keystroke.** The check-in door
+  never submits. When the human asks for a run in the session, the agent
+  submits it with the project's own sync CLI (its `submit` / `push-submit`
+  verb) and records the job id at once with `cortex.py move <phase> submitted
+  --run <jobid>`. Nothing is submitted unasked, and a run that has no phase
+  gets one before the session ends. (Changed 2026-09-05 by the human's ruling;
+  before that the human typed the submit.)
 - **A verdict recorded only outside the Cortex does not exist.** A decision
   reached in chat is not a ruling until `cortex.py rule` has written it.
 - **A phase is a question with a pre-registered witness.** If `Witness:` is