From a879474a7ab1062f3ae6220847db40c72439edab Mon Sep 17 00:00:00 2001
From: M Waleed Kadous <waleedk@gmail.com>
Date: Sun, 18 Oct 2026 16:05:07 -0700
Subject: [PATCH 1/8] chore(porch): 1826 init air

---
 .../status.yaml                                    | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml

diff --git a/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml b/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
new file mode 100644
index 000000000..af58bb4e2
--- /dev/null
+++ b/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
@@ -0,0 +1,14 @@
+id: '1826'
+title: skeleton-ship-the-owner-decisi
+protocol: air
+phase: implement
+plan_phases: []
+current_plan_phase: null
+gates:
+  pr:
+    status: pending
+iteration: 1
+build_complete: false
+history: []
+started_at: '2026-10-18T23:05:06.935Z'
+updated_at: '2026-10-18T23:05:06.936Z'

From f4c854e420a0f0fd80b8991eededdf06d094c9e2 Mon Sep 17 00:00:00 2001
From: M Waleed Kadous <waleedk@gmail.com>
Date: Sun, 18 Oct 2026 16:12:07 -0700
Subject: [PATCH 2/8] [Air #1826] feat: Ship the owner decisions process with
 the Decisions tab

Add resources/decision-protocol.md to both trees: the intake message, the item
format the Decisions tab parses (bare words described from **Options:**, stamps
that carry their own zone), what the hub does, and the file skeleton. Link it
from the Decisions tab section of agent-farm.md and from the architect role.
A test runs the doc's own examples through the tab's parser, splice and notice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../resources/commands/agent-farm.md          |   2 +
 codev-skeleton/resources/decision-protocol.md | 178 ++++++++++++++++++
 codev-skeleton/roles/architect.md             |   9 +
 codev/resources/commands/agent-farm.md        |   2 +
 codev/resources/decision-protocol.md          | 178 ++++++++++++++++++
 codev/roles/architect.md                      |   9 +
 codev/state/air-1826_thread.md                |  27 +++
 .../__tests__/decision-protocol-doc.test.ts   | 155 +++++++++++++++
 8 files changed, 560 insertions(+)
 create mode 100644 codev-skeleton/resources/decision-protocol.md
 create mode 100644 codev/resources/decision-protocol.md
 create mode 100644 codev/state/air-1826_thread.md
 create mode 100644 packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts

diff --git a/codev-skeleton/resources/commands/agent-farm.md b/codev-skeleton/resources/commands/agent-farm.md
index 553200f4a..f42808ba9 100644
--- a/codev-skeleton/resources/commands/agent-farm.md
+++ b/codev-skeleton/resources/commands/agent-farm.md
@@ -936,6 +936,8 @@ Both are Tower-global (they apply to the whole Tower, not per-project) and optio
 
 When a workspace has a pending-decisions file, the dashboard shows a **Decisions** tab (Spec 1819). The tab is a view of that file. Each item under `## Open` becomes a card with a click box per option (the first option, the recommended one, is marked) and a comment box. Submitting writes the chosen word, then the comment, on the lines right after the item's `**Your word:**` line, exactly as the owner would type them, and changes nothing else. `## Ruled` is shown below as a collapsed, read-only list. The file is the only state. While the tab is open it re-reads the file every 2 seconds, so edits made elsewhere appear without a reload, and an unsent draft survives them.
 
+The file's format and the process around it are in [`decision-protocol.md`](../decision-protocol.md): one hub architect, `main`, is the only agent that edits the file, other architects send it their items, and the hub relays each ruling. The tab reads exactly the item format that document describes.
+
 The file is `codev/state/pending-decisions.md` unless `dashboard.decisionsFile` names another:
 
 ```json
diff --git a/codev-skeleton/resources/decision-protocol.md b/codev-skeleton/resources/decision-protocol.md
new file mode 100644
index 000000000..01b21840d
--- /dev/null
+++ b/codev-skeleton/resources/decision-protocol.md
@@ -0,0 +1,178 @@
+# Owner decisions: one file, one hub
+
+How a workspace's owner and its architects make decisions through one markdown file,
+`codev/state/pending-decisions.md`. The dashboard's **Decisions** tab is a view of that file:
+see the Decisions tab section of [`commands/agent-farm.md`](commands/agent-farm.md). This is a
+working agreement between people and agents, not a porch protocol; nothing is spawned from it.
+
+- **The owner** is the human whose word clears a gate, a merge, a spend or a product choice.
+- **The hub** is one architect, named `main`. It is the only agent that edits the file.
+- **Every other architect** sends its asks to the hub and acts on the ruling the hub relays.
+
+Anything that needs the owner's word goes through the file, one item per question. Status
+reports and FYIs do not.
+
+## 1. The intake message (architect → hub)
+
+An architect sends the item as one message:
+
+```bash
+afx send architect:main 'DECISION <name>-<n>: <question>
+<the item, exactly as it should appear>'
+```
+
+The first line is `DECISION <name>-<n>: <question>`; append ` [urgent]` only when a live user
+or running work is blocked. Single-quote the message, because inside double quotes the shell
+runs the item's backticks; write an apostrophe inside it as `'\''`. Ids are
+`<architect name>-<running number>` (`web-4`, `main-12`): each architect keeps its own counter
+and never reuses a number.
+
+## 2. The item
+
+```markdown
+### <name>-<n> · <YYYY-MM-DD h:mm am/pm ZONE> · <The question the owner answers, naming the thing by what it does>
+
+- **Problem:** (or **Context:**) what is wrong or undecided, as the owner would see it. One to three sentences.
+- **Root cause:** why, for a fix.
+- **Options:** for a choice, (a) `<word>` = what it does (b) `<word>` = what it does.
+- **Fix:** what the change does, in product terms.
+- **Testing:** the receipt: tests before and after, a live check, checks green on the exact head.
+- **Cost:** money or time, only when a budget is involved.
+- **Recommendation (<name>):** one line, owned by the architect.
+- **Links:** pull request and issue URLs; spec, plan and receipt paths.
+
+**Your word:** `<first word, recommended>` / `<second word>` / `hold`
+```
+
+Delete labels that do not apply; never rename them. The hub bounces a malformed item back,
+naming what is missing, and does not post it.
+
+### What the tab reads
+
+The Decisions tab parses the file by these rules. An item that follows them gets a click box
+per option and a comment box.
+
+- **Items are the `###` headings under `## Open`.** An item runs to the next `#`, `##` or `###`
+  heading, so inside an item use `####` or bold labels, never a higher heading. The file has
+  exactly one `## Open`.
+- **The heading is id · stamp · question.** The first word is the id; ` · ` (space, middle dot,
+  space) separates the id, the stamp and the question. Open items that share an id are
+  read-only until the ids differ.
+- **The stamp carries its zone; nothing assumes one.** `YYYY-MM-DD h:mm am` (or `pm`), or 24-hour
+  `YYYY-MM-DD HH:mm`, then the zone the time was read in. The tab converts the stamp using only
+  that zone and shows it in the viewer's local time. It reads the North-American generic zones
+  `PT`, `MT`, `CT`, `ET`, `AKT` and `HT` (daylight saving follows the stamp's date), fixed
+  abbreviations such as `UTC`, `GMT`, `EST`/`EDT`, `CET`/`CEST`, `JST` and `AEST`/`AEDT` (`CST`
+  is North-American Central), offsets such as `+05:30`, `UTC+5:30` or `GMT-3`, and IANA names
+  such as `Europe/Berlin`. Any other zone, including ambiguous abbreviations such as `IST`,
+  `BST` and `AST`, is shown as written and marked not converted, as is a time the clocks
+  skipped or repeated that day.
+- **Exactly one `**Your word:**` line**, starting a line, outside a code block. The options are
+  the backticked words on it, separated by ` / `. The first is the recommended one, and the tab
+  marks it. A description follows a word after ` = ` and runs to the next ` / ` before a
+  backtick: `` `retry` = keep the page / `signout` = sign out / `hold` ``. Other text on the
+  line is ignored.
+- **A bare word takes its description from `**Options:**`.** A word written without ` = …` on
+  the word line is described by the body's `**Options:**` entry for the same word: ``(a) `word` = …``
+  or ``(a) `word`: …`` after the label, or ``- `word` = …`` list items under it. A
+  description on the word line wins; a word with neither (`hold`) shows bare.
+- **Questions and answers** are body lines above the word line, `- **You asked (<time>):** …`
+  and `- **<Name>'s answer (<time>):** …`, continued on lines indented two spaces. The tab shows
+  them on the card as a thread (section 3c).
+- **Whatever follows the `**Your word:**` line is the ruling.** While nothing follows it, the
+  card takes a submit, which writes the chosen word on the next line and then the comment after
+  a blank line, exactly as the owner would type them. Once any text follows the line, typed by
+  hand or written by the tab, the card shows it as the current ruling and takes no new submit.
+- **`## Ruled`** is shown read-only, as written.
+
+A worked example, a choice with bare words on the word line:
+
+```markdown
+### web-4 · 2026-10-17 9:40 pm ET · When a session expires mid-edit, should the login fix keep the page or sign the user out?
+
+- **Context:** users whose session expires while they edit lose their draft when the page reloads.
+- **Options:** (a) `retry` = refresh the sign-in in the background and keep the page (b) `signout` = sign the user out and keep the draft on this device
+- **Testing:** unit tests cover both paths; a live check with a forced expiry kept the draft.
+- **Recommendation (web):** `retry`, the smaller change for the user.
+- **Links:** https://github.com/example/app/pull/412 (the login fix), `codev/specs/412-session-expiry.md`
+
+**Your word:** `retry` / `signout` / `hold`
+```
+
+## 3. What the hub does
+
+1. **Post.** The hub puts the item at the top of `## Open`, updates the status line
+   (`N open — <ids>`), and tells the owner in one chat line:
+   `New decision from <name>: <id> — <question>`, plus `[urgent]` if marked.
+2. **Learn of rulings.** The owner rules in the tab, by typing in the file, or in chat. A ruling
+   made in the tab reaches the hub as a message from Tower: `RULED <id>: <word>`, or
+   `QUESTION <id>:` when no word was chosen, with the comment on the lines after it. A ruling
+   typed into the file reaches the hub when the owner says so in chat (a short agreed word,
+   such as `ddu` for "decisions doc updated") or when the hub's own watch on the file sees the
+   change. Either way the hub scans every open item for text after its `**Your word:**` line
+   and replies with one line per ruling found. A word in chat counts the same.
+3. **Relay and record.** For each ruling the hub relays at once,
+   `afx send architect:<name> 'RULING <id>: <word> (owner, <time> <zone>)'`, and moves the
+   item out of `## Open` into `## Ruled` as one line:
+   ``- **<id>** · <time> <zone> · <question> → `<word>` → <what happened>``.
+   A ruling that carries a question goes through 3b first.
+4. **Done.** The architect acts and replies `DONE <id>: <one line of what happened>`; the hub
+   appends it to the item's line in `## Ruled`.
+5. If the owner rules in chat to another architect directly, that architect sends the hub
+   `RULED <id>: <word> (owner, <time> <zone>, in chat)`, and the hub records it the same way.
+6. The hub's own asks use the same format, under `main-<n>`.
+
+The hub writes the file as little as possible: one write per scan, recording every ruling
+found, and new items in batches. It re-reads the file immediately before each write. Every
+time it writes carries its zone, read from the clock (`date`).
+
+### 3b. A ruling that carries a question comes back as an item
+
+When the owner's word carries a question or a choice ("retry, but could this sign people out
+twice?"), the hub does not answer it in the relay and move on. It posts a new item with the
+options and its recommendation before directing anyone, unless the answer is a plain fact with
+no design behind it. The same holds for a gap the hub finds after a ruling (a receipt that did
+not cover what was ruled on, a step the ruling implied but did not say): it goes into the file,
+as an item or as a line under the ruled item, not into chat alone. Chat tells the owner the
+file changed; the file is where the decision lives.
+
+### 3c. The owner's question gets the architect's answer, in the item
+
+When the owner writes a question instead of a word (in the tab's comment box, under the word
+line, or in chat), the hub, in order:
+
+1. Relays it verbatim to the owning architect:
+   `afx send architect:<name> '<id>: no word yet. The owner asks: "<question>". Answer in one short plain-words message.'`
+2. Pastes the answer into the item, above the `**Your word:**` line, as two labelled lines,
+   adding its own check where it can make one:
+
+   ```markdown
+   - **You asked (10:05 pm ET):** "Could retry hide a real sign-out from the user?"
+   - **Web's answer (10:12 pm ET):** No. A refresh that fails still signs the user out and says why.
+     Main checked the test that forces a failed refresh: it signs out and shows the message.
+   ```
+
+3. Lifts the question out from under the word line, so that nothing follows the
+   `**Your word:**` line. The scan no longer reads the question as a ruling, and the tab takes
+   a submit again. The item stays open, and the owner rules after reading the answer. If the
+   answer changes the choice, the hub updates the options.
+
+A second question gets a second pair of lines under the first.
+
+## 4. The file
+
+```markdown
+# Pending owner decisions — all architects (hub: main)
+
+Rule inline: one word on an item's **Your word:** line, or in the Decisions tab.
+Newest first. Only main edits this file; architects send items with `afx send architect:main 'DECISION …'`.
+
+_Status: 0 open._
+
+## Open
+
+## Ruled
+```
+
+Newest first in both sections. `## Open` holds only what still needs a word; `## Ruled` keeps
+one line per item.
diff --git a/codev-skeleton/roles/architect.md b/codev-skeleton/roles/architect.md
index 41dc0d17f..6668c3191 100644
--- a/codev-skeleton/roles/architect.md
+++ b/codev-skeleton/roles/architect.md
@@ -67,6 +67,15 @@ dev-approval — lead with **Problem · Root Cause · Fix · Testing**, unprompt
 tier. Verify the root cause yourself: a builder's summary is evidence, not ground truth. The
 human should be able to answer from your message without opening the diff.
 
+### The owner decisions file
+
+A workspace may route every ask for the human's word through one file,
+`codev/state/pending-decisions.md`, shown in the dashboard as the **Decisions** tab. One
+architect, named `main`, is the hub and the only agent that edits it. Other architects send it
+items with `afx send architect:main 'DECISION <id>: <question> …'`, and a ruling made in the
+tab reaches `main` as a `RULED <id>: <word>` message. The item format the tab reads, and what
+the hub does with each ruling and question, are in `codev/resources/decision-protocol.md`.
+
 ## UX verification
 
 Before approving anything with UX requirements, exercise the actual user path. A spec that says
diff --git a/codev/resources/commands/agent-farm.md b/codev/resources/commands/agent-farm.md
index ae95c0b36..d9ab097a3 100644
--- a/codev/resources/commands/agent-farm.md
+++ b/codev/resources/commands/agent-farm.md
@@ -1166,6 +1166,8 @@ Both are Tower-global (they apply to the whole Tower, not per-project) and optio
 
 When a workspace has a pending-decisions file, the dashboard shows a **Decisions** tab (Spec 1819). The tab is a view of that file. Each item under `## Open` becomes a card with a click box per option (the first option, the recommended one, is marked) and a comment box. Submitting writes the chosen word, then the comment, on the lines right after the item's `**Your word:**` line, exactly as the owner would type them, and changes nothing else. `## Ruled` is shown below as a collapsed, read-only list. The file is the only state. While the tab is open it re-reads the file every 2 seconds, so edits made elsewhere appear without a reload, and an unsent draft survives them.
 
+The file's format and the process around it are in [`decision-protocol.md`](../decision-protocol.md): one hub architect, `main`, is the only agent that edits the file, other architects send it their items, and the hub relays each ruling. The tab reads exactly the item format that document describes.
+
 The file is `codev/state/pending-decisions.md` unless `dashboard.decisionsFile` names another:
 
 ```json
diff --git a/codev/resources/decision-protocol.md b/codev/resources/decision-protocol.md
new file mode 100644
index 000000000..01b21840d
--- /dev/null
+++ b/codev/resources/decision-protocol.md
@@ -0,0 +1,178 @@
+# Owner decisions: one file, one hub
+
+How a workspace's owner and its architects make decisions through one markdown file,
+`codev/state/pending-decisions.md`. The dashboard's **Decisions** tab is a view of that file:
+see the Decisions tab section of [`commands/agent-farm.md`](commands/agent-farm.md). This is a
+working agreement between people and agents, not a porch protocol; nothing is spawned from it.
+
+- **The owner** is the human whose word clears a gate, a merge, a spend or a product choice.
+- **The hub** is one architect, named `main`. It is the only agent that edits the file.
+- **Every other architect** sends its asks to the hub and acts on the ruling the hub relays.
+
+Anything that needs the owner's word goes through the file, one item per question. Status
+reports and FYIs do not.
+
+## 1. The intake message (architect → hub)
+
+An architect sends the item as one message:
+
+```bash
+afx send architect:main 'DECISION <name>-<n>: <question>
+<the item, exactly as it should appear>'
+```
+
+The first line is `DECISION <name>-<n>: <question>`; append ` [urgent]` only when a live user
+or running work is blocked. Single-quote the message, because inside double quotes the shell
+runs the item's backticks; write an apostrophe inside it as `'\''`. Ids are
+`<architect name>-<running number>` (`web-4`, `main-12`): each architect keeps its own counter
+and never reuses a number.
+
+## 2. The item
+
+```markdown
+### <name>-<n> · <YYYY-MM-DD h:mm am/pm ZONE> · <The question the owner answers, naming the thing by what it does>
+
+- **Problem:** (or **Context:**) what is wrong or undecided, as the owner would see it. One to three sentences.
+- **Root cause:** why, for a fix.
+- **Options:** for a choice, (a) `<word>` = what it does (b) `<word>` = what it does.
+- **Fix:** what the change does, in product terms.
+- **Testing:** the receipt: tests before and after, a live check, checks green on the exact head.
+- **Cost:** money or time, only when a budget is involved.
+- **Recommendation (<name>):** one line, owned by the architect.
+- **Links:** pull request and issue URLs; spec, plan and receipt paths.
+
+**Your word:** `<first word, recommended>` / `<second word>` / `hold`
+```
+
+Delete labels that do not apply; never rename them. The hub bounces a malformed item back,
+naming what is missing, and does not post it.
+
+### What the tab reads
+
+The Decisions tab parses the file by these rules. An item that follows them gets a click box
+per option and a comment box.
+
+- **Items are the `###` headings under `## Open`.** An item runs to the next `#`, `##` or `###`
+  heading, so inside an item use `####` or bold labels, never a higher heading. The file has
+  exactly one `## Open`.
+- **The heading is id · stamp · question.** The first word is the id; ` · ` (space, middle dot,
+  space) separates the id, the stamp and the question. Open items that share an id are
+  read-only until the ids differ.
+- **The stamp carries its zone; nothing assumes one.** `YYYY-MM-DD h:mm am` (or `pm`), or 24-hour
+  `YYYY-MM-DD HH:mm`, then the zone the time was read in. The tab converts the stamp using only
+  that zone and shows it in the viewer's local time. It reads the North-American generic zones
+  `PT`, `MT`, `CT`, `ET`, `AKT` and `HT` (daylight saving follows the stamp's date), fixed
+  abbreviations such as `UTC`, `GMT`, `EST`/`EDT`, `CET`/`CEST`, `JST` and `AEST`/`AEDT` (`CST`
+  is North-American Central), offsets such as `+05:30`, `UTC+5:30` or `GMT-3`, and IANA names
+  such as `Europe/Berlin`. Any other zone, including ambiguous abbreviations such as `IST`,
+  `BST` and `AST`, is shown as written and marked not converted, as is a time the clocks
+  skipped or repeated that day.
+- **Exactly one `**Your word:**` line**, starting a line, outside a code block. The options are
+  the backticked words on it, separated by ` / `. The first is the recommended one, and the tab
+  marks it. A description follows a word after ` = ` and runs to the next ` / ` before a
+  backtick: `` `retry` = keep the page / `signout` = sign out / `hold` ``. Other text on the
+  line is ignored.
+- **A bare word takes its description from `**Options:**`.** A word written without ` = …` on
+  the word line is described by the body's `**Options:**` entry for the same word: ``(a) `word` = …``
+  or ``(a) `word`: …`` after the label, or ``- `word` = …`` list items under it. A
+  description on the word line wins; a word with neither (`hold`) shows bare.
+- **Questions and answers** are body lines above the word line, `- **You asked (<time>):** …`
+  and `- **<Name>'s answer (<time>):** …`, continued on lines indented two spaces. The tab shows
+  them on the card as a thread (section 3c).
+- **Whatever follows the `**Your word:**` line is the ruling.** While nothing follows it, the
+  card takes a submit, which writes the chosen word on the next line and then the comment after
+  a blank line, exactly as the owner would type them. Once any text follows the line, typed by
+  hand or written by the tab, the card shows it as the current ruling and takes no new submit.
+- **`## Ruled`** is shown read-only, as written.
+
+A worked example, a choice with bare words on the word line:
+
+```markdown
+### web-4 · 2026-10-17 9:40 pm ET · When a session expires mid-edit, should the login fix keep the page or sign the user out?
+
+- **Context:** users whose session expires while they edit lose their draft when the page reloads.
+- **Options:** (a) `retry` = refresh the sign-in in the background and keep the page (b) `signout` = sign the user out and keep the draft on this device
+- **Testing:** unit tests cover both paths; a live check with a forced expiry kept the draft.
+- **Recommendation (web):** `retry`, the smaller change for the user.
+- **Links:** https://github.com/example/app/pull/412 (the login fix), `codev/specs/412-session-expiry.md`
+
+**Your word:** `retry` / `signout` / `hold`
+```
+
+## 3. What the hub does
+
+1. **Post.** The hub puts the item at the top of `## Open`, updates the status line
+   (`N open — <ids>`), and tells the owner in one chat line:
+   `New decision from <name>: <id> — <question>`, plus `[urgent]` if marked.
+2. **Learn of rulings.** The owner rules in the tab, by typing in the file, or in chat. A ruling
+   made in the tab reaches the hub as a message from Tower: `RULED <id>: <word>`, or
+   `QUESTION <id>:` when no word was chosen, with the comment on the lines after it. A ruling
+   typed into the file reaches the hub when the owner says so in chat (a short agreed word,
+   such as `ddu` for "decisions doc updated") or when the hub's own watch on the file sees the
+   change. Either way the hub scans every open item for text after its `**Your word:**` line
+   and replies with one line per ruling found. A word in chat counts the same.
+3. **Relay and record.** For each ruling the hub relays at once,
+   `afx send architect:<name> 'RULING <id>: <word> (owner, <time> <zone>)'`, and moves the
+   item out of `## Open` into `## Ruled` as one line:
+   ``- **<id>** · <time> <zone> · <question> → `<word>` → <what happened>``.
+   A ruling that carries a question goes through 3b first.
+4. **Done.** The architect acts and replies `DONE <id>: <one line of what happened>`; the hub
+   appends it to the item's line in `## Ruled`.
+5. If the owner rules in chat to another architect directly, that architect sends the hub
+   `RULED <id>: <word> (owner, <time> <zone>, in chat)`, and the hub records it the same way.
+6. The hub's own asks use the same format, under `main-<n>`.
+
+The hub writes the file as little as possible: one write per scan, recording every ruling
+found, and new items in batches. It re-reads the file immediately before each write. Every
+time it writes carries its zone, read from the clock (`date`).
+
+### 3b. A ruling that carries a question comes back as an item
+
+When the owner's word carries a question or a choice ("retry, but could this sign people out
+twice?"), the hub does not answer it in the relay and move on. It posts a new item with the
+options and its recommendation before directing anyone, unless the answer is a plain fact with
+no design behind it. The same holds for a gap the hub finds after a ruling (a receipt that did
+not cover what was ruled on, a step the ruling implied but did not say): it goes into the file,
+as an item or as a line under the ruled item, not into chat alone. Chat tells the owner the
+file changed; the file is where the decision lives.
+
+### 3c. The owner's question gets the architect's answer, in the item
+
+When the owner writes a question instead of a word (in the tab's comment box, under the word
+line, or in chat), the hub, in order:
+
+1. Relays it verbatim to the owning architect:
+   `afx send architect:<name> '<id>: no word yet. The owner asks: "<question>". Answer in one short plain-words message.'`
+2. Pastes the answer into the item, above the `**Your word:**` line, as two labelled lines,
+   adding its own check where it can make one:
+
+   ```markdown
+   - **You asked (10:05 pm ET):** "Could retry hide a real sign-out from the user?"
+   - **Web's answer (10:12 pm ET):** No. A refresh that fails still signs the user out and says why.
+     Main checked the test that forces a failed refresh: it signs out and shows the message.
+   ```
+
+3. Lifts the question out from under the word line, so that nothing follows the
+   `**Your word:**` line. The scan no longer reads the question as a ruling, and the tab takes
+   a submit again. The item stays open, and the owner rules after reading the answer. If the
+   answer changes the choice, the hub updates the options.
+
+A second question gets a second pair of lines under the first.
+
+## 4. The file
+
+```markdown
+# Pending owner decisions — all architects (hub: main)
+
+Rule inline: one word on an item's **Your word:** line, or in the Decisions tab.
+Newest first. Only main edits this file; architects send items with `afx send architect:main 'DECISION …'`.
+
+_Status: 0 open._
+
+## Open
+
+## Ruled
+```
+
+Newest first in both sections. `## Open` holds only what still needs a word; `## Ruled` keeps
+one line per item.
diff --git a/codev/roles/architect.md b/codev/roles/architect.md
index 41dc0d17f..6668c3191 100644
--- a/codev/roles/architect.md
+++ b/codev/roles/architect.md
@@ -67,6 +67,15 @@ dev-approval — lead with **Problem · Root Cause · Fix · Testing**, unprompt
 tier. Verify the root cause yourself: a builder's summary is evidence, not ground truth. The
 human should be able to answer from your message without opening the diff.
 
+### The owner decisions file
+
+A workspace may route every ask for the human's word through one file,
+`codev/state/pending-decisions.md`, shown in the dashboard as the **Decisions** tab. One
+architect, named `main`, is the hub and the only agent that edits it. Other architects send it
+items with `afx send architect:main 'DECISION <id>: <question> …'`, and a ruling made in the
+tab reaches `main` as a `RULED <id>: <word>` message. The item format the tab reads, and what
+the hub does with each ruling and question, are in `codev/resources/decision-protocol.md`.
+
 ## UX verification
 
 Before approving anything with UX requirements, exercise the actual user path. A spec that says
diff --git a/codev/state/air-1826_thread.md b/codev/state/air-1826_thread.md
new file mode 100644
index 000000000..8d6f1701c
--- /dev/null
+++ b/codev/state/air-1826_thread.md
@@ -0,0 +1,27 @@
+# air-1826 thread — ship the owner decisions process with the Decisions tab
+
+## 2026-10-18 — implement
+
+- Source: Shannon's `codev/decision-protocol.md` (read by absolute path per the architect).
+  Brought over sections 3 (intake + item), 4 incl. 4b/4c (what the hub does), 5 (file
+  skeleton), renumbered 1–4 for a standalone doc. Left out 0/0b/0c/1/2/6 (Shannon's scope,
+  jargon table, what-needs-a-word list) except one rule from 6 that bears on the file: write
+  it as little as possible, re-read before each write, every time carries its zone.
+- Placement: `resources/decision-protocol.md` in BOTH trees (byte-identical), next to
+  `risk-triage.md`. Not `protocols/`: it is a working agreement, not a porch protocol, and a
+  `protocols/<name>/` dir would read as a spawnable protocol.
+- Format section is derived from `servers/decisions/parse.ts`, `grammar.ts`, `stamp.ts`:
+  `###` items under one `## Open`, id · stamp · question, one `**Your word:**` line,
+  bare words described from the body's `**Options:**`, You asked / answer pairs, and "text
+  after the word line = the ruling, card read-only". Time zones: the doc lists exactly what
+  `stamp.ts` accepts; nothing assumes PT.
+- Source inconsistencies resolved toward the latest practice (#1819 issue body, source §6):
+  a ruled item moves to `## Ruled` at once (no interim `**Ruling:**` line under the word line).
+  Dropped HTML-comment / `<!-- REVIEW -->` mentions (annotation-viewer artifacts) and the
+  file-watch implementation details; added Tower's `RULED`/`QUESTION` notice (#1828) as how
+  tab rulings reach the hub.
+- Gap noticed, not fixed (out of scope): skeleton `resources/*.md` (risk-triage.md, now this
+  doc) is not materialized into adopter repos; the architect role names it by path, following
+  the risk-triage precedent.
+- Test: `decision-protocol-doc.test.ts` runs the doc's own markdown examples through the
+  parser, splice and notice, plus twin/link checks across both trees.
diff --git a/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts b/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts
new file mode 100644
index 000000000..b555adc1b
--- /dev/null
+++ b/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts
@@ -0,0 +1,155 @@
+/**
+ * Issue #1826 — the owner decisions process ships with the Decisions tab.
+ *
+ * `resources/decision-protocol.md` is the canonical description of the file the tab
+ * parses, so its examples run through the tab's own parser, splice and notice: a format
+ * change on either side that the other does not follow fails here. The twin and link
+ * checks are the standing "grep both trees" lesson, executed.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { parseDecisions } from '../servers/decisions/parse.js';
+import { spliceRuling } from '../servers/decisions/splice.js';
+import { rulingNotice } from '../servers/decisions/notice.js';
+
+const REPO = resolve(import.meta.dirname, '../../../../..');
+const read = (rel: string) => readFileSync(resolve(REPO, rel), 'utf8');
+
+const DOC = 'codev-skeleton/resources/decision-protocol.md';
+const doc = read(DOC);
+
+/** The doc's ```markdown blocks, de-indented (one sits inside a list item). */
+const blocks = [...doc.matchAll(/^( *)```markdown\n([\s\S]*?)^\1```$/gm)].map(([, indent, body]) =>
+  body.split('\n').map(line => line.slice(indent.length)).join('\n').trimEnd(),
+);
+
+/** The one markdown block containing `marker`. */
+function block(marker: string): string {
+  const found = blocks.filter(b => b.includes(marker));
+  expect(found, `exactly one markdown block containing ${marker}`).toHaveLength(1);
+  return found[0];
+}
+
+const fileSkeleton = block('## Ruled');
+const template = block('<first word, recommended>');
+const example = block('### web-4');
+const qaPair = block('**You asked');
+
+/** The file skeleton with `item` posted at the top of `## Open`. */
+const posted = (item: string) => fileSkeleton.replace('## Open\n', `## Open\n\n${item}\n`);
+
+describe('decision-protocol.md — its examples are what the tab parses', () => {
+  it('the file skeleton parses with no problems and no items', () => {
+    const parsed = parseDecisions(fileSkeleton);
+    expect(parsed.problems).toEqual([]);
+    expect(parsed.items).toEqual([]);
+  });
+
+  it('the item template reads its id, question and options; the first option is recommended', () => {
+    const [item] = parseDecisions(posted(template)).items;
+    expect(item.id).toBe('<name>-<n>');
+    expect(item.question).toMatch(/^<The question the owner answers/);
+    expect(item.options).toEqual([
+      { word: '<first word, recommended>', description: '', recommended: true },
+      { word: '<second word>', description: '', recommended: false },
+      { word: 'hold', description: '', recommended: false },
+    ]);
+  });
+
+  it('the worked example is one writable item whose bare words take their descriptions from **Options:**', () => {
+    const parsed = parseDecisions(posted(example));
+    expect(parsed.problems).toEqual([]);
+    expect(parsed.items).toHaveLength(1);
+    const [item] = parsed.items;
+    expect(item).toMatchObject({ id: 'web-4', problems: [], writable: true, currentRuling: '', qa: [] });
+    expect(item.question).toBe('When a session expires mid-edit, should the login fix keep the page or sign the user out?');
+    expect(item.options).toEqual([
+      { word: 'retry', description: 'refresh the sign-in in the background and keep the page', recommended: true },
+      { word: 'signout', description: 'sign the user out and keep the draft on this device', recommended: false },
+      { word: 'hold', description: '', recommended: false },
+    ]);
+  });
+
+  it("the worked example's stamp converts using only the zone it carries", () => {
+    const [item] = parseDecisions(posted(example)).items;
+    // 9:40 pm US Eastern on 2026-10-17 is daylight time, UTC-4.
+    expect(item.stamp).toEqual({ raw: '2026-10-17 9:40 pm ET', instant: '2026-10-18T01:40:00.000Z' });
+  });
+
+  it('a submit writes the word and comment after the word line, the notice names them, and the card is then ruled', () => {
+    const text = posted(example);
+    const [before] = parseDecisions(text).items;
+    const request = { id: 'web-4', word: 'retry', comment: 'Ship it after the release.', fingerprint: before.fingerprint };
+    const result = spliceRuling(text, request);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.text).toContain('**Your word:** `retry` / `signout` / `hold`\nretry\n\nShip it after the release.\n');
+    const [after] = parseDecisions(result.text).items;
+    expect(after.currentRuling).toBe('retry\n\nShip it after the release.');
+    expect(after.writable).toBe(false);
+    expect(rulingNotice(request)).toBe('RULED web-4: retry\nShip it after the release.');
+    expect(doc).toContain('`RULED <id>: <word>`');
+  });
+
+  it("the owner's question blocks the card until the hub lifts it into a You asked / answer pair (3c)", () => {
+    const text = posted(example);
+    const [before] = parseDecisions(text).items;
+    const question = 'Could retry hide a real sign-out from the user?';
+    const request = { id: 'web-4', comment: question, fingerprint: before.fingerprint };
+    const asked = spliceRuling(text, request);
+    expect(asked.ok).toBe(true);
+    if (!asked.ok) return;
+    expect(parseDecisions(asked.text).items[0]).toMatchObject({ currentRuling: question, writable: false });
+    expect(rulingNotice(request)).toBe(`QUESTION web-4:\n${question}`);
+    expect(doc).toContain('`QUESTION <id>:`');
+
+    // The hub pastes the pair above the word line and leaves nothing under it.
+    const answered = posted(example.replace('\n\n**Your word:**', `\n\n${qaPair}\n\n**Your word:**`));
+    const [item] = parseDecisions(answered).items;
+    expect(item).toMatchObject({ problems: [], writable: true, currentRuling: '' });
+    expect(item.qa).toEqual([
+      { kind: 'asked', time: '10:05 pm ET', markdown: `"${question}"`, answered: true },
+      {
+        kind: 'answer',
+        name: 'Web',
+        time: '10:12 pm ET',
+        markdown:
+          'No. A refresh that fails still signs the user out and says why.\n' +
+          'Main checked the test that forces a failed refresh: it signs out and shows the message.',
+      },
+    ]);
+    expect(item.bodyMarkdown).not.toContain('You asked');
+    expect(item.options.map(o => o.description)[0]).toBe('refresh the sign-in in the background and keep the page');
+  });
+
+  it('no time in the doc assumes a zone: every example time carries one, and none is written as PT-only', () => {
+    expect(doc).not.toMatch(/(?:am|pm) PT\b/);
+    for (const b of blocks) expect(b).not.toMatch(/\d{1,2}:\d{2} (?:am|pm)(?! [A-Z])/);
+  });
+});
+
+describe('decision-protocol.md — reaches both trees and is linked where adopters look', () => {
+  it('the instance copy is byte-identical to the skeleton', () => {
+    expect(read('codev/resources/decision-protocol.md')).toBe(doc);
+  });
+
+  for (const tree of ['codev', 'codev-skeleton']) {
+    it(`${tree}: the Decisions tab section of agent-farm.md links the doc, and the link resolves`, () => {
+      const rel = `${tree}/resources/commands/agent-farm.md`;
+      const section = read(rel).match(/^### Decisions tab\n[\s\S]*?(?=^### )/m)?.[0] ?? '';
+      expect(section).toContain('](../decision-protocol.md)');
+      expect(existsSync(resolve(REPO, dirname(rel), '../decision-protocol.md'))).toBe(true);
+    });
+
+    it(`${tree}: the architect role points at the doc`, () => {
+      expect(read(`${tree}/roles/architect.md`)).toContain('`codev/resources/decision-protocol.md`');
+    });
+  }
+
+  it("the doc's own link to agent-farm.md resolves", () => {
+    expect(doc).toContain('](commands/agent-farm.md)');
+    expect(existsSync(resolve(REPO, 'codev-skeleton/resources/commands/agent-farm.md'))).toBe(true);
+  });
+});

From dfd37a2ef08bded51fbe9134d6ccf856589c46fe Mon Sep 17 00:00:00 2001
From: M Waleed Kadous <waleedk@gmail.com>
Date: Sun, 18 Oct 2026 16:14:06 -0700
Subject: [PATCH 3/8] chore(porch): 1826 pr phase-transition

---
 .../projects/1826-skeleton-ship-the-owner-decisi/status.yaml  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml b/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
index af58bb4e2..34cf70a34 100644
--- a/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
+++ b/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
@@ -1,7 +1,7 @@
 id: '1826'
 title: skeleton-ship-the-owner-decisi
 protocol: air
-phase: implement
+phase: pr
 plan_phases: []
 current_plan_phase: null
 gates:
@@ -11,4 +11,4 @@ iteration: 1
 build_complete: false
 history: []
 started_at: '2026-10-18T23:05:06.935Z'
-updated_at: '2026-10-18T23:05:06.936Z'
+updated_at: '2026-10-18T23:14:06.640Z'

From 76a2a8ce0808e8a10ac6ba76630b4b770d37afb3 Mon Sep 17 00:00:00 2001
From: M Waleed Kadous <waleedk@gmail.com>
Date: Sun, 18 Oct 2026 16:21:03 -0700
Subject: [PATCH 4/8] [Air #1826] fix: Address CMAP review of the decisions
 process doc

- The file header now says to rule on the line under **Your word:**, which is
  what the tab reads; a word typed on the line itself leaves the card open.
- The ## Ruled line no longer names an outcome before DONE; DONE is appended.
- Say that creating the file makes the tab appear, and that Tower's notice
  reaches only an architect named main.
- Tests pin the hand-ruling instruction and every zone the doc names.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 codev-skeleton/resources/decision-protocol.md | 21 +++++++++-------
 codev/resources/decision-protocol.md          | 21 +++++++++-------
 codev/state/air-1826_thread.md                | 18 ++++++++++++++
 .../__tests__/decision-protocol-doc.test.ts   | 24 +++++++++++++++++++
 4 files changed, 68 insertions(+), 16 deletions(-)

diff --git a/codev-skeleton/resources/decision-protocol.md b/codev-skeleton/resources/decision-protocol.md
index 01b21840d..703d2de13 100644
--- a/codev-skeleton/resources/decision-protocol.md
+++ b/codev-skeleton/resources/decision-protocol.md
@@ -106,18 +106,20 @@ A worked example, a choice with bare words on the word line:
    `New decision from <name>: <id> — <question>`, plus `[urgent]` if marked.
 2. **Learn of rulings.** The owner rules in the tab, by typing in the file, or in chat. A ruling
    made in the tab reaches the hub as a message from Tower: `RULED <id>: <word>`, or
-   `QUESTION <id>:` when no word was chosen, with the comment on the lines after it. A ruling
-   typed into the file reaches the hub when the owner says so in chat (a short agreed word,
-   such as `ddu` for "decisions doc updated") or when the hub's own watch on the file sees the
-   change. Either way the hub scans every open item for text after its `**Your word:**` line
-   and replies with one line per ruling found. A word in chat counts the same.
+   `QUESTION <id>:` when no word was chosen, with the comment on the lines after it. The notice
+   goes only to an architect named `main`, and waits for it to come back if it is not running;
+   a workspace without one gets no notice, so its hub must scan the file. A ruling typed
+   into the file reaches the hub when the owner says so in chat (a short agreed word, such as
+   `ddu` for "decisions doc updated") or when the hub's own watch on the file sees the change.
+   Either way the hub scans every open item for text on the lines under its `**Your word:**`
+   line and replies with one line per ruling found. A word in chat counts the same.
 3. **Relay and record.** For each ruling the hub relays at once,
    `afx send architect:<name> 'RULING <id>: <word> (owner, <time> <zone>)'`, and moves the
    item out of `## Open` into `## Ruled` as one line:
-   ``- **<id>** · <time> <zone> · <question> → `<word>` → <what happened>``.
+   ``- **<id>** · <time> <zone> · <question> → `<word>` ``.
    A ruling that carries a question goes through 3b first.
 4. **Done.** The architect acts and replies `DONE <id>: <one line of what happened>`; the hub
-   appends it to the item's line in `## Ruled`.
+   appends ` → DONE <time> <zone>: <what happened>` to the item's line in `## Ruled`.
 5. If the owner rules in chat to another architect directly, that architect sends the hub
    `RULED <id>: <word> (owner, <time> <zone>, in chat)`, and the hub records it the same way.
 6. The hub's own asks use the same format, under `main-<n>`.
@@ -161,10 +163,13 @@ A second question gets a second pair of lines under the first.
 
 ## 4. The file
 
+Create it at `codev/state/pending-decisions.md`, or at the path `dashboard.decisionsFile` names;
+the Decisions tab appears once the file exists.
+
 ```markdown
 # Pending owner decisions — all architects (hub: main)
 
-Rule inline: one word on an item's **Your word:** line, or in the Decisions tab.
+Rule inline: one word on the line under an item's **Your word:** line, or in the Decisions tab.
 Newest first. Only main edits this file; architects send items with `afx send architect:main 'DECISION …'`.
 
 _Status: 0 open._
diff --git a/codev/resources/decision-protocol.md b/codev/resources/decision-protocol.md
index 01b21840d..703d2de13 100644
--- a/codev/resources/decision-protocol.md
+++ b/codev/resources/decision-protocol.md
@@ -106,18 +106,20 @@ A worked example, a choice with bare words on the word line:
    `New decision from <name>: <id> — <question>`, plus `[urgent]` if marked.
 2. **Learn of rulings.** The owner rules in the tab, by typing in the file, or in chat. A ruling
    made in the tab reaches the hub as a message from Tower: `RULED <id>: <word>`, or
-   `QUESTION <id>:` when no word was chosen, with the comment on the lines after it. A ruling
-   typed into the file reaches the hub when the owner says so in chat (a short agreed word,
-   such as `ddu` for "decisions doc updated") or when the hub's own watch on the file sees the
-   change. Either way the hub scans every open item for text after its `**Your word:**` line
-   and replies with one line per ruling found. A word in chat counts the same.
+   `QUESTION <id>:` when no word was chosen, with the comment on the lines after it. The notice
+   goes only to an architect named `main`, and waits for it to come back if it is not running;
+   a workspace without one gets no notice, so its hub must scan the file. A ruling typed
+   into the file reaches the hub when the owner says so in chat (a short agreed word, such as
+   `ddu` for "decisions doc updated") or when the hub's own watch on the file sees the change.
+   Either way the hub scans every open item for text on the lines under its `**Your word:**`
+   line and replies with one line per ruling found. A word in chat counts the same.
 3. **Relay and record.** For each ruling the hub relays at once,
    `afx send architect:<name> 'RULING <id>: <word> (owner, <time> <zone>)'`, and moves the
    item out of `## Open` into `## Ruled` as one line:
-   ``- **<id>** · <time> <zone> · <question> → `<word>` → <what happened>``.
+   ``- **<id>** · <time> <zone> · <question> → `<word>` ``.
    A ruling that carries a question goes through 3b first.
 4. **Done.** The architect acts and replies `DONE <id>: <one line of what happened>`; the hub
-   appends it to the item's line in `## Ruled`.
+   appends ` → DONE <time> <zone>: <what happened>` to the item's line in `## Ruled`.
 5. If the owner rules in chat to another architect directly, that architect sends the hub
    `RULED <id>: <word> (owner, <time> <zone>, in chat)`, and the hub records it the same way.
 6. The hub's own asks use the same format, under `main-<n>`.
@@ -161,10 +163,13 @@ A second question gets a second pair of lines under the first.
 
 ## 4. The file
 
+Create it at `codev/state/pending-decisions.md`, or at the path `dashboard.decisionsFile` names;
+the Decisions tab appears once the file exists.
+
 ```markdown
 # Pending owner decisions — all architects (hub: main)
 
-Rule inline: one word on an item's **Your word:** line, or in the Decisions tab.
+Rule inline: one word on the line under an item's **Your word:** line, or in the Decisions tab.
 Newest first. Only main edits this file; architects send items with `afx send architect:main 'DECISION …'`.
 
 _Status: 0 open._
diff --git a/codev/state/air-1826_thread.md b/codev/state/air-1826_thread.md
index 8d6f1701c..08e72c08e 100644
--- a/codev/state/air-1826_thread.md
+++ b/codev/state/air-1826_thread.md
@@ -25,3 +25,21 @@
   the risk-triage precedent.
 - Test: `decision-protocol-doc.test.ts` runs the doc's own markdown examples through the
   parser, splice and notice, plus twin/link checks across both trees.
+
+## 2026-10-18 — PR #1832, CMAP round 1 (codex REQUEST_CHANGES, claude APPROVE)
+
+- Fixed (codex): the file skeleton's header said to rule "on" the `**Your word:**` line, but
+  the tab reads only the lines under it, so a word typed on the line leaves the card open.
+  Header now says "on the line under"; §3 says the hub scans "the lines under". A new test
+  pins both behaviours.
+- Fixed (codex): the `## Ruled` one-liner carried `<what happened>` before DONE supplies it.
+  Now `- **<id>** · <time> <zone> · <question> → `<word>``, and DONE appends
+  ` → DONE <time> <zone>: <what happened>`.
+- Rebutted (codex): over AIR's 300 LOC. There is no runtime code; the length is the doc the
+  issue asks for (~180 lines), its mirror (two-trees rule) and its test. Flagged to the
+  architect rather than trimmed silently.
+- Applied (claude, non-blocking): test pins every zone the doc names to `stamp.ts`; §4 says
+  creating the file is what makes the tab appear; §3 says the Tower notice reaches only an
+  architect named `main`.
+- Porch's first `tests` check failed with truncated output; three later full runs on the same
+  commit passed. Unidentified; recorded under Flaky Tests in the PR body.
diff --git a/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts b/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts
index b555adc1b..d15c0f301 100644
--- a/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts
+++ b/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts
@@ -13,6 +13,7 @@ import { dirname, resolve } from 'node:path';
 import { parseDecisions } from '../servers/decisions/parse.js';
 import { spliceRuling } from '../servers/decisions/splice.js';
 import { rulingNotice } from '../servers/decisions/notice.js';
+import { resolveStamp } from '../servers/decisions/stamp.js';
 
 const REPO = resolve(import.meta.dirname, '../../../../..');
 const read = (rel: string) => readFileSync(resolve(REPO, rel), 'utf8');
@@ -124,10 +125,33 @@ describe('decision-protocol.md — its examples are what the tab parses', () =>
     expect(item.options.map(o => o.description)[0]).toBe('refresh the sign-in in the background and keep the page');
   });
 
+  it("a word typed by hand where the file's header says rules the item; on the word line itself it does not", () => {
+    expect(fileSkeleton).toContain("one word on the line under an item's **Your word:** line");
+    const wordLine = '**Your word:** `retry` / `signout` / `hold`';
+    const under = parseDecisions(posted(example.replace(wordLine, `${wordLine}\nretry`))).items[0];
+    expect(under).toMatchObject({ currentRuling: 'retry', writable: false });
+    const onLine = parseDecisions(posted(example.replace(wordLine, `${wordLine} retry`))).items[0];
+    expect(onLine).toMatchObject({ currentRuling: '', writable: true });
+  });
+
   it('no time in the doc assumes a zone: every example time carries one, and none is written as PT-only', () => {
     expect(doc).not.toMatch(/(?:am|pm) PT\b/);
     for (const b of blocks) expect(b).not.toMatch(/\d{1,2}:\d{2} (?:am|pm)(?! [A-Z])/);
   });
+
+  it('every zone the doc names converts, and the ambiguous abbreviations it names do not', () => {
+    const zones = ['PT', 'MT', 'CT', 'ET', 'AKT', 'HT', 'UTC', 'GMT', 'EST', 'EDT', 'CET', 'CEST', 'JST', 'AEST', 'AEDT', 'CST',
+      '+05:30', 'UTC+5:30', 'GMT-3', 'Europe/Berlin'];
+    for (const zone of zones) {
+      expect(doc).toContain(`\`${zone}\``);
+      expect(resolveStamp(`2026-01-15 9:00 am ${zone}`).instant, zone).not.toBeNull();
+    }
+    expect(resolveStamp('2026-01-15 9:00 am CST').instant).toBe('2026-01-15T15:00:00.000Z');
+    for (const zone of ['IST', 'BST', 'AST']) {
+      expect(doc).toContain(`\`${zone}\``);
+      expect(resolveStamp(`2026-01-15 9:00 am ${zone}`).unconvertedReason, zone).toBe('unknown-zone');
+    }
+  });
 });
 
 describe('decision-protocol.md — reaches both trees and is linked where adopters look', () => {

From fc5f1832f66e7bdf5409004959d009576ec1e0dc Mon Sep 17 00:00:00 2001
From: M Waleed Kadous <waleedk@gmail.com>
Date: Sun, 18 Oct 2026 16:21:33 -0700
Subject: [PATCH 5/8] chore(porch): 1826 record PR #1832

---
 .../1826-skeleton-ship-the-owner-decisi/status.yaml        | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml b/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
index 34cf70a34..4813bdc30 100644
--- a/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
+++ b/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
@@ -11,4 +11,9 @@ iteration: 1
 build_complete: false
 history: []
 started_at: '2026-10-18T23:05:06.935Z'
-updated_at: '2026-10-18T23:14:06.640Z'
+updated_at: '2026-10-18T23:21:33.556Z'
+pr_history:
+  - phase: pr
+    pr_number: 1832
+    branch: builder/air-1826
+    created_at: '2026-10-18T23:21:33.555Z'

From 0f8613b4798525c4000e67bbd2cbc2f6a4878c49 Mon Sep 17 00:00:00 2001
From: M Waleed Kadous <waleedk@gmail.com>
Date: Sun, 18 Oct 2026 16:22:32 -0700
Subject: [PATCH 6/8] chore(porch): 1826 pr gate-requested

---
 .../projects/1826-skeleton-ship-the-owner-decisi/status.yaml  | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml b/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
index 4813bdc30..1fe06717e 100644
--- a/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
+++ b/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
@@ -7,13 +7,15 @@ current_plan_phase: null
 gates:
   pr:
     status: pending
+    requested_at: '2026-10-18T23:22:32.432Z'
 iteration: 1
 build_complete: false
 history: []
 started_at: '2026-10-18T23:05:06.935Z'
-updated_at: '2026-10-18T23:21:33.556Z'
+updated_at: '2026-10-18T23:22:32.434Z'
 pr_history:
   - phase: pr
     pr_number: 1832
     branch: builder/air-1826
     created_at: '2026-10-18T23:21:33.555Z'
+pr_ready_for_human: true

From 6356a76d9a9154c3c21c5baf6222221129a4078b Mon Sep 17 00:00:00 2001
From: M Waleed Kadous <waleedk@gmail.com>
Date: Sun, 18 Oct 2026 16:29:59 -0700
Subject: [PATCH 7/8] [Air #1826] fix: Carry the owner's comment in the relay;
 trim the architect role section

- The hub's RULING relay carries the owner's comment verbatim, and the
  ## Ruled line quotes it after the word, so a conditional ruling keeps its
  condition. The doc test asserts both forms.
- roles/architect.md: three lines pointing at the doc instead of restating it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 codev-skeleton/resources/decision-protocol.md        |  7 ++++---
 codev-skeleton/roles/architect.md                    |  9 +++------
 codev/resources/decision-protocol.md                 |  7 ++++---
 codev/roles/architect.md                             |  9 +++------
 codev/state/air-1826_thread.md                       | 12 ++++++++++++
 .../__tests__/decision-protocol-doc.test.ts          |  3 +++
 6 files changed, 29 insertions(+), 18 deletions(-)

diff --git a/codev-skeleton/resources/decision-protocol.md b/codev-skeleton/resources/decision-protocol.md
index 703d2de13..4981fb23f 100644
--- a/codev-skeleton/resources/decision-protocol.md
+++ b/codev-skeleton/resources/decision-protocol.md
@@ -114,9 +114,10 @@ A worked example, a choice with bare words on the word line:
    Either way the hub scans every open item for text on the lines under its `**Your word:**`
    line and replies with one line per ruling found. A word in chat counts the same.
 3. **Relay and record.** For each ruling the hub relays at once,
-   `afx send architect:<name> 'RULING <id>: <word> (owner, <time> <zone>)'`, and moves the
-   item out of `## Open` into `## Ruled` as one line:
-   ``- **<id>** · <time> <zone> · <question> → `<word>` ``.
+   `afx send architect:<name> 'RULING <id>: <word> (owner, <time> <zone>)'`, with the owner's
+   comment verbatim on the lines after it when there is one, and moves the item out of
+   `## Open` into `## Ruled` as one line, the comment quoted after the word when there is one:
+   ``- **<id>** · <time> <zone> · <question> → `<word>` — "<comment>"``.
    A ruling that carries a question goes through 3b first.
 4. **Done.** The architect acts and replies `DONE <id>: <one line of what happened>`; the hub
    appends ` → DONE <time> <zone>: <what happened>` to the item's line in `## Ruled`.
diff --git a/codev-skeleton/roles/architect.md b/codev-skeleton/roles/architect.md
index 6668c3191..300db825e 100644
--- a/codev-skeleton/roles/architect.md
+++ b/codev-skeleton/roles/architect.md
@@ -69,12 +69,9 @@ human should be able to answer from your message without opening the diff.
 
 ### The owner decisions file
 
-A workspace may route every ask for the human's word through one file,
-`codev/state/pending-decisions.md`, shown in the dashboard as the **Decisions** tab. One
-architect, named `main`, is the hub and the only agent that edits it. Other architects send it
-items with `afx send architect:main 'DECISION <id>: <question> …'`, and a ruling made in the
-tab reaches `main` as a `RULED <id>: <word>` message. The item format the tab reads, and what
-the hub does with each ruling and question, are in `codev/resources/decision-protocol.md`.
+A workspace may collect every ask for the human's word in `codev/state/pending-decisions.md`,
+the dashboard's **Decisions** tab, with one architect named `main` as the hub and its only
+editor. The process and the item format are in `codev/resources/decision-protocol.md`.
 
 ## UX verification
 
diff --git a/codev/resources/decision-protocol.md b/codev/resources/decision-protocol.md
index 703d2de13..4981fb23f 100644
--- a/codev/resources/decision-protocol.md
+++ b/codev/resources/decision-protocol.md
@@ -114,9 +114,10 @@ A worked example, a choice with bare words on the word line:
    Either way the hub scans every open item for text on the lines under its `**Your word:**`
    line and replies with one line per ruling found. A word in chat counts the same.
 3. **Relay and record.** For each ruling the hub relays at once,
-   `afx send architect:<name> 'RULING <id>: <word> (owner, <time> <zone>)'`, and moves the
-   item out of `## Open` into `## Ruled` as one line:
-   ``- **<id>** · <time> <zone> · <question> → `<word>` ``.
+   `afx send architect:<name> 'RULING <id>: <word> (owner, <time> <zone>)'`, with the owner's
+   comment verbatim on the lines after it when there is one, and moves the item out of
+   `## Open` into `## Ruled` as one line, the comment quoted after the word when there is one:
+   ``- **<id>** · <time> <zone> · <question> → `<word>` — "<comment>"``.
    A ruling that carries a question goes through 3b first.
 4. **Done.** The architect acts and replies `DONE <id>: <one line of what happened>`; the hub
    appends ` → DONE <time> <zone>: <what happened>` to the item's line in `## Ruled`.
diff --git a/codev/roles/architect.md b/codev/roles/architect.md
index 6668c3191..300db825e 100644
--- a/codev/roles/architect.md
+++ b/codev/roles/architect.md
@@ -69,12 +69,9 @@ human should be able to answer from your message without opening the diff.
 
 ### The owner decisions file
 
-A workspace may route every ask for the human's word through one file,
-`codev/state/pending-decisions.md`, shown in the dashboard as the **Decisions** tab. One
-architect, named `main`, is the hub and the only agent that edits it. Other architects send it
-items with `afx send architect:main 'DECISION <id>: <question> …'`, and a ruling made in the
-tab reaches `main` as a `RULED <id>: <word>` message. The item format the tab reads, and what
-the hub does with each ruling and question, are in `codev/resources/decision-protocol.md`.
+A workspace may collect every ask for the human's word in `codev/state/pending-decisions.md`,
+the dashboard's **Decisions** tab, with one architect named `main` as the hub and its only
+editor. The process and the item format are in `codev/resources/decision-protocol.md`.
 
 ## UX verification
 
diff --git a/codev/state/air-1826_thread.md b/codev/state/air-1826_thread.md
index 08e72c08e..792cf1e09 100644
--- a/codev/state/air-1826_thread.md
+++ b/codev/state/air-1826_thread.md
@@ -43,3 +43,15 @@
   architect named `main`.
 - Porch's first `tests` check failed with truncated output; three later full runs on the same
   commit passed. Unidentified; recorded under Flaky Tests in the PR body.
+
+## 2026-10-18 — architect integration review on PR #1832
+
+- The owner's comment now survives the hub's `RULING` relay (verbatim, on the lines after it)
+  and the `## Ruled` record (quoted after the word). Before, a conditional ruling lost its
+  condition everywhere but Tower's notice. The doc test asserts both forms.
+- `roles/architect.md` section trimmed to three lines (what the file is, `main` is the hub,
+  pointer to the doc); the intake command and `RULED` format live only in the doc (Spec 1280
+  direction: keep the always-loaded role small).
+- Filed #1834 (area/scaffold): skeleton `resources/*.md` reference docs never reach adopter
+  repos; one generic fix, not per-file.
+- pr gate stays pending; the architect takes the merge word to the owner once CI is green.
diff --git a/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts b/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts
index d15c0f301..c9f60e690 100644
--- a/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts
+++ b/packages/codev/src/agent-farm/__tests__/decision-protocol-doc.test.ts
@@ -92,6 +92,9 @@ describe('decision-protocol.md — its examples are what the tab parses', () =>
     expect(after.writable).toBe(false);
     expect(rulingNotice(request)).toBe('RULED web-4: retry\nShip it after the release.');
     expect(doc).toContain('`RULED <id>: <word>`');
+    // The comment survives the hub's relay and its `## Ruled` record, not only the notice.
+    expect(doc).toMatch(/'RULING <id>: <word> \(owner, <time> <zone>\)'`, with the owner's\s+comment verbatim/);
+    expect(doc).toContain('→ `<word>` — "<comment>"');
   });
 
   it("the owner's question blocks the card until the hub lifts it into a You asked / answer pair (3c)", () => {

From a298a3b34c12629768a04e59378815af41a2f010 Mon Sep 17 00:00:00 2001
From: M Waleed Kadous <waleedk@gmail.com>
Date: Sun, 18 Oct 2026 18:00:21 -0700
Subject: [PATCH 8/8] chore(porch): 1826 pr gate-approved

---
 .../1826-skeleton-ship-the-owner-decisi/status.yaml        | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml b/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
index 1fe06717e..7ffb6aac3 100644
--- a/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
+++ b/codev/projects/1826-skeleton-ship-the-owner-decisi/status.yaml
@@ -6,16 +6,17 @@ plan_phases: []
 current_plan_phase: null
 gates:
   pr:
-    status: pending
+    status: approved
     requested_at: '2026-10-18T23:22:32.432Z'
+    approved_at: '2026-10-19T01:00:21.629Z'
 iteration: 1
 build_complete: false
 history: []
 started_at: '2026-10-18T23:05:06.935Z'
-updated_at: '2026-10-18T23:22:32.434Z'
+updated_at: '2026-10-19T01:00:21.629Z'
 pr_history:
   - phase: pr
     pr_number: 1832
     branch: builder/air-1826
     created_at: '2026-10-18T23:21:33.555Z'
-pr_ready_for_human: true
+pr_ready_for_human: false