create-pmos 0.497.0 → 0.499.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.497.0",
+  "version": "0.499.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {
@@ -32,6 +32,62 @@
     "audit"
   ],
   "pmosChanges": [
+    {
+      "v": "0.499.0",
+      "at": "2026-11-03T03:25:28.533Z",
+      "f": 3,
+      "prs": [
+        {
+          "n": 1180,
+          "t": "The context meter knows the default model is 1M",
+          "s": "The context meter knows the default model is 1M",
+          "k": "fix"
+        },
+        {
+          "n": 1181,
+          "t": "`pmos initiative list` names records on a document lane",
+          "s": "Pmos initiative list names records on a document lane",
+          "k": "fix"
+        },
+        {
+          "n": 1182,
+          "t": "Claude login test passes for a signed-in new user; picker shows each login once",
+          "s": "Claude login test passes for a signed-in new user; picker shows each login once",
+          "k": "fix"
+        }
+      ]
+    },
+    {
+      "v": "0.498.0",
+      "at": "2026-11-03T02:50:09.805Z",
+      "f": 3,
+      "prs": [
+        {
+          "n": 1176,
+          "t": "Commit as the repo's own git identity; ask the PM once when it has none",
+          "s": "Commit as the repo's own git identity; ask the PM once when it has none",
+          "k": "fix"
+        },
+        {
+          "n": 1178,
+          "t": "Full task names wrap; add-task chips for stage, type, dates, owner",
+          "s": "Full task names wrap; add-task chips for stage, type, dates, owner",
+          "k": "new"
+        },
+        {
+          "n": 1179,
+          "t": "Each product repo pushes with its own GitHub login",
+          "s": "Each product repo pushes with its own GitHub login",
+          "k": "new"
+        },
+        {
+          "n": 1177,
+          "t": "A workflow routes the initiative; blocked steps ask only as ✦ proposals",
+          "s": "A workflow routes the initiative; blocked steps ask only as ✦ proposals",
+          "k": "fix"
+        }
+      ]
+    },
     {
       "v": "0.497.0",
       "at": "2026-11-03T02:04:11.405Z",
@@ -366,31 +422,6 @@
           "k": "fix"
         }
       ]
-    },
-    {
-      "v": "0.479.0",
-      "at": "2026-11-01T10:19:06.142Z",
-      "f": 3,
-      "prs": [
-        {
-          "n": 1137,
-          "t": "Batch 21: feedback fixes (held for one merge)",
-          "s": "Batch 21: feedback fixes (held for one merge)"
-        }
-      ]
-    },
-    {
-      "v": "0.478.0",
-      "at": "2026-11-01T08:32:21.933Z",
-      "f": 3,
-      "prs": [
-        {
-          "n": 1138,
-          "t": "Shared-board milestone keeps its place; CI runs only the suites a PR reaches",
-          "s": "Shared-board milestone keeps its place; CI runs only the suites a PR reaches",
-          "k": "fix"
-        }
-      ]
     }
   ]
 }

package/payload/AGENTS.md

@@ -89,6 +89,7 @@ Every initiative carries a `type` — the lane picks what the gate requires **be
    - **Existing surface → the PM needs the understanding too.** That retrieval warms *you*. When the work touches something that already exists — the test is *would specifying this honestly require reading code that already exists?* — run `skills/explain-surface.skill` on that region **before** the brief/PRD is authored, in a fresh context and **not** by the agent that will write it. Standard for existing surfaces, skipped for greenfield. Without it, the agent acquires the understanding and the **PM approves a spec built on facts they never saw**.
 4. Anchor: the initiative file must exist at stage `intake`/`spec` with its **lane's** spec/eval artifacts authored **before** build (eval-first, D13, generalized per lane — see the lane table above; `feature` = PRD + rubric; the incident lane alone records post-hoc). Contract per lane: `feature` = the rubric's sprint-contract section with the PM's explicit `PM_approved: true`; `discovery` = the PM-approved spike brief (question + timebox); `chore` = the stated intent; `content` = the PM-approved content brief; `prototype` = the PM-approved quick brief (the judgement exercised + the specimen format) — and **no rubric**, which is the decision, not an omission. No work before the lane's approval. When you question the PM to reach any of these, follow `skills/requirements-elicitation.skill`. Feature-lane `test_method`s SHOULD be executable checks written before build (D58) — wire `templates/product-ci-starter.yml` so tier 1 is never silently empty.
 5. Branch `initiative/<id>`; execute at control altitude; one commit per artifact.
+   - **Commit as the repository's own git identity, and push with its own GitHub login.** Never pass an author on the command line (`-c user.name=…`, `-c user.email=…`, `--author`, `GIT_AUTHOR_*` or `GIT_COMMITTER_*`), and never use a name, email or login from your account, the session or another repository. The PM uses different identities and GitHub logins for different products. Run `pmos git-identity` (or `node "$PMOS_BIN" git-identity`) before the first commit or push in a repository, and again if `git commit` fails with "Author identity unknown" or `git push` fails with "Repository not found". It says what this repository uses, or lists what the PM uses in the other repositories. If something is missing, ask the PM once which identity and GitHub login this product uses, offering those. Save the answer with `pmos git-identity set --name "…" --email "…" --login <login>` (this repository only, never `--global`), then commit and push. After that, `git push` uses that login by itself; run `gh` in this repository as `GH_TOKEN="$(gh auth token --user <login>)" gh …`. Never run `gh auth switch`. Do not leave the PM's files staged.
 6. Self-evaluate against the contract — self-eval is unreliable; it is an input to the gates, never a verdict.
 7. Close the gates: **Quality** = this repo's CI plus the kit gate (`pmos/scripts/gate-initiative.sh`
    + `pmos/planning/evals/check_rubrics.py`); **Review** = score against the rubric with the evaluator skill (adversarial, outcome-only, default-to-refute) and append to `evals.jsonl`; **Acceptance** = the human PM merges and disposes — final and non-delegable. Never merge your own PR.

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@4a32332c
+kernel-source: pmos@02cdbcfc
 assembled: 2026-11-03
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-11-03T02:04:07Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T03:25:24Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-11-03T02:04:07Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T03:25:24Z"}
 status: stable
 ---
 

package/payload/scripts/workflow-state.js

@@ -556,6 +556,29 @@ function profileOf(root) {
   } catch { return 'product-code'; }
 }
 
+/*
+ * workflowOf(root, id) — the workflow an initiative runs, when its repository runs initiatives on workflows (Boards, Settings ›
+ * Workflows). The workspace gives every repository it keeps state for a default board, so every initiative there runs a workflow:
+ * an `ini-wf` line in the boards ledger (<state dir>/boards.jsonl, the dirs workspace/server.js stateDirFor reads) names its
+ * own, else it runs its board's (Product feature by default). A repository runs on workflows when it holds that ledger or a
+ * pmos/state/ dir. PMOS itself holds neither (its state is the workspace's own), so it still routes by lane and R0 still binds it.
+ * → the workflow's id, '' (its board's), or null (no workflows). The ledger is read again when its size or mtime changes.
+ */
+const wfMemo = new Map();
+function workflowOf(root, id) {
+  const f = [['pmos', 'state'], ['state'], ['.pmos']].map((rel) => path.join(root, ...rel, 'boards.jsonl')).find((x) => fs.existsSync(x));
+  const on = !!f || fs.existsSync(path.join(root, 'pmos', 'state'));
+  if (!on) return null;
+  let key = '';
+  try { const st = f ? fs.statSync(f) : null; key = st ? st.size + ':' + st.mtimeMs : '-'; } catch { key = '?'; }
+  let m = wfMemo.get(root);
+  if (!m || m.key !== key) {   // a held module sees a new line on the next read (the in-process freshness rule)
+    m = { key, wf: new Map() };
+    for (const l of f ? jsonl.readJsonl(f).rows : []) if (l && l.kind === 'ini-wf' && typeof l.id === 'string' && typeof l.wf === 'string' && l.wf) m.wf.set(l.id, l.wf);
+    wfMemo.set(root, m);
+  }
+  return m.wf.get(id) || '';
+}
 /** The lanes a repository's initiatives may declare — what the lane picker offers and the lane write accepts. */
 function laneNames(profile) { return laneDefs.laneNames(profile === 'pm-artifacts' ? 'pm-artifacts' : 'product-code'); }
 function lanesFor(root) {
@@ -735,6 +758,7 @@ function computeWorkflowDerived(id, opts) {
   // ── route ─ the lane is chosen and the two intake questions are answered ─────────────────────
   const sRoute = specimenRoute(fm.specimen_test);
   const fRoute = surfaceRoute(fm.surface_check);
+  const onWf = workflowOf(root, id);
   {
     const missing = [];
     if (sRoute === 'undeclared' || sRoute === 'malformed') missing.push('specimen_test');
@@ -742,6 +766,10 @@ function computeWorkflowDerived(id, opts) {
     if (!missing.length) {
       steps.push(step('route', 'route', 'done',
         `${lane} lane · specimen test ${sRoute} · surface ${fRoute}`));
+    } else if (onWf !== null) {
+      // Batch 25 item 6: an initiative on a workflow is routed. The workflow's stages say what comes first, and PMOS proposes a
+      // switch when the BRD says another workflow fits, so the two intake questions are not asked of it again.
+      steps.push(step('route', 'route', 'done', `${onWf ? `runs the ${onWf} workflow` : 'runs its board\'s workflow'} — the workflow routes it`));
     } else if (effLane !== 'feature') {
       // The routing questions are asked of feature work only.
       steps.push(step('route', 'route', 'done', `${lane} lane — routing questions are for features only (${CUT_NOTE})`));

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-11-03T02:04:07Z"}
+generated: {by: process:create-pmos, at: "2026-11-03T03:25:24Z"}
 status: stable
 ---
 

package/workspace/briefing-premium-test.js

@@ -172,11 +172,11 @@ const vw = () => { const v = document.querySelector('#czViewer:not([hidden])');
     await p.click(`.hm-r[data-id="n:${k4}"] .hm-rm`);
     await until(() => p.evaluate(() => !!document.querySelector('#czViewer:not([hidden]) [data-czs-act="start"]')));
     const s0 = await p.evaluate(() => { const v = document.querySelector('#czViewer'); return { line: (v.querySelector('.czs-line') || {}).textContent || '', offer: (v.querySelector('.nv-offer') || {}).textContent || '', cost: (v.querySelector('.nv-cost') || {}).textContent || '', pri: (v.querySelector('.czs-pri') || {}).textContent || '', own: (v.querySelector('.nv-own') || {}).textContent || '' }; });
-    ok('W8 a blocked row says what is missing, offers ✦ what Claude drafts, says what waiting costs, and holds ONE verb', s0.line === 'Blocked: the spec is missing' && /^I can do the spec/.test(s0.offer) && /^If it waits: /.test(s0.cost) && s0.pri === 'Do the spec' && /Yours to unblock · New feature/.test(s0.own), JSON.stringify(s0));
+    ok('W8 a blocked row says what is missing, offers ✦ what Claude drafts (batch 25 item 6: a concrete proposal), says what waiting costs, and holds ONE verb', s0.line === 'Blocked: the spec is missing' && /^I can draft the PRD/.test(s0.offer) && /^If it waits: /.test(s0.cost) && s0.pri === 'Draft the PRD' && /Yours to unblock · New feature/.test(s0.own), JSON.stringify(s0));
     await p.click('[data-czs-act="start"]');
     const sp = await until(() => { const l = A.posts.filter((x) => x.path === '/api/agent/start'); return l.length ? l : null; });
     ok('W8 Start posts one agent start for that row', !!sp && sp.length === 1, JSON.stringify(A.posts.map((x) => [x.path, x.body])));
-    const s1 = await until(() => p.evaluate(() => { const v = document.querySelector('#czViewer:not([hidden])'); const l = v && v.querySelector('.czs-line'); return l && /^Doing the spec/.test(l.textContent) ? { stop: !!v.querySelector('[data-czs-act="stop"][aria-label="Stop the agent"]'), chat: !!v.querySelector('[data-czs-act="talk"]'), pri: !!v.querySelector('.czs-pri') } : null; }));
+    const s1 = await until(() => p.evaluate(() => { const v = document.querySelector('#czViewer:not([hidden])'); const l = v && v.querySelector('.czs-line'); return l && /^Drafting the PRD/.test(l.textContent) ? { stop: !!v.querySelector('[data-czs-act="stop"][aria-label="Stop the agent"]'), chat: !!v.querySelector('[data-czs-act="talk"]'), pri: !!v.querySelector('.czs-pri') } : null; }));
     ok('W8 after Start the same card says what the agent does now, with Stop and its chat and no other verb (OvA1After)', !!s1 && s1.stop && s1.chat && !s1.pri, JSON.stringify(s1));
     const mint = await T.nonce(BASE);
     const writes = A.posts.filter((x) => /briefing-premium\/(decide|put-off)|\/api\/agent\/start/.test(x.path));

package/workspace/changelog.json

@@ -1,4 +1,60 @@
 [
+ {
+  "v": "0.499.0",
+  "at": "2026-11-03T03:25:28.533Z",
+  "f": 3,
+  "prs": [
+   {
+    "n": 1180,
+    "t": "The context meter knows the default model is 1M",
+    "s": "The context meter knows the default model is 1M",
+    "k": "fix"
+   },
+   {
+    "n": 1181,
+    "t": "`pmos initiative list` names records on a document lane",
+    "s": "Pmos initiative list names records on a document lane",
+    "k": "fix"
+   },
+   {
+    "n": 1182,
+    "t": "Claude login test passes for a signed-in new user; picker shows each login once",
+    "s": "Claude login test passes for a signed-in new user; picker shows each login once",
+    "k": "fix"
+   }
+  ]
+ },
+ {
+  "v": "0.498.0",
+  "at": "2026-11-03T02:50:09.805Z",
+  "f": 3,
+  "prs": [
+   {
+    "n": 1176,
+    "t": "Commit as the repo's own git identity; ask the PM once when it has none",
+    "s": "Commit as the repo's own git identity; ask the PM once when it has none",
+    "k": "fix"
+   },
+   {
+    "n": 1178,
+    "t": "Full task names wrap; add-task chips for stage, type, dates, owner",
+    "s": "Full task names wrap; add-task chips for stage, type, dates, owner",
+    "k": "new"
+   },
+   {
+    "n": 1179,
+    "t": "Each product repo pushes with its own GitHub login",
+    "s": "Each product repo pushes with its own GitHub login",
+    "k": "new"
+   },
+   {
+    "n": 1177,
+    "t": "A workflow routes the initiative; blocked steps ask only as ✦ proposals",
+    "s": "A workflow routes the initiative; blocked steps ask only as ✦ proposals",
+    "k": "fix"
+   }
+  ]
+ },
  {
   "v": "0.497.0",
   "at": "2026-11-03T02:04:11.405Z",

package/workspace/guide/briefing-premium.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "The premium Briefing (/premium.html)"
 description: "The Briefing page at /premium.html: the hero sentence, What you need to do, Today, the dock, and what each one reads from the repository."
-timestamp: 2026-11-02
+timestamp: 2026-11-03
 ---
 
 # The premium Briefing
@@ -133,7 +133,9 @@ The list is the console's **Needs you**: the same rows, in the same order, from
 
 Each row is a thing that waits for you. The order is fixed: blocked work first, then decisions only you can make, then what has waited longest. The first row is tagged "Do this first".
 
-A row has two lines: a verb-first title, then the subject and what the repository says is next, joined by a dot. When the line is too long it ends in "…"; the full text is in the row's dialog. "If you skip", which says what stays blocked, is in the dialog too. Press a row to open it. Detail opens first, and the conversation sits beside it. On a phone, the Detail tab is first.
+A row has two lines: a verb-first title, then the subject and what the repository says is next, joined by a dot.
+
+**Blocked work is Claude's ✦ proposal.** A blocked initiative shows as a row only when Claude can propose a way through. The title names the proposal (for example, **Draft the PRD**, **Anchor it** or **Start a prototype**), and the second line says what Claude will do: "✦ I'll draft the PRD with its done-criteria…". The initiative page and the chat show the same proposal ("Also waiting on you: ✦ Draft the PRD · Review"), not a question. Press the proposal to approve it, and Claude starts an agent session that does it. Two blocks are never a row: routing, because the initiative's workflow routes it, and an order violation in git history, which no draft can fix. When the line is too long it ends in "…"; the full text is in the row's dialog. "If you skip", which says what stays blocked, is in the dialog too. Press a row to open it. Detail opens first, and the conversation sits beside it. On a phone, the Detail tab is first.
 
 The header counts "N of M done". A row counts as done when the record behind it changes, so a row clears by itself. Nothing on this page presses Done for you. The count starts again each day and is kept on this device.
 

package/workspace/guide/claude-proposes.md

@@ -53,7 +53,7 @@ Press the ✦ to open "Claude proposes" in the Viewer. The groups come in this o
 
 In the pill menu on an initiative's row, a session that is idle and safe to close is light blue. Its line starts with ✦ and says why, and its ✓ closes it. An idle session that is not safe has no ✦ and no ✓. Its line says what holds it, such as "3 files not committed".
 
-Each session shows how full its context window is, as a small pie in the pill list, the chat header, the phone top bar and the Live pill. The pie shows from 50% (grey). It turns amber from 70% and red from 90%. Hover it to see the tokens used, such as "156k of 200k used · last turn 10:12". The window is 1M when the session runs a 1M model, else 200k. From 70%, when it is your turn, Claude proposes Compact: the row's ✦ line says so, and its ✓ types /compact into the session. The chat shows the same offer as a chip. A session that is safe to close shows that ✦ instead. ✕ hides the Compact offer until the context is 10 points fuller.
+Each session shows how full its context window is, as a small pie in the pill list, the chat header, the phone top bar and the Live pill. The pie shows from 50% (grey). It turns amber from 70% and red from 90%. Hover it to see the tokens used, such as "156k of 200k used · last turn 10:12". The window is 1M when the session runs a 1M model, else 200k. Claude Code's default model, Opus 5.5, is a 1M model, so a session you start without choosing a model has a 1M window. If CLAUDE_CODE_DISABLE_1M_CONTEXT is set, the window is 200k. From 70%, when it is your turn, Claude proposes Compact: the row's ✦ line says so, and its ✓ types /compact into the session. The chat shows the same offer as a chip. A session that is safe to close shows that ✦ instead. ✕ hides the Compact offer until the context is 10 points fuller.
 
 ✓ in the header keeps everything shown. Each proposal has its own ✓ and ✕, and ⌄ shows its rows. ✕ on a row leaves it out of that group for good, with Undo on the row. One toast says what was placed, with Undo. History lists each approval with its own Undo. An initiative that was started stays when you undo: close it on the Board.
 

package/workspace/guide/home.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Home (/premium.html) and the designed features"
 description: "Home in the Agreed design: the list grouped by product, the Viewer, the place menu, Your day and its New for you fold, Search, and the initiative, meeting, report, Board and Insights features designed after it."
-timestamp: 2026-11-01
+timestamp: 2026-11-03
 ---
 
 # Home
@@ -103,8 +103,8 @@ Press an initiative's name in the list, or open `?ini=<id>`. The list stays as i
 - **Set a Jira ticket's dates.** Press the dates of a Jira ticket in the List, or drag its bar on the Timeline, as you do for a task. PMOS keeps the start and due days and shows them in place of the sprint end. Jira does not change. The status and the name stay Jira's.
 - **Tasks** show one row (one group) for each stage of the workflow, in order. Finished stages and later stages are never merged into one row; they start folded, and the current stage and any stage with a late task start open.
 - **Change a task where it is.** In the List, press a task's name. The row opens in place: change the name (Enter saves), the status, and the dates. Only one row is open at a time. Esc closes it. The ⋯ after the dates has **Milestone** (or **Make it a plain task**), **Move to a stage**, **Open the task card** and **Delete task**. A milestone has one date: its due day. Each change shows **Undo**.
-- In the List, a row shows the dates at the right. On a phone, it shows only the due day. A task with no dates shows no date; open the row to set them.
-- **Add a task to a stage.** Press **+** on an open stage. The field opens at the top of that stage. Enter adds the task and keeps the field open for the next one. **Dates** is optional. Esc closes the field.
+- In the List, a task's full name always shows: a long name wraps onto more lines. A short prefix such as "Bus shelter:" stays in the name, in grey. The dates show at the right. In a narrow panel or on a phone, the dates show under the name. A task with no dates shows no date; open the row to set them.
+- **Add a task to a stage.** Press **+** on an open stage. The field opens at the top of that stage, with one row of chips under it. **Stage** is the stage you pressed + on; press it to pick another stage of the workflow. **Task** can change to **Milestone**: the box becomes ◇ and **Date** takes one day. **Dates** and **Owner** are optional; with no owner, the task is yours. Enter adds the task and keeps the field open for the next one. Esc closes the field.
 - **Move a task between stages.** On a computer, drag the grip at the left of a row. On a phone, press and hold the task's name, then drag. Drop it on a stage name to put it last in that stage, or between two rows to put it there. The status and the dates do not change. The message shows **Undo**.
 - A linked Jira ticket opens in place too. Its name and status stay Jira's ("In Progress in Jira · read 4 min ago"). Its dates can change, and it can be a milestone. It has no **Delete**.
 - **Delete a task.** Press the caret under a task's box (on a phone, press and hold the box) and press the trash at the end of the status picker. The task goes at once and the message shows **Undo**. In the Task Viewer, the trash is the last icon of the Status row, and **Delete** is the last entry of its ⋯ menu. You can delete every PMOS task, also a task that Claude planned in the breakdown and a task that a stage's To finish list made. A deleted To finish task does not come back when the stage is read again or when the initiative moves back to that stage. A Jira ticket has no Delete: change it in Jira. A task deleted in a draft leaves only the draft.
@@ -182,7 +182,7 @@ There is no My work page. The list on Home is your list:
 - **One chat box.** Every conversation has the same box: **+** (attach a file, notes, the terminal, and **Link to an initiative** for a loose chat), **/** for commands, **@** inside an initiative, the To or In chip, the mic, and Send. A chat opens at its newest message.
 - **A session's terminal.** **Watch its terminal** in **+**, or a session row such as **Claude sign-in**, opens the session's terminal in the Viewer. While the session runs, it is a real terminal: type in it to answer Claude or paste a code. When the session has ended, the Viewer shows it read only and says so.
 - **Setting up your first project opens by itself** until a registered folder holds an initiative or setup has finished. The `PMOS` folder that the one-line installer makes holds no initiative yet, so a new user who opens PMOS from the Start menu or the Dock still gets the setup conversation, not an empty Home.
-- **Signing in to Claude when you set up your first project.** If the login you choose is signed in already, PMOS does not open a terminal. It tests the login at once. Otherwise PMOS runs `claude auth login`: Claude opens your browser to sign in, and the terminal under the question shows only Claude's request for a code, if it needs one. Claude's theme and trust-this-folder screens do not appear. When the sign-in ends, PMOS tests the login by itself. **The Claude login on this computer** is the login your usual terminal uses (`~/.claude.json`); PMOS no longer points it at a different file.
+- **Signing in to Claude when you set up your first project.** If the login you choose is signed in already, PMOS does not open a terminal. It tests the login at once. Otherwise PMOS runs `claude auth login`: Claude opens your browser to sign in, and the terminal under the question shows only Claude's request for a code, if it needs one. Claude's theme and trust-this-folder screens do not appear. When the sign-in ends, PMOS tests the login by itself. **The Claude login on this computer** is the login your usual terminal uses (`~/.claude.json`); PMOS no longer points it at a different file. You choose between two logins only: **The Claude login on this computer** and **A separate login just for PMOS**. The test passes for a login that works in your terminal. Claude updates its own files when it runs, and the test does not count that as a changed setup.
 - **Documents not written yet.** A document that does not exist yet shows **Draft it**, in its stage or ahead of it. The agent writes a draft. Nothing is issued until you read it.
 - **Meeting notes.** A decision, to-do or question that the notes caught is not a fact until you confirm it in the meeting's Replay. Home, Your day and the evening recap do not count unconfirmed points.
 

package/workspace/guide/launcher.md

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "Start the workspace without a terminal"
-timestamp: 2026-10-30
+timestamp: 2026-11-03
 ---
 
 # Start the workspace without a terminal
@@ -31,3 +31,9 @@ Type `pmos launcher off`. This removes only launcher files that PMOS owns. It le
 ## Limits
 
 The login item starts the server once at login. Open the app if the server stops. Login does not enable remote access. Mac and Linux launcher output goes to `launcher.log` in the runtime state folder. Windows launchers run without a command window and use the server's normal logs.
+
+## Choose which git identity and GitHub login a repository uses
+
+Some computers have no global git name and email, so each repository keeps its own. A computer can also have more than one GitHub login, and a private repository of one login is not found by the other. PMOS does not choose for you, because you can use a different identity and login for each product. When a repository has none, Claude asks you once and offers the ones from your other repositories.
+
+Type `pmos git-identity` in the repository to see the identity it commits as and the GitHub login it pushes with. When one is missing, the result lists the ones your other repositories use. To save your choice for this repository only, type `pmos git-identity set --name "Your Name" --email you@example.com --login your-github-login`. To save only the login, type `pmos git-identity set --login your-github-login`. After that, `git push` in the repository uses that login, whichever login `gh` has active. Your global git settings do not change.

package/workspace/lib/briefing-premium.js

@@ -54,8 +54,32 @@ const STEP = {
   spec: { title: 'Put the spec ahead of the build', skip: 'the build stays ahead of the spec, so the order check keeps failing.' },
   contract: { title: 'Agree the contract', skip: 'the contract stays unagreed, so the run has no done-criteria to check.' },
   anchor: { title: 'Anchor the initiative', skip: 'the initiative stays unanchored, and unanchored work is rejected.' },
-  route: { title: 'Route the initiative', skip: 'the initiative has no lane, so no lane rule can run.' },
+  route: { title: 'Route the initiative', skip: 'the initiative has no workflow, so its stages cannot run.' },
 };
+
+/* What Claude proposes for a blocked step (batch 25 item 6). A blocked step reaches the PM only as a ✦ proposal: what Claude will do, in
+ * one sentence, that the PM approves (the Start write opens the agent session that does it). A step Claude cannot move by itself is not
+ * an ask: route (the initiative's workflow routes it, scripts/workflow-state.js), and an order violation (git history; no draft fixes it).
+ * `what` is the agent's task and starts with the verb the press names (pm/home-need.js plainStep makes the label from it).
+ * → { label, say, what } | null */
+const PROPOSE = {
+  route: () => null,
+  anchor: (st) => (/only the PM adds/.test(st.next || '')
+    ? { label: 'Anchor it again', say: 'I’ll anchor it again to a goal or health budget you already have, and say which and why.', what: 'anchor it again to a KR or health budget the OKR documents already declare, set parent_kr in the record, and say which and why' }
+    : { label: 'Anchor it', say: 'I’ll pick the goal it moves from your goals and add it as its anchor, and say which and why.', what: 'anchor it to the KR or health budget it moves, from the OKR documents: set parent_kr in the record and say which and why' }),
+  prototype: (st) => (/cannot follow it/.test(st.next || '') ? null
+    : /prototype lane first/.test(st.next || '')
+      ? { label: 'Start a prototype', say: 'I’ll start a prototype: a quick brief and two or three specimens you can look at.', what: 'start a prototype with a quick brief and two or three divergent specimens (skills/core/prototype.skill), then set predecessor in the record' }
+      : { label: 'Link its prototype', say: 'I’ll link it to its prototype, or start one if there is none.', what: 'link its prototype by setting predecessor in the record to the prototype initiative, or start a prototype if there is none' }),
+  spec: (st) => (/^O[12]$/.test(st.code || st.rule || '') || /earlier commit than the build/.test(st.next || '') ? null
+    : /intent/.test(st.next || '')
+      ? { label: 'Draft the intent', say: 'I’ll write the one-paragraph intent from what the initiative already says.', what: 'draft the one-paragraph intent from what the initiative already says and put it in the record\'s status' }
+      : /rubric/.test(st.next || '')
+        ? { label: 'Draft the rubric', say: 'I’ll draft the done-criteria rubric from the PRD, for you to review.', what: 'draft the rubric from the PRD (skills/core/eval-rubric.skill), then set rubric_path' }
+        : { label: 'Draft the PRD', say: 'I’ll draft the PRD with its done-criteria from what the initiative already says, for you to review.', what: 'draft the PRD with its done-criteria (skills/core/prd.skill) from what the initiative already says, then set prd_path' }),
+  contract: () => ({ label: 'Draft the contract', say: 'I’ll draft the done-criteria and how we test them, for you to approve.', what: 'draft the contract with its done-criteria and test method, for the PM to approve, and record it in the runs ledger' }),
+};
+const proposalOf = (st) => { try { return PROPOSE[st.key] ? PROPOSE[st.key](st) : null; } catch { return null; } };
 const stepOf = (key) => STEP[key] || { title: 'Unblock the ' + key + ' step', skip: 'the ' + key + ' step stays blocked.' };
 
 /* The options a decision offers. They name the choices the repository's own rules give (D41 for a tripwire, D60 for a prototype); none is marked
@@ -99,26 +123,28 @@ function blockedRows(f) {
   for (const i of f.initiatives) {
     try {
     if (!live(i)) continue;
-    const st = (i.steps || []).find((s) => s.status === 'blocked' && s.blocking !== false) || (i.steps || []).find((s) => s.status === 'blocked');
+    // the first blocked step Claude can propose a way through, the blocking ones first; a step with no proposal is not an ask
+    const blocked = (i.steps || []).filter((s) => s.status === 'blocked');
+    const st = [...blocked.filter((s) => s.blocking !== false), ...blocked.filter((s) => s.blocking === false)].find((s) => proposalOf(s));
     if (!st) continue;
-    const m = stepOf(st.key);
+    const m = stepOf(st.key), pr = proposalOf(st);
     out.push({
-      kind: 'blocked', key: 'blocked:' + i.id, title: m.title, subject: clip(i.title, 90),
-      prepared: st.next ? 'Next step: ' + clip(st.next, 140) : 'No next step is on record.',
+      kind: 'blocked', key: 'blocked:' + i.id, title: pr.label, subject: clip(i.title, 90),
+      prepared: '✦ ' + pr.say, propose: { label: pr.label, say: pr.say },
       skip: 'If you skip: ' + m.skip,
       from: [i.id], stepKey: st.key, order: [-(i.blockers || []).length, i.id],
-      detail: { id: i.id, step: st.key, rule: st.rule || null, next: st.next == null ? null : String(st.next), record: i.record || null, ...whoOf(i) },
+      detail: { id: i.id, step: st.key, rule: st.rule || null, next: pr.what, record: i.record || null, ...whoOf(i) },
       dialog: tryD(() => ({
         eye: 'Unblock', logTitle: 'Read from the repository',
         log: ['Read the initiative record' + (i.record ? ' (' + i.record + ')' : ''), 'Ran the workflow order rules on it', 'Found the step that blocks it: ' + st.key],
         say: i.id + ' is blocked at the ' + st.key + ' step.' + (st.rule ? ' The rule it does not meet: ' + clip(st.rule, 200) : ''),
         hold: START_NOTE, head: 'The way through',
         facts: [['Blocked at', st.key], ['Initiative', i.id], ['The check', st.rule && clip(st.rule, 200)], ['Record', i.record]].filter((x) => x[1]),
-        opts: st.next ? [{ k: 'next', t: clip(st.next[0].toUpperCase() + st.next.slice(1), 140), d: 'The next step on record.' }] : [],
-        sel: st.next ? 'next' : null,
-        nodef: st.next ? '' : 'No next step is on record.',
-        write: st.next ? { kind: 'start', initiative: i.id, what: clip(st.next, 200), ...(i.ws ? { ws: i.ws } : {}) } : undefined,
-        prim: { next: 'Start: ' + clip(st.next || '', 40) },
+        opts: [{ k: 'next', t: pr.label, d: '✦ ' + pr.say }],
+        sel: 'next',
+        nodef: '',
+        write: { kind: 'start', initiative: i.id, what: clip(pr.what, 200), ...(i.ws ? { ws: i.ws } : {}) },
+        prim: { next: '✦ ' + pr.label },
         pane: { label: 'Initiative record', file: i.record || i.id, h: clip(i.title, 90), rows: fmRows(i.fm) },
       })),
     });
@@ -528,7 +554,7 @@ function goalOf(A, raw) {
 async function readInitiatives({ root, engine }) {
   const wf = engine ? await run(process.execPath, [engine, '--json', '--root', root], { cwd: root, nice: 10 }) : null;
   let list;
-  try { list = JSON.parse(wf).map((x) => ({ id: x.id, title: x.title, lane: x.lane, stage: x.stage, accepted: !!x.accepted, stopped: !!x.stopped, legacy: !!x.legacy, anchor: x.anchor, last_activity: x.last_activity, blockers: x.blockers || [], next: x.next, record: x.record, steps: (x.steps || []).map((s) => ({ key: s.key, status: s.status, next: s.next, rule: (s.basis && s.basis.rule) || s.rule, blocking: s.blocking })) })); } catch { return null; }
+  try { list = JSON.parse(wf).map((x) => ({ id: x.id, title: x.title, lane: x.lane, stage: x.stage, accepted: !!x.accepted, stopped: !!x.stopped, legacy: !!x.legacy, anchor: x.anchor, last_activity: x.last_activity, blockers: x.blockers || [], next: x.next, record: x.record, steps: (x.steps || []).map((s) => ({ key: s.key, status: s.status, next: s.next, rule: (s.basis && s.basis.rule) || s.rule, code: s.rule || null, blocking: s.blocking })) })); } catch { return null; }
   let A = null;
   try { A = require('./initiative-rows.js').anchorsOf(root); } catch { A = null; }
   for (const i of list) {

package/workspace/lib/claude-readiness.js

@@ -8,6 +8,7 @@ const cp = require('child_process');
 const win = require('./win-command');
 const claudeHome = require('./claude-home');
 const DEFAULT = '__default__';
+const OWN_ID = require('./own-profile').ID;   // PMOS's separate login (lib/own-profile.js)
 const PROMPT = 'Reply with exactly PMOS_READY. Do not use tools.';
 const FLAGS = ['--safe-mode', '--tools', '--strict-mcp-config', '--mcp-config', '--disable-slash-commands', '--no-session-persistence', '--output-format'];
 const MESSAGES = {
@@ -38,7 +39,15 @@ function executable(env) {
   const file = String(env.PATH || '').split(path.delimiter).map(d => path.join(d, 'claude')).find(f => { try { fs.accessSync(f, fs.constants.X_OK); return fs.statSync(f).isFile(); } catch { return false; } });
   return { file: file || 'claude', prefix: [] };
 }
-function stamp(f) { try { const s = fs.statSync(f); return [s.mtimeMs, s.size]; } catch { return null; } }
+// The parts of settings.json that decide which account Claude uses: only these are fingerprinted, as a hash, never returned.
+const AUTH_ENV = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'CLAUDE_CODE_USE_BEDROCK', 'CLAUDE_CODE_USE_VERTEX', 'CLAUDE_CODE_USE_FOUNDRY'];
+function settingsAuth(f) {
+  let j; try { j = JSON.parse(fs.readFileSync(f, 'utf8')); } catch (e) { return e && e.code === 'ENOENT' ? null : 'unreadable'; }
+  if (!j || typeof j !== 'object') return 'unreadable';
+  const env = j.env && typeof j.env === 'object' ? j.env : {};
+  const picked = { apiKeyHelper: j.apiKeyHelper || '', forceLoginMethod: j.forceLoginMethod || '', forceLoginOrgUUID: j.forceLoginOrgUUID || '', env: AUTH_ENV.map(k => [k, env[k] || '']) };
+  return crypto.createHash('sha256').update(JSON.stringify(picked)).digest('hex');
+}
 function atomic(file, value) {
   fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
   if (fs.existsSync(file) && fs.lstatSync(file).isSymbolicLink()) throw new Error('symlink');
@@ -56,18 +65,20 @@ function create({ stateDir, home = os.homedir(), readProfiles, readPrefs, savePr
     if (typeof id !== 'string' || !/^[a-zA-Z0-9_.-]{1,80}$/.test(id)) return null;
     // The usual login is Claude with no CLAUDE_CONFIG_DIR at all, unless the PM's own environment sets one. Naming ~/.claude
     // here made Claude read ~/.claude/.claude.json and miss the login in ~/.claude.json (lib/claude-home.js).
-    if (id === DEFAULT) { const inherited = envFor(null).CLAUDE_CONFIG_DIR; return { id, label: 'My usual Claude login', env: inherited ? { CLAUDE_CONFIG_DIR: path.resolve(inherited) } : {} }; }
+    if (id === DEFAULT) { const inherited = envFor(null).CLAUDE_CONFIG_DIR; return { id, label: 'The Claude login on this computer', env: inherited ? { CLAUDE_CONFIG_DIR: path.resolve(inherited) } : {} }; }
     return (readProfiles().profiles || []).find(p => p.id === id) || null;
   }
   function binding(p) {
     const env = envFor(p);
     const command = resolveExecutable(env);
     const dir = path.resolve(env.CLAUDE_CONFIG_DIR || path.join(home, '.claude'));
-    const authNames = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'CLAUDE_CODE_USE_BEDROCK', 'CLAUDE_CODE_USE_VERTEX', 'CLAUDE_CODE_USE_FOUNDRY'];
     // the env as it is applied (a CLAUDE_CONFIG_DIR that names only ~/.claude sets nothing), so an old descriptor and a new one match
     const applied = claudeHome.overlay(p.env, { home, inherited: envFor(null).CLAUDE_CONFIG_DIR || '' });
-    const input = { command, executable: stamp(command.file), env: Object.entries(applied).sort(), dir,
-      auth: authNames.map(k => [k, env[k] || '']), config: [path.join(dir, 'settings.json'), claudeHome.configFile(env, home), path.join(dir, '.credentials.json')].map(stamp) };
+    // Only what decides the login: the command, the env, the folder and the auth settings. NOT the timestamps of ~/.claude.json,
+    // .credentials.json or the executable: every `claude -p` rewrites ~/.claude.json and may refresh its token, and Claude Code
+    // updates itself, so those made every check end "The Claude setup changed during the check" (bug 2026-11-03, new user).
+    const input = { command: { file: command.file, prefix: command.prefix }, env: Object.entries(applied).sort(), dir,
+      auth: AUTH_ENV.map(k => [k, env[k] || '']), settings: settingsAuth(path.join(dir, 'settings.json')) };
     return { env, command, fingerprint: crypto.createHash('sha256').update(JSON.stringify(input)).digest('hex') };
   }
   // The sentence for a state. A signed-out or unverified login names the login it checked and its folder, because signing in to another
@@ -88,9 +99,21 @@ function create({ stateDir, home = os.homedir(), readProfiles, readPrefs, savePr
     const state = valid ? r.state : 'unchecked';
     return { state, message: say(state, p), profile: id, label: p.label || id, checked_at: r && r.checked_at || null, ready: state === 'ready' && selected() === id };
   }
+  /** The logins to choose from, one row per login that really differs (bug 2026-11-03: "My usual Claude login" and "PMOS"
+   *  showed beside the two options they repeat). A profile with the same binding as the login on this computer is that login,
+   *  so it folds into it; PMOS's own profile is the "separate login" option, so it is named `own` and not listed again.
+   *  `alias` maps a folded id to the row that shows it. */
   function list() {
     const read = readProfiles();
-    return { ok: true, selected: selected(), status: status(), profiles: [candidate(DEFAULT), ...(read.profiles || [])].map(p => ({ id: p.id, label: p.label || p.id })), broken: (read.broken || []).map(b => ({ file: b.file })), discovery_failed: read.ok === false };
+    const usual = candidate(DEFAULT), usualPrint = binding(usual).fingerprint;
+    const alias = {}, rows = [{ id: DEFAULT, label: usual.label }];
+    let own = null;
+    for (const p of read.profiles || []) {
+      if (p.id === OWN_ID) { own = p.id; continue; }
+      let same = false; try { same = binding(p).fingerprint === usualPrint; } catch {}
+      if (same) alias[p.id] = DEFAULT; else rows.push({ id: p.id, label: p.label || p.id });
+    }
+    return { ok: true, selected: selected(), status: status(), profiles: rows, alias, own, broken: (read.broken || []).map(b => ({ file: b.file })), discovery_failed: read.ok === false };
   }
   function pinDefault(p) {
     if (p.id !== DEFAULT) return p.id;