bareloop 0.46.0 → 0.46.1

package/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to bareloop are documented here. Format:
 [SemVer](https://semver.org/spec/v2.0.0.html). Pre-1.0: **minor** = a ladder rung or
 feature lands, **patch** = docs, fixes, scaffolding.
 
+## [0.46.1] - 2026-10-24
+
+### Fixed
+
+- **A blank Base URL in the New job readiness line reads "Type a Base URL."** It showed `[✗] no-base-url — may be flaky, not blocking`; it now shows the server's own sentence (owned by `src/modellist.js`).
+
+- **The Audit learnings header counts distinct hints across the draft and the first replan.** It counted only the draft block (3 at draft, 5 at replan read "3 hints"). A hint handed at both draft and replan counts once (identity = ledger row id).
+
+- **A scheduled fire refused at the run-start fetch shows its status word on the schedule card.** The card read `last 10:30 · run-4` with no word because the run list's events were not passed to `summarizeRow`; the refused row now carries its `failed` status.
+
+- **Every drafting stop reads in plain words from one table.** `confirm-abandoned` and `confirm-restart` printed `Stopped: <code>`, and a code outside an 8-entry table fell back to `Drafting stopped (<code>).`. `STOP_HEADS` (with `STOP_TODO` where "draft again" is wrong) in `src/authorreadout.js` now covers about 20 stop codes and `authorsession` routes every stop through `draftStopText`; an unknown code gets a generic sentence, never the raw code. The confirm-abandoned stop now ends "nothing more was spent" (it promised a figure that reads "unknown" when spend is incomplete). Wording signed by hamr 2026-10-23.
+
+- **One `isReusableGreen` decides every Reuse-eligibility check.** The picker, `getStartFrom`, the start gate and prefill flag in `authorroutes`, and the Ended block each spelled it their own way, and the Ended block still treated an already-green as not reusable. An already-green now ends "Nothing to do." like a green, and a scheduled already-green run is held for Accept like a green. Scheduling itself still needs a real green (`greenFor` in `src/schedules.js` is unchanged).
+
+- **A watched-folder file whose name holds a line break or ends in whitespace is refused.** A newline in the name became extra Inputs lines in the fire's card text, and a trailing space trimmed to a path that does not exist. `perFireSpec` now refuses it through the ordinary refused-fire path ("Rename the file. Nothing started."; one refused row, no session) and never rewrites the name. A leading space is harmless and not refused.
+
+- **`scripts/hermetic.mjs` refuses a test path that does not exist.** A mistyped path was skipped and the run exited 0, so a green count could miss a file. A path-looking argument that does not exist now exits 1 with a plain message and runs nothing; `npm test` with no arguments, flags and globs are untouched. The value of a value-taking flag (`--test-name-pattern "a/b"`, `--test-reporter`, `--import`, `-r`, ...) is never checked as a path; a boolean flag followed by a mistyped path is still refused.
+
+### Changed
+
+- **Linear-time trailing trims in the reuse-preprobe `normPath` (`scripts/`, not shipped).** The `[.,;:)\]}'"`]+$` and `\/+$` trims were the quadratic class (about 1.2 s CPU on 30000 trailing dots); same results on 1.5M random strings, 0 mismatches.
+
+- **`stageQuestionText`'s JSDoc now sits on the function, not on `GENRE_WHAT`.** Comments and declaration order only.
+
+- **Tests strengthened (test-only, no source change).** A seeded differential test pins the linear `stringLiteralsOf` and `staticImportsOf` scanners against the old regexes; `buildCards`' card-level secret mask, the judged-strike trend number (read from the real `runDeclaredStages`), the Revise-at-menu spend figure (waits for the unwind, runs a second draft), and money-as-read in symbol-first and far-apart layouts each have a test that fails on a mutant.
+
 ## [0.46.0] - 2026-10-23
 
 ### Added

package/bareloop.context.md

@@ -627,7 +627,7 @@ a step, or test it without a provider.
 `error: 'truncated:max_tokens'`, neutral `stopReason: 'max_tokens'`) is a FAILED TRY on `askStructured`'s retry ladder with the
 reason "the AI's answer was cut off at the output limit" (`axis: 'output-truncated'`) — NOT `provider-red`; all attempts stay
 booked, `AUTHOR_MAX_TOKENS` is never raised, and only a real transport failure stays `provider-red`. `draftStopText`
-(`src/authorreadout.js`) words any drafting stop that has no wording of its own; the panel puts it on the failed step. (2)
+(`src/authorreadout.js`) words EVERY drafting stop from one table (`STOP_HEADS` for the sentence, `STOP_TODO` where "draft again" is the wrong advice; a code the table lacks reads one generic sentence, never the raw code); the panel puts it on the failed step. (2)
 `authorClose({ offerQuestions })` (default `false`; the CLI never sets it) offers the optional `questions` property on the LAST
 try of the full ladder only, and only when the two tries before it both failed — validation OR the seed read (hamr ruled 2026-10-10; this DIFFERS
 from fwdloop's validation-only rule): a seed-read failure is a work stage that instrument-stopped or a close with no work stage
@@ -3074,7 +3074,9 @@ Enforcement is **local only** — wired into `npm test` (see `package.json`'s `t
 script), never into `.github/workflows/*` (CI already runs `npm test`, so the rule is
 enforced there without an ask-first CI edit). `npm test` itself now runs `node --test`
 through `scripts/hermetic.mjs`, which strips this machine's `HOME`/git identity so a
-test that leans on either fails locally instead of only on CI (F136). The check itself lives outside the
+test that leans on either fails locally instead of only on CI (F136). It also refuses a
+test path that does not exist (`node --test` skips one silently, so a mistyped file could hide
+behind a green count); the separate value of a value-taking flag is never read as a path. The check itself lives outside the
 published package, at `scripts/prompt-commit-check.mjs` (pure decision logic in
 `scripts/promptcommitlib.mjs`, `scripts/` is not in `package.json`'s `files`, so none of
 this ships):
@@ -3889,7 +3891,7 @@ No model is called anywhere in learnings (a test walks the import closure). Pure
 - **Cards:** `buildCards({ runid, events, audit, workdir, spec, model, questions })` → `{ cards, suspect, thin, noise }`. FIXED = a check red then the same check passes later in the run; NEVER FIXED = still red at run end. Excluded and counted: noise runs (provider-red, close-crashed, worker-crash, no close spoke), CHECK-SUSPECT (a no-suppressions hit on a prose comment), TOO-THIN (no error kind and no fix files). Written files come from `attempt-diff` events and the gate audit's allow write/edit rows relative to the tree.
 - **Fold:** `cardsMatch` / `foldCards`: same job + check, a shared error kind, Jaccard >= 60% on flagged-text tokens (a fit on known cards, not a proof). Code-less cards (kind `other`) fold on the text rule alone, only when both token sets are non-empty (R1, 2026-10-23: UNTESTED on real data; the 60% was fitted on cards with codes). `kindAgrees` is the one kind test.
 - **Ledger** `<config home>/learn/ledger.json` (mode 600, atomic, secrets masked): rows `{ id, lesson, count, sample, models, workflow, place, level, trust, runIds, firstSeen, lastSeen, specHash }`, plus `pending` (held rubric cards), `suspect`, `health`. There is no check-wide set-aside (R2, 2026-10-23): a lesson seen in several jobs climbs by the climb rules and is read at its level; all-jobs hints come last. `countLedger` (+1 per run per row), `holdPending` / `releasePending` (rubric cards count only after the human Accept; `releaseRun` is called from the door's accept path), `climb` (the level of a lesson, derived at read time by `readableRows` from the rows not decayed at that moment: it can go back down when siblings age past 56 days; the file stores `workflow` only and ignores an older stored level). The ledger keeps EVERY row (nothing is deleted, no `expired` flag is stored; hamr 2026-10-23). Memory is the filter: `readableRows` / `renderHints` skip a row last seen more than 56 days ago (`isDecayed`) and a workflow row of another signed hash (`otherJobVersion`); a lesson seen again counts +1 on its old row. Old files with `status`/`expiredBy` still load; the fields are ignored and dropped at the next write.
-- **Reading:** `hintsForRun({ home, spec, specHash })` renders once at run start; `runJob(..., { learnHints: { text, ids } })` → `runPlan` hands it to the PLANNER at the draft and the first replan only, and emits a `learnings` spine record with the exact text. `renderHints(ledger, { workflow, place, specHash, now })` is the one render (this job, then this place, then all-jobs, highest count first, 2,000 characters, a hint whole or not at all; all-jobs hints last); a FIXED hint adds `What changed:` (first 3 `+`/`-` lines of the stored diff, 150 chars each, then `(+N more)`; never on NEVER FIXED) and a repeated path in a hint reads as its basename (R3, R5, 2026-10-23); the spine's recorded text is byte-equal to a fresh `renderHints(...).text` from the ledger as it stood. The Audit run detail carries `learnings` (read-only).
+- **Reading:** `hintsForRun({ home, spec, specHash })` renders once at run start; `runJob(..., { learnHints: { text, ids } })` → `runPlan` hands it to the PLANNER at the draft and the first replan only, and emits a `learnings` spine record with the exact text. `renderHints(ledger, { workflow, place, specHash, now })` is the one render (this job, then this place, then all-jobs, highest count first, 2,000 characters, a hint whole or not at all; all-jobs hints last); a FIXED hint adds `What changed:` (first 3 `+`/`-` lines of the stored diff, 150 chars each, then `(+N more)`; never on NEVER FIXED) and a repeated path in a hint reads as its basename (R3, R5, 2026-10-23); the spine's recorded text is byte-equal to a fresh `renderHints(...).text` from the ledger as it stood. The Audit run detail carries `learnings` (read-only); its header counts DISTINCT hints (the same ledger row handed at the draft and the first replan counts once).
 
 ### Settings — the keys file, `config.json`, the monthly $ limit, the Providers tab (PANEL-BUILD.md P4a, `src/keysfile.js`, `src/config.js`, `src/monthly.js`, `src/providerrows.js`, `src/panel/settingsroutes.js`)
 
@@ -3976,7 +3978,7 @@ above 0, or `null`/blank to clear) — an empty or key-less body is a `400`, nev
 only the shell holds when config already names it (`keys.<ENV>` or `models.<ENV>`; its status reads `found in shell`) — nothing is hardcoded, there is no add-row and no remove-row control. A missing `.env`
 is created (mode 600, dir 700) on the first Providers read with two comment lines and no key. A value of `null` counts as SET and means "no real key" (the provider is handed the placeholder
 `no-key-needed`, never the word `null`; the row shows `set in file`). A key whose value has a space or a line break shows `The key has a space or a line break in it. Fix it in your keys file, then
-reload keys.` Each row: the env NAME + status, an **API shape** select (Anthropic / OpenAI-compatible / Gemini), the typed **Base URL** (empty = no run, no list, `type the Base URL`), the **Old max_tokens**
+reload keys.` Each row: the env NAME + status, an **API shape** select (Anthropic / OpenAI-compatible / Gemini), the typed **Base URL** (empty = no run, no list, `type the Base URL`; the Test line reads the server's own sentence `Type a Base URL.`), the **Old max_tokens**
 tick (applies to `openai-api` only), **Tokens** (the key's spend), `[ Test ] [ ⟳ Refresh ]`, and its model lines: a **Use** tick, the model name, **In / Out $/1M** boxes, tokens (`—` when no spend row names the model).
 A listed id from Refresh is shown unticked and is not saved until touched; `+ type a model name` adds a line unticked. Saves are on change; success reads `saved — applies from the next model call`;
 every refusal is a plain sentence in `say` (`Fill both prices to tick this model.`, `Fill both price boxes or clear both.`, `A price must be a number, 0 or more.`, …). **Open keys folder** (in the KEYS strip,
@@ -4439,12 +4441,12 @@ Check what the person asked for, not what the worker chose to write. bareloop ne
 - **Only the panel fires.** `createPanelServer` runs one 500 ms unref'd scheduler (poll only, never `fs.watch`); the CLI never fires. Panel off = nothing fires; slots missed collapse to ONE catch-up (marked when more than 2 minutes late). `createPanelServer` test seams: `scheduleNow`, `schedulerIntervalMs` (0 = no timer), `sessionDeps`, `acceptWaitMs`.
 - **Files live under `<config home>/triggers/<job>/`**: `schedule.json` (the current signed schedule) and ONE append-only `ledger.jsonl` (every row carries `sig`, the spec hash it was written under). A run that a schedule started carries `trigger.json` beside its `resolved-spec.json`.
 - **Setting one is two clicks, both $0** (`POST /api/author/schedule-prepare`, then `/api/author/schedule` with the hash). It needs a real green run of the job's CURRENT workflow (a rubric job also an honoured Accept). A file trigger is for plain-files jobs only. Cancel is never refused. A reuse never clears a schedule: Reuse workflow (the one door, v1.101) keeps the origin's name while no job box is changed and switches the Job name to the next free `<base>-N` once one is; a changed job is a new workflow that needs its own green before it can be scheduled.
-- **A fire goes busy, then monthly limit, then `wouldAccept`, then the one starter** (the same session start and `signRun` as a Reuse the person clicked, with `--review-door`). Busy, monthly and refused fires consume nothing and are told once per `key|outcome|why`, so they retry. A run is busy while its pid is alive AND its process started no later than 5 s after its run row was written (a recycled pid is not that run). A run waiting at its review door is not busy.
+- **A fire goes busy, then monthly limit, then `wouldAccept`, then the one starter** (the same session start and `signRun` as a Reuse the person clicked, with `--review-door`). Busy, monthly and refused fires consume nothing and are told once per `key|outcome|why`, so they retry. A file fire whose name holds a line break or ends in whitespace is refused at `perFireSpec` (the card text is `label: value` lines, so it would read back as another Inputs line); the person is told to rename the file. A run is busy while its pid is alive AND its process started no later than 5 s after its run row was written (a recycled pid is not that run). A run waiting at its review door is not busy.
 - **An install-needed refusal backs off, then gives up.** When a fire's copy needs packages, that job's next attempt waits 1, 2, 3, 5, 8, 13, then 21 minutes (in memory: a restart begins at the first wait); a wait that would pass 60 minutes in total is not taken: the schedule writes ONE `gave-up` row and is paused (nothing fires; files still queue as `arrived`), and the job shows in Needs you with the pill `Check` (`listGaveUp`). Signing the schedule again writes `resumed` and clears it. Constants: `INSTALL_RETRY_STEPS_MS`, `INSTALL_GIVE_UP_MS` (`src/panel/schedules.js`).
 - **A scheduled green is held until accepted**: `getStartFrom` reads its outcome as `green-held` and the Reuse list skips it, until the spine holds an honoured accept.
 - **Accept** (`POST /api/runs/<id>/accept`) runs the engine's own door path (`run-u --spec <signed spec> --door <id> --decide accept --approve <hash>`): the mechanical stages re-run, a red is `door-accept-red`, the run's verdict is untouched. It shows only while `doorWaiting(events)` (`src/reviewdoor.js`) is true; the same answer fills the runs list's Needs-you `Accept`.
 - **Every word the page shows** comes from `src/schedulewords.js` (`SCHEDULE_WORDS` is the one button table the server sends).
-- **The schedule is shown on three tabs** (v1.102): the Run tab's one summary block (ENDED dated, NEXT, SCHEDULE with `last`/`next`; row and frame red when the last fire started nothing), the Job tab's Started and Schedule rows (`getRunJob`), and the Audit's own folded `schedule` section on every run of a scheduled job (v1.104: `detail.scheduleSection` `{title, sign, word, head, rows}`, drawn `[sign] word schedule · head` with the sign and word both from the status table, v1.106 Part 4; a run a cancelled schedule started keeps `detail.startedAudit`). `/api/runs` `scheduled[]` and `gaveUp[]` carry `runNo` so the small lists read `job · run-N`. `trigger.json` carries `triggerKind`, `sessionId`, `originRunid`, `sig`, `lateMs`; each signing appends a `signed` ledger row naming its origin run.
+- **The schedule is shown on three tabs** (v1.102): the Run tab's one summary block (ENDED dated, NEXT, SCHEDULE with `last`/`next`; row and frame red when the last fire started nothing; `last` wears the run's status word even for a fire refused at the run-start fetch, which has no spine, only a settled event), the Job tab's Started and Schedule rows (`getRunJob`), and the Audit's own folded `schedule` section on every run of a scheduled job (v1.104: `detail.scheduleSection` `{title, sign, word, head, rows}`, drawn `[sign] word schedule · head` with the sign and word both from the status table, v1.106 Part 4; a run a cancelled schedule started keeps `detail.startedAudit`). `/api/runs` `scheduled[]` and `gaveUp[]` carry `runNo` so the small lists read `job · run-N`. `trigger.json` carries `triggerKind`, `sessionId`, `originRunid`, `sig`, `lateMs`; each signing appends a `signed` ledger row naming its origin run.
 
 
 ## The Audit's tries, checks and answered questions (PRD v1.106 Part 5)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bareloop",
-  "version": "0.46.0",
+  "version": "0.46.1",
   "description": "Workflows that earn their own design, with receipts — agent-authored workflows for repeated, long, verifiable jobs that improve across runs under an un-gameable gate.",
   "type": "module",
   "main": "./src/index.js",

package/src/authorreadout.js

@@ -656,6 +656,50 @@ export function proposalStopText({ stop, reds, cases = null, spend = null, sourc
 /** the reason inside a `scout-absent` red's detail: `the survey is ABSENT (<reason>) — an absent facts object ...` (src/authorflow.js) */
 const SCOUT_REASON_RE = /^the survey is [^(]*\((.*)\) — an absent facts/s;
 
+/**
+ * ONE owner of the plain sentence for every drafting stop code (hamr 2026-10-09: "a user should get a reason they can
+ * understand and do something about"). What happened; `STOP_TODO` below overrides the default "draft again" where that is wrong.
+ * Used by `draftStopText` for every stop the panel and the CLI show; a code not listed reads `STOP_UNKNOWN`, never the raw code.
+ * @type {Record<string, string>}
+ */
+export const STOP_HEADS = {
+  'provider-red': 'The AI provider failed before a usable plan came back — a connection or service fault, not a problem with your job.',
+  'artifact-red': 'The AI answered, but its answer could not be used as a plan.',
+  'cap-halt': 'Drafting stopped on your cost cap.',
+  'pricing-red': 'Drafting stopped: the cost of a call could not be priced, so the cap cannot be enforced.',
+  'max-revisions': 'The AI used all its tries without a plan that passed the checks.',
+  precheck: 'Drafting stopped before any call: something it needs was missing.',
+  unchanged: 'Drafting stopped: the AI sent the same plan twice.',
+  'scout-absent': 'Drafting stopped: the first look at your repo or input did not complete.',
+  refused: 'Drafting stopped: something in the job or its inputs is not allowed.',
+  'interview-incomplete': 'Drafting stopped: the job form was not complete, so there was nothing to draft from.',
+  'calibration-missing': 'Drafting stopped: the practice cases that prove the rubric were missing, so the check could not be trusted.',
+  'invalid-set': 'Drafting stopped: the rubric and its practice cases do not fit together, so they could not be graded.',
+  'broken-close': 'Drafting stopped: the final check the model wrote could not run.',
+  'listing-absent': 'Drafting stopped: the list of your files was not available, so the checks could not name any.',
+  'listing-conflict': 'Drafting stopped: the list of your files was given twice and the two did not agree.',
+  'listing-unreadable': 'Drafting stopped: your repo\'s file list could not be read.',
+  'non-code-source': 'Drafting stopped: this source is not a code repo, and this kind of job only works on code.',
+  'authoring-failed': 'Drafting stopped for a reason that was not recorded.',
+  'confirm-abandoned': 'Drafting stopped: the confirm step ended before you answered, so nothing was signed.',
+  'confirm-restart': 'Drafting stopped: you chose to start over, so nothing was signed.',
+};
+
+/** the "What to do" for the stops where "draft again" is not the right advice */
+const STOP_TODO = /** @type {Record<string, string>} */ ({
+  refused: 'change what the message above names, then draft again.',
+  'interview-incomplete': 'fill in every line of the job form, then draft again.',
+  'calibration-missing': 'draft again; if it stops the same way twice, make your PASS/FAIL examples more concrete.',
+  'invalid-set': 'draft again; if it stops the same way twice, make your PASS/FAIL examples more concrete.',
+  'non-code-source': 'point the job at a code repo, or use a folder or file job instead.',
+  'listing-unreadable': 'check the repo is a readable git repo with at least one commit, then draft again.',
+  'confirm-abandoned': 'start a new draft when you are ready; nothing more was spent.',
+  'confirm-restart': 'change the answers you want and start the draft again.',
+});
+
+/** a stop code this table does not know: still plain words, never the code */
+const STOP_UNKNOWN = 'Drafting stopped for a reason this screen has no wording for.';
+
 /**
  * @param {{stop: string, reds?: PlainRed[]|null, refusal?: {detail?: string}|null,
  *   spend?: {knownUsd?: number|null, spendComplete?: boolean|null}|null, wholeJob?: boolean}} o `wholeJob` - a rubric job on the person's
@@ -674,23 +718,13 @@ export function draftStopText({ stop, reds = null, refusal = null, spend = null,
     const detail = (Array.isArray(reds) ? reds : []).find((r) => r?.code === 'fit-stopped')?.detail;
     if (detail) return `Stopped before drafting: the page does not show everything the job asks for: ${redactSecrets(String(detail))}. Change the job or the page and draft again. Spent so far: ${spent ?? 'unknown'}.`;
   }
-  /** @type {Record<string, string>} */
-  const heads = {
-    'provider-red': 'The AI provider failed before a usable plan came back — a connection or service fault, not a problem with your job.',
-    'artifact-red': 'The AI answered, but its answer could not be used as a plan.',
-    'cap-halt': 'Drafting stopped on your cost cap.',
-    'pricing-red': 'Drafting stopped: the cost of a call could not be priced, so the cap cannot be enforced.',
-    'max-revisions': 'The AI used all its tries without a plan that passed the checks.',
-    precheck: 'Drafting stopped before any call: something it needs was missing.',
-    unchanged: 'Drafting stopped: the AI sent the same plan twice.',
-    'scout-absent': 'Drafting stopped: the first look at your repo or input did not complete.',
-  };
+  const heads = STOP_HEADS;
   const redList = Array.isArray(reds) ? reds : [];
   // F217: the first look at the repo failing (a dropped connection, a timeout) arrives as a `precheck` stop with a
   // `scout-absent` red. That is NOT "something it needs was missing", and its reason sits past the 60-char quote bound
   // behind a fixed lead-in, so the person saw neither. Word it as the scout's stop and quote the reason in full (scrubbed).
   const scoutRed = stop === 'precheck' ? redList.find((r) => r?.code === 'scout-absent') : undefined;
-  const head = scoutRed ? heads['scout-absent'] : (heads[stop] ?? `Drafting stopped (${safeText(stop)}).`);
+  const head = scoutRed ? heads['scout-absent'] : (Object.hasOwn(heads, stop) ? heads[stop] : STOP_UNKNOWN);
   /** @type {string[]} */
   const said = scoutRed
     ? [SCOUT_REASON_RE.exec(String(scoutRed.detail ?? ''))?.[1]
@@ -705,6 +739,7 @@ export function draftStopText({ stop, reds = null, refusal = null, spend = null,
   }
   lines.push(stop === 'cap-halt' || stop === 'pricing-red'
     ? 'What to do: raise the cap or fix the price in Settings, then draft again.'
+    : Object.hasOwn(STOP_TODO, stop) ? `What to do: ${STOP_TODO[stop]}`
     : (wholeJob ? 'What to do: review the whole job - every line and its ~ rules, and the inputs - and submit it again.' : 'What to do: draft again.'));
   return lines.join('\n');
 }

package/src/panel/authorroutes.js

@@ -25,6 +25,7 @@ import { readFileSync } from 'node:fs';
 import { planMatchesClose } from '../rubricstep.js';
 import { createSession, validateJobCard, validateReuseCard, jobBoxesChanged, buildReuseSpec, cardFields, nextFreeJobName, startDestinationProblem, STEP_LABELS } from './authorsession.js';
 import { parseInputs } from '../jobblock.js';
+import { isReusableGreen } from './status.js';
 import { proveInputFiles, looksLikeRubricInput, webFetchState } from '../source.js';
 import { validateJob } from '../job.js';
 
@@ -282,7 +283,7 @@ export function createAuthorRoutes(opts) {
         ok: true, origin: pre.origin, card, from: pre.from, note: pre.note,
         // ONE door (v1.101): `green` = the origin earned a real green (an imported job counts), so an unchanged job reuses the signed plan;
         // `nextName` = the Job name box once a job box changes (the box shows the origin's name until then). Nothing is locked.
-        green: pre.origin.importId !== undefined || pre.outcome === 'green' || pre.outcome === 'already-green',
+        green: pre.origin.importId !== undefined || isReusableGreen(pre.outcome),
         nextName: nextFreeJobName(pre.origin.job, opts.runJobNames ? opts.runJobNames() : [], { jobsDir: opts.jobsDir }),
         specHash: pre.specHash, workflowKey: pre.workflowKey, trackRecord: pre.trackRecord,
         line: pre.line, specNamesModel: pre.specNamesModel, specWorker: pre.specWorker,
@@ -357,7 +358,7 @@ export function createAuthorRoutes(opts) {
           // a scheduled run's green waits for the person's Accept (quarantine): its plan is neither reused nor re-drafted until then
           if (pre.outcome === 'green-held') { send(409, { ok: false, error: 'This run was started by a schedule and is waiting for your Accept. Accept it first, then it can be reused.' }); return true; }
           card.jobName = pre.origin.job; // an unchanged job keeps its name; a typed one is ignored
-          if (fromImport !== null || pre.outcome === 'green' || pre.outcome === 'already-green') {
+          if (fromImport !== null || isReusableGreen(pre.outcome)) {
             const rv = validateReuseCard(card, { rows });
             if (!rv.ok) { send(400, { ok: false, error: rv.error }); return true; }
             const spec = buildReuseSpec(pre.spec, card, rows);

package/src/panel/authorsession.js

@@ -1146,13 +1146,11 @@ export function createSession(card, deps = {}) {
         const no = state.steps.findLastIndex((/** @type {any} */ x) => x.status === 'running');
         appendDraftLog(outDir, { kind: 'step-reds', no: no === -1 ? state.steps.length - 1 : no, stop: authored.stop ?? 'authoring-failed', reds: redsRecord(stopReds), at: new Date().toISOString() });
       }
-      refuse(authored.stop === 'confirm-abandoned' || authored.stop === 'confirm-restart'
-        ? `Stopped: ${authored.stop}${authored.refusal ? ` — ${authored.refusal.detail}` : ''}`
-        : draftStopText({
-          stop: String(authored.stop ?? 'authoring-failed'), reds: stopReds, refusal: authored.refusal,
-          spend: { knownUsd: state.draftSpentUsd, spendComplete: state.draftSpendComplete },
-          wholeJob: RUBRIC_FILES,
-        }), authored.stop === 'confirm-abandoned' ? 'abandoned' : 'refused');
+      refuse(draftStopText({
+        stop: String(authored.stop ?? 'authoring-failed'), reds: stopReds, refusal: authored.refusal,
+        spend: { knownUsd: state.draftSpentUsd, spendComplete: state.draftSpendComplete },
+        wholeJob: RUBRIC_FILES,
+      }), authored.stop === 'confirm-abandoned' ? 'abandoned' : 'refused');
       return;
     }
 

package/src/panel/index.html

@@ -2910,7 +2910,17 @@
       });
     });
     if(sum){
-      var first = items.length ? (Array.isArray(items[0].hints) ? items[0].hints.length : 0) : 0;
+      // count DISTINCT hints across the draft and replan blocks: the same ledger row (ids[i], parallel to hints[i]) handed twice is one hint
+      var seen = {};
+      var first = 0;
+      items.forEach(function(it){
+        var hs = Array.isArray(it.hints) ? it.hints : [];
+        var byId = Array.isArray(it.ids) && it.ids.length === hs.length;
+        hs.forEach(function(h, i){
+          var key = byId ? "id:" + it.ids[i] : "n:" + it.phase + ":" + h.n;
+          if(!seen[key]){ seen[key] = true; first += 1; }
+        });
+      });
       var label = items.length ? head + " \u00B7 " + first + (first === 1 ? " hint" : " hints") : head;
       // no arrow (hamr 2026-10-23): the state chip leads; aria-expanded carries open/closed. The same `[✓] word` state markup the schedule/step headers wear (stateDotHTML), then the plain-words title
       var paint = function(){ sum.innerHTML = stateDotHTML(glyphClass("\u2713"), "learnings", "audit-learnings-state") + " " + escapeXml(label); };
@@ -4939,6 +4949,8 @@
         var suffix = reach.modelListed === false ? " (model not listed)" : "";
         return { keyOk: true, ok: true, text: "[✓] " + r.envKey + " found · " + modelId + " reachable" + suffix };
       }
+      // a blank Base URL is nothing to probe, not flakiness: say the server's own plain sentence (src/modellist.js owns it)
+      if(reach.status === "no-base-url" && reach.note) return { keyOk: true, ok: false, text: "[✗] " + reach.note };
       return { keyOk: true, ok: false, text: reachStatusText(reach.status) };
     }
     function refreshModelStatus(){

package/src/panel/schedulestart.js

@@ -46,6 +46,11 @@ export function perFireSpec(schedule, cause) {
   if (jobSpecHash(schedule.spec) !== schedule.specHash) return { ok: false, why: 'The saved schedule no longer matches what you signed. Nothing started.' };
   const spec = JSON.parse(JSON.stringify(schedule.spec));
   if (cause.kind === 'file') {
+    // the card text is `label: value` lines: a name holding a line break would read back as ANOTHER Inputs line, and edge whitespace
+    // is trimmed to a path that does not exist (a leading space in the file name sits mid-path and is harmless). Refused with its reason, never rewritten.
+    if (/[\r\n]/.test(cause.path) || cause.path !== cause.path.trim()) {
+      return { ok: false, why: `The file name ${JSON.stringify(cause.path)} has a line break or a space at its end, which the job form cannot carry. Rename the file. Nothing started.` };
+    }
     const first = Array.isArray(spec.inputs) ? spec.inputs[0] : null;
     if (!first) return { ok: false, why: 'The saved schedule has no input for the file to replace. Nothing started.' };
     spec.inputs = [{ ...first, value: cause.path }, ...spec.inputs.slice(1)];

package/src/panel/server.js

@@ -68,7 +68,7 @@ import { SHAPES } from '../providershapes.js';
 import { resolveProvider } from '../providers.js';
 import { readResume, checkpointAgeGate, CHECKPOINT_OUTCOMES } from '../reuse.js';
 import {
-  statusFor, partStatusFor, GOAL_MET_LINE, doorViewOf, ACTOR_MARKER, DOOR_WORDS,
+  statusFor, partStatusFor, GOAL_MET_LINE, doorViewOf, ACTOR_MARKER, DOOR_WORDS, isReusableGreen,
 } from './status.js';
 import { thinkingJobText } from '../thinking.js';
 import { judgedFilesOf, lineRules, stepFileRel, proseNotCheckedItems } from '../rubricstep.js';
@@ -542,7 +542,7 @@ function endedBase(summary, death, o) {
     if (o.destinationRefused) {
       // Reuse workflow only on a run that earned its green (hamr 2026-10-08, as below); every ending offers Reuse workflow
       // (withReuseAction adds it) and is told to change the job
-      const earned = outcome === 'green';
+      const earned = isReusableGreen(outcome);
       return {
         reason: 'Goal met, but the output could not be delivered.',
         next: earned ? 'Fix the destination, then Reuse workflow.' : CHANGE,
@@ -550,10 +550,9 @@ function endedBase(summary, death, o) {
         actions: earned ? REUSE : [],
       };
     }
-    // hamr 2026-10-08: already-green (the check passed before any work) is not a reusable job — only a run that
-    // earned its green offers Reuse workflow; every ending offers Reuse workflow (withReuseAction adds it). `satisfied` is a
-    // close VERDICT, never a run outcome (ralph and the job-end emitters write `green`), so it rides with already-green.
-    if (outcome !== 'green') return { reason: 'Goal met.', next: CHANGE, line: GOAL_MET_LINE, actions: [] };
+    // a reusable green (isReusableGreen: green or already-green, hamr 2026-10-15) says nothing is left to do; every ending offers
+    // Reuse workflow (withReuseAction adds it). `satisfied` is a close VERDICT, never a run outcome, so it is not one.
+    if (!isReusableGreen(outcome)) return { reason: 'Goal met.', next: CHANGE, line: GOAL_MET_LINE, actions: [] };
     return { reason: 'Goal met.', next: 'Nothing to do.', line: GOAL_MET_LINE, actions: REUSE };
   }
   if (outcome === 'cap-halt') {
@@ -1530,7 +1529,8 @@ function scheduleExtrasFor(runid, job, rows, nos, opts, view) {
             }
             const got = hit ?? fallback;
             const no = got ? nos.get(got.r.runid) : undefined;
-            const word = got ? summarizeRow(got.r).status?.word : undefined;
+            // events: a fire refused at the run-start fetch has no spine, only its settled event; without them it has no status word
+            const word = got ? summarizeRow(got.r, Date.now(), undefined, readRunList(opts).events).status?.word : undefined;
             lastWords = `last ${dateTimeWords(Number(lastRow.at))}${no ? ` · run-${no}` : ''}${word ? ` · ${word}` : ''}${got?.rec.catchUp === true ? ' · catch-up' : ''}`;
           } else {
             lastWords = `last ${dateTimeWords(Number(lastRow.at))} · ${skippedWords(lastRow, true)}`;
@@ -3514,7 +3514,7 @@ export function getStartFrom(runid, opts = {}) {
     // T D.2: a SCHEDULED run's green reads `green-held` until the person accepts it, so that same refusal holds it unchanged
     outcome: (() => {
       const o = legsOf(records).at(-1)?.outcome ?? null;
-      return o === 'green' && heldScheduled(records, triggerRecordOf(row)) ? 'green-held' : o;
+      return isReusableGreen(o) && heldScheduled(records, triggerRecordOf(row)) ? 'green-held' : o;
     })(),
     card,
     from: 'signed job',
@@ -3579,7 +3579,7 @@ export function listReuseJobs(opts = {}) {
     try { records = parseJsonl(row.spine).records; } catch { continue; }
     const outcome = legsOf(records).at(-1)?.outcome ?? null;
     // a real green or an already-green (hamr 2026-10-15: if it is already fixed and nothing is to be done, it is green and can be reused)
-    if (outcome !== 'green' && outcome !== 'already-green') continue;
+    if (!isReusableGreen(outcome)) continue;
     if (heldScheduled(records, triggerRecordOf(row))) continue; // T D.2: a scheduled green waits for the person's Accept
     const signed = signedSpecForRun(row, records);
     if (!signed) continue;

package/src/panel/status.js

@@ -20,6 +20,17 @@ import { capKindOf } from '../legs.js';
 /** the sentence a passed run carries as its reason (the Ended block's `line`) */
 export const GOAL_MET_LINE = 'goal met';
 
+/**
+ * ONE spelling of "this run's outcome is a green that can be reused" (the Reuse picker, the Reuse start/prefill, the Ended block's
+ * next line). hamr 2026-10-15: an `already-green` (fixed before any work) counts. `satisfied` is a close verdict, never a run outcome.
+ * The SCHEDULE gate (schedules.js greenFor) deliberately stays on a real `green` only (T3).
+ * @param {string|null|undefined} outcome
+ * @returns {boolean}
+ */
+export function isReusableGreen(outcome) {
+  return outcome === 'green' || outcome === 'already-green';
+}
+
 /** @typedef {'running'|'waiting'|'passed'|'failed'|'capped'|'stopped'|'died'} StatusKey */
 
 /** the table: key -> sign + word */

package/src/stagewords.js

@@ -2,6 +2,24 @@
 // src/panel/server.js (verbatim) so the Audit/step map AND the learnings cards read the same sentence from the same
 // code — a second spelling is how two screens come to disagree about one check. Pure; no file IO, no model.
 
+/** the genre-owned noun for the count a TYPES-genre typecheck stage measures (see {@link stageQuestionText}) */
+export const GENRE_WHAT = Object.freeze({ TYPES: 'type errors' });
+
+/** `cmd`+`args`, as a comparable key — the one signal (besides `kind`
+ * itself) that two stages measure the SAME command's output, used to tell a
+ * genuine typecheck stage apart from the TYPES genre's other `lower-is-
+ * better`/`baseline: 0` stage (the failing-test-count half of `suite-green`'s
+ * "two assertions"), which shares that stage's own shape but not its
+ * population. `null` for a stage whose `cmd` isn't a non-empty string —
+ * never matches anything, so it never falsely suppresses a real typecheck
+ * question.
+ * @param {any} params @returns {string|null} */
+export function cmdKey(params) {
+  if (!params || typeof params.cmd !== 'string' || params.cmd.length === 0) return null;
+  const args = Array.isArray(params.args) ? params.args : [];
+  return JSON.stringify([params.cmd, args]);
+}
+
 /**
  * THE PLAIN-QUESTION OWNER (plain-checks build, 2026-09-28, hamr's ruling:
  * the "checks N/M" headline is WITHDRAWN — "confusing, reads like 6 failed
@@ -64,23 +82,6 @@
  * @param {{kind: string|null, params: any, genre: string|null, suiteCmdKeys: Set<string>}} o
  * @returns {string|null}
  */
-export const GENRE_WHAT = Object.freeze({ TYPES: 'type errors' });
-
-/** `cmd`+`args`, as a comparable key — the one signal (besides `kind`
- * itself) that two stages measure the SAME command's output, used to tell a
- * genuine typecheck stage apart from the TYPES genre's other `lower-is-
- * better`/`baseline: 0` stage (the failing-test-count half of `suite-green`'s
- * "two assertions"), which shares that stage's own shape but not its
- * population. `null` for a stage whose `cmd` isn't a non-empty string —
- * never matches anything, so it never falsely suppresses a real typecheck
- * question.
- * @param {any} params @returns {string|null} */
-export function cmdKey(params) {
-  if (!params || typeof params.cmd !== 'string' || params.cmd.length === 0) return null;
-  const args = Array.isArray(params.args) ? params.args : [];
-  return JSON.stringify([params.cmd, args]);
-}
-
 export function stageQuestionText({
   kind, params, genre, suiteCmdKeys,
 }) {

package/types/authorreadout.d.ts

@@ -303,6 +303,13 @@ export function redsRecord(reds: PlainRed[], { cases, signing }?: {
 }): Record<string, any>[];
 /** the stops this module explains in plain words */
 export const PLAIN_PROPOSAL_STOPS: readonly string[];
+/**
+ * ONE owner of the plain sentence for every drafting stop code (hamr 2026-10-09: "a user should get a reason they can
+ * understand and do something about"). What happened; `STOP_TODO` below overrides the default "draft again" where that is wrong.
+ * Used by `draftStopText` for every stop the panel and the CLI show; a code not listed reads `STOP_UNKNOWN`, never the raw code.
+ * @type {Record<string, string>}
+ */
+export const STOP_HEADS: Record<string, string>;
 /** codes the declaration gates (validateJob, validateCloseDecl) raise: one plain sentence covers the family */
 export const DECLARATION_CODES: readonly string[];
 export type PlainRed = {

package/types/panel/status.d.ts

@@ -1,3 +1,11 @@
+/**
+ * ONE spelling of "this run's outcome is a green that can be reused" (the Reuse picker, the Reuse start/prefill, the Ended block's
+ * next line). hamr 2026-10-15: an `already-green` (fixed before any work) counts. `satisfied` is a close verdict, never a run outcome.
+ * The SCHEDULE gate (schedules.js greenFor) deliberately stays on a real `green` only (T3).
+ * @param {string|null|undefined} outcome
+ * @returns {boolean}
+ */
+export function isReusableGreen(outcome: string | null | undefined): boolean;
 /**
  * The status of one run.
  * @param {{outcome: string|null|undefined, died?: boolean, category?: string|null, moneyHalt?: boolean}} o

package/types/stagewords.d.ts

@@ -8,21 +8,6 @@
  * question.
  * @param {any} params @returns {string|null} */
 export function cmdKey(params: any): string | null;
-export function stageQuestionText({ kind, params, genre, suiteCmdKeys, }: {
-    kind: any;
-    params: any;
-    genre: any;
-    suiteCmdKeys: any;
-}): string | null;
-/**
- * Stage name to its plain question, off a signed spec's `closeDecl.stages` — the one pass that gathers every
- * `command-exit` stage's cmd+args FIRST (so the failing-test-count half of `suite-green`'s pair can be told from a
- * genuine typecheck stage) and then asks {@link stageQuestionText} per stage. `null` for a stage with no honest
- * question; an empty map for a spec with no declared stages.
- * @param {any} spec
- * @returns {Map<string, string|null>}
- */
-export function stageQuestionsByName(spec: any): Map<string, string | null>;
 /**
  * THE PLAIN-QUESTION OWNER (plain-checks build, 2026-09-28, hamr's ruling:
  * the "checks N/M" headline is WITHDRAWN — "confusing, reads like 6 failed
@@ -85,6 +70,22 @@ export function stageQuestionsByName(spec: any): Map<string, string | null>;
  * @param {{kind: string|null, params: any, genre: string|null, suiteCmdKeys: Set<string>}} o
  * @returns {string|null}
  */
+export function stageQuestionText({ kind, params, genre, suiteCmdKeys, }: {
+    kind: string | null;
+    params: any;
+    genre: string | null;
+    suiteCmdKeys: Set<string>;
+}): string | null;
+/**
+ * Stage name to its plain question, off a signed spec's `closeDecl.stages` — the one pass that gathers every
+ * `command-exit` stage's cmd+args FIRST (so the failing-test-count half of `suite-green`'s pair can be told from a
+ * genuine typecheck stage) and then asks {@link stageQuestionText} per stage. `null` for a stage with no honest
+ * question; an empty map for a spec with no declared stages.
+ * @param {any} spec
+ * @returns {Map<string, string|null>}
+ */
+export function stageQuestionsByName(spec: any): Map<string, string | null>;
+/** the genre-owned noun for the count a TYPES-genre typecheck stage measures (see {@link stageQuestionText}) */
 export const GENRE_WHAT: Readonly<{
     TYPES: "type errors";
 }>;