muse-crew 0.14.4 → 0.14.6

package/lib/publish-note-vocabulary.js

@@ -1,44 +1,157 @@
-// Terminal-note vocabulary registry (D7, 2026-09-19). Explicit state, not
-// prose: every `publish: …` note the state machine treats as terminally
-// parked. Readers (scan-publish-unknown in lib/crew-api.js) consult this;
-// writers assert against it (lib/verify-publish.js's terminal() fails loud
-// before emitting a verb that is not in the registry). Add a note here when
-// a new terminal verb is introduced — the scan recognizes it with no other
-// change.
+// Publish-note vocabulary registry (D7, 2026-09-19; 0.14.6 version-acknowledgement
+// rewrite, 2026-09-20). Explicit state, not prose.
 //
-// This module is the closed-enum pattern's first instance: the audit
-// (room23-design/blanket-call-audit.md §3) lists the other state-carrying
-// string families (the full `publish: <transition>` note shapes, the
-// publish-ledger `outcome` vocabulary, worker-report marker lines) that a
-// later unification pass extends the enum-guard pattern to. The contract
-// for any new family: one registry module, readers consult it, writers
-// assert membership before writing, closed by default and open by edit.
+// 0.14.6 replaced the content-verdict/readback architecture with Eric's
+// publication contract: exact version acknowledgement is the sole positive
+// completion criterion ("If we hear that the artifact acknowledges our
+// version, that's it. We don't verify against content."). Provenance now
+// certifies that an issuance request was ACKNOWLEDGED — never that bytes
+// matched.
+//
+// Two registries:
+//   TERMINAL_PUBLISH_NOTES — every `publish: …` note the ack/intent scans
+//     treat as terminally parked. Readers consult this; a recognized
+//     terminal note is skipped as terminal with its meaning, never as
+//     unrecognized. Legacy verbs from the retired content-verdict machine
+//     stay recognized (marked below) so old note history never becomes
+//     "unrecognized" — the new machine never writes them.
+//   TRANSITIONAL_PUBLISH_NOTES — every non-terminal state-carrying
+//     `publish: …` note the 0.14.6 machine writes.
+//
+// Writers are split in two (2026-09-20 REVIEW): deterministic code writes
+// through writeGuardedPublishNote (asserts CODE_WRITABLE_PUBLISH_NOTES —
+// transitional + the four current terminals); tick prose writes only
+// through the `record-publish-note` crew-api command (asserts
+// WRITABLE_PUBLISH_NOTES — transitional ONLY, so prose can never mint a
+// terminal state). A third prose path, `log-event` with type "note", is
+// mechanically rejected for any `publish:` verb — notes are advisory, but
+// only the closed writer may mint state-carrying ones.
+//
+// The one gap: the workflow's `publish: publish-requested` park note is
+// written by the workflow's own parkTask plumbing, not through crew-api —
+// the intent scan validates its shape (commit + attempt) against the intent
+// ledger entry when claiming, which is the mechanical guard for that path.
+//
+// Add a note here when a new verb is introduced — readers recognize it with
+// no other change, and writers cannot emit it without registering it.
 //
 // ESM, no shebang, no side effects on import (import-safe module — bare
 // `node publish-note-vocabulary.js` exits 0).
+//
+// The four 0.14.6 terminals the machine's own deterministic code writes
+// (never tick prose — see the writer split above).
+export const CODE_TERMINAL_PUBLISH_NOTES = [
+  // The artifact acknowledged the attempt's exact version on disk.
+  // Provenance is stamped; the task re-queues. (2026-09-20 REVIEW: disk
+  // is the sole positive evidence — the builder-report path was circular.)
+  "publish: version-acknowledged",
+  // The platform explicitly refused the tick worker's directly-issued edit.
+  // Honest terminal state — no re-issue; parked for human attention.
+  "publish: publish-refused",
+  // The 2-hour acknowledgement budget from first issuance is exhausted with
+  // no acknowledgement (unobserved within budget — the edit may still have
+  // landed). Parked for human attention.
+  "publish: version-timeout",
+  // One-party intent terminal: the diff for the committed intent cannot be
+  // (re)generated byte-identically — the staged file is missing or corrupt,
+  // or the base..commit range cannot be regenerated. Never re-claim, never
+  // loop; parked for human attention.
+  "publish: publish-unissuable",
+];
 export const TERMINAL_PUBLISH_NOTES = [
+  ...CODE_TERMINAL_PUBLISH_NOTES,
+  // Legacy terminals (retired content-verdict/unknown-recovery machine):
+  // recognized so old note history skips as terminal, never written anew.
   "publish: ambiguous",
   "publish: retry-superseded",
   "publish: retry-refused",
   "publish: verified",
   "publish: superseded",
-  // Verification pipeline's terminal content verdict (verify-publish.js).
-  // The task stays parked for human attention; unknown-recovery never
-  // re-enters it. Added 2026-09-19 (Room #23 J1/J3: was mislogged as
-  // unrecognized-publish-note).
   "publish: verification-failed",
+  "publish: intent-unverifiable",
 ];
 export const TERMINAL_NOTE_MEANINGS = {
-  "publish: ambiguous": "unknown-recovery terminal: could not prove the drop; parked for human attention",
-  "publish: retry-superseded": "retry protocol terminal: superseded; parked for human attention",
-  "publish: retry-refused": "retry protocol terminal: platform refused the re-issued edit; parked for human attention",
-  "publish: verified": "publish verified and stamped; task re-queued (terminal for the scan)",
-  "publish: superseded": "HEAD moved past the attempt; recovery aborted; parked for human attention",
-  "publish: verification-failed": "verification pipeline's terminal content verdict — parked for human attention",
+  "publish: version-acknowledged": "the artifact acknowledged this attempt's exact version — provenance stamped; task re-queued (terminal for the scans)",
+  "publish: publish-refused": "the platform refused the tick worker's directly-issued edit (or a builder report carried the version + an explicit refusal) — parked for human attention",
+  "publish: version-timeout": "the 2-hour acknowledgement budget from first issuance expired with no version acknowledgement (unobserved within budget — the edit may still have landed; the outcome is unknown) — parked for human attention",
+  "publish: publish-unissuable": "one-party intent terminal: the intent diff cannot be (re)generated byte-identically; parked for human attention",
+  "publish: ambiguous": "legacy (retired unknown-recovery): could not prove the drop; parked for human attention",
+  "publish: retry-superseded": "legacy (retired retry protocol): superseded; parked for human attention",
+  "publish: retry-refused": "legacy (retired retry protocol): platform refused the re-issued edit; parked for human attention",
+  "publish: verified": "legacy (retired content-verdict pipeline): publish verified and stamped; task re-queued",
+  "publish: superseded": "legacy (retired unknown-recovery): HEAD moved past the attempt; recovery aborted; parked for human attention",
+  "publish: verification-failed": "legacy (retired content-verdict pipeline): terminal content verdict — parked for human attention",
+  "publish: intent-unverifiable": "legacy (retired manifest-freshness path): re-claimed intent with no manifest baseline; parked for human attention",
 };
+// 0.14.6 transitional notes — every non-terminal state-carrying note the
+// machine writes. The ack scan (scan-ack-pending) is atomic code and needs
+// no claim note of its own.
+export const TRANSITIONAL_PUBLISH_NOTES = [
+  // The workflow parked at Publish with a checksummed publish-intent ledger
+  // entry (carries the per-attempt version). The intent scan claims these.
+  "publish: publish-requested",
+  // The intent scan claimed this tick's issuance lease (1 hour).
+  "publish: publish-intent-claimed",
+  // The intent's staged diff was computed against a superseded base —
+  // re-queued for the workflow's Publish to re-prepare. Never issued.
+  "publish: publish-base-stale",
+  // The tick worker issued the edit and recorded it (issuer-stamped
+  // submitted ledger entry). The ack scan owns the task from here.
+  "publish: edit-issued",
+];
+// The prose-writable set (0.14.6 §1.5, closed publish-note writer): the ONLY
+// verbs tick prose may mint, via the `record-publish-note` crew-api command.
+// Transitional notes only — prose can never mint a terminal state. Legacy
+// terminals are recognized (read-side, so old note history still skips as
+// terminal) but NOT writable — history stays readable; nothing new may be
+// written in the old tongue.
+export const WRITABLE_PUBLISH_NOTES = [
+  ...TRANSITIONAL_PUBLISH_NOTES,
+];
+// The code-writable set: deterministic code (the scans and the guarded
+// record-* commands) writes through writeGuardedPublishNote, which asserts
+// here — transitional notes plus the four current terminals the machine
+// itself transitions to. Legacy terminals are never written anew.
+export const CODE_WRITABLE_PUBLISH_NOTES = [
+  ...TRANSITIONAL_PUBLISH_NOTES,
+  ...CODE_TERMINAL_PUBLISH_NOTES,
+];
+function extractPublishVerb(message) {
+  const m = /publish:\s*([a-z0-9-]+)/.exec(String(message || ""));
+  return m ? `publish: ${m[1]}` : null;
+}
 export function matchTerminalPublishNote(message) {
   for (const note of TERMINAL_PUBLISH_NOTES) {
     if (message.includes(note)) return note; // same substring semantics the scan already uses
   }
   return null;
 }
+// Prose-side guard (0.14.6 §1.5, closed publish-note writer): the
+// `record-publish-note` command asserts here. Returns the matched
+// "publish: <verb>". Throws (usage) on anything else — prose cannot mint
+// new states, and cannot mint terminal states.
+export function assertWritablePublishNote(message) {
+  const verb = extractPublishVerb(message);
+  if (!verb || !WRITABLE_PUBLISH_NOTES.includes(verb)) {
+    throw new Error(
+      `unregistered publish-note verb ${verb === null ? "(none found)" : `'${verb}'`} — ` +
+      `tick prose may only mint transitional publish notes (lib/publish-note-vocabulary.js); ` +
+      `terminal states are written by deterministic code, never prose. Legacy terminals are recognized but not writable.`
+    );
+  }
+  return verb;
+}
+// Code-side guard: writeGuardedPublishNote asserts here. Returns the
+// matched "publish: <verb>". Throws on anything else — a registry
+// violation is a caller bug (usage).
+export function assertCodeWritablePublishNote(message) {
+  const verb = extractPublishVerb(message);
+  if (!verb || !CODE_WRITABLE_PUBLISH_NOTES.includes(verb)) {
+    throw new Error(
+      `unregistered publish-note verb ${verb === null ? "(none found)" : `'${verb}'`} — ` +
+      `state-carrying publish notes are a closed set (lib/publish-note-vocabulary.js); ` +
+      `register the verb before writing it. Legacy terminals are recognized but never written anew.`
+    );
+  }
+  return verb;
+}

package/lib/schema.sql

@@ -205,3 +205,22 @@ CREATE TABLE IF NOT EXISTS platform_run_tasks (
   linked_at       TEXT NOT NULL DEFAULT (datetime('now'))
 );
 CREATE INDEX IF NOT EXISTS platform_run_tasks_task_id_idx ON platform_run_tasks(task_id);
+
+-- Builder reports (0.14.6, 2026-09-20). The tick worker records the artifact
+-- platform's report text verbatim after each directly-issued edit via the
+-- `record-builder-report` command. The command mechanically rejects unless
+-- the report text contains the exact per-attempt version, so every row here is
+-- a version-keyed refusal the ack scan can evaluate: outcome 'refused' + a
+-- version matching an issued attempt = terminal publish-refused. (The old
+-- 'acknowledged' outcome was cut 2026-09-20 REVIEW as circular — disk is the
+-- sole positive evidence.) Rows are evidence, never deleted by the scans.
+CREATE TABLE IF NOT EXISTS builder_reports (
+  id          TEXT PRIMARY KEY,
+  task_id     TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  version     TEXT NOT NULL,
+  outcome     TEXT NOT NULL CHECK (outcome IN ('acknowledged', 'refused')),
+  report_text TEXT NOT NULL,
+  created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS builder_reports_task_id_idx ON builder_reports(task_id);
+CREATE INDEX IF NOT EXISTS builder_reports_version_idx ON builder_reports(version);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muse-crew",
-  "version": "0.14.4",
+  "version": "0.14.6",
   "description": "Opinionated orchestration for Muse — workflows, identities, and tooling for autonomous software development.",
   "license": "UNLICENSED",
   "private": false,

package/seed/AGENTS.md

@@ -5,6 +5,7 @@ Init source data. Everything `crew-init.js` reads when setting up a new crew ins
 - `crons.json` — the declarative cron manifest; crew-init creates/updates each entry idempotently; `enabled` is a creation-time default only
 - `cron-body-template.md` — template for creating the dispatch cron job
 - `cron-body-update-watch.md` — template for the daily `crew-update-watch` cron job: runs `lib/update-watch.js --crew-home {crewHome}` verbatim and reports stdout
+- `cron-body-ack-scan.md` — template for the 5-minute `crew-ack-scan` cron job: runs the observation-only `scan-ack-pending` pass so publish verdicts land quickly. It never issues artifact edits — issuance stays in the 15-minute poll tick's claim-and-issue path.
 - `posture.md` — PM posture that shapes the user's assistant for crew interaction
 - `feedback/` — feedback feature placeholder
 - `workflows/` — human-readable workflow definitions, copied to `$CREW_HOME/.orchestration/workflows/` during init

package/seed/cron-body-ack-scan.md

@@ -0,0 +1,44 @@
+# Muse Crew acknowledgement scan (fast observation tick)
+
+You are the ack-scan worker for the Muse Crew at {crewHome}. This is an
+observation-only tick: it runs the version acknowledgement scan every 5
+minutes so publish verdicts land quickly. It NEVER issues artifact edits —
+issuance belongs to the 15-minute poll tick's Step 4.4/4.4b claim-and-issue
+path.
+
+1. Run the scan verbatim:
+
+   ```
+   node {crewHome}/lib/crew-api.js --crew-home {crewHome} scan-ack-pending
+   ```
+
+   The command cross-checks that the running release is the active one
+   (`resolveActiveRelease`); if it reports a release mismatch, do NOT
+   proceed — log the mismatch and stop.
+
+   Failure behavior (mechanical): if the scan exits nonzero, report its
+   stderr verbatim as the complete result of this tick, take NO other
+   action, do NOT rerun the scan, do NOT invoke any other Crew API
+   command, and stop. A release mismatch ("not the active release") is a
+   stop, not a retry. A nonzero exit is never retried inside this tick —
+   the next 5-minute tick runs the scan again on its own.
+
+2. Log every list the scan returns: `acknowledged`, `refused`, `reissued`,
+   `timeouts`, `skipped`.
+   - `acknowledged` / `refused` / `timeouts` are fully handled by code — take
+     NO action.
+   - `reissued` entries are fresh intents staged for the poll tick —
+     immediately claimable, no backoff. This worker does NOT claim or
+     issue them; the poll tick's `scan-publish-intent` +
+     `record-intent-issuance` path does that.
+   - `skipped` with `window-open` means the attempt's 30-minute window from
+     latest issuance is still open — no action. The scan runs every 5 minutes
+     so the scan's own latency never eats the window: with 6 scans per
+     window, the verdict lands within one cadence of the ack or the expiry.
+
+3. Verdicts are evidence-only. The exact per-attempt version string on the
+   artifact's disk is the sole positive signal; a `scan-ack-pending` result
+   that names `acknowledged` IS the verdict. Never stamp provenance from
+   prose, never infer a verdict from timing, and never issue a publish edit
+   yourself — a publish edit is always the tick worker's directly-issued
+   `artifact_edit` against a claimed intent, never an agent-issued one.

package/seed/cron-body-template.md

@@ -2,6 +2,16 @@
 
 You are the dispatch trigger for Muse Crew. Run the authoritative dispatcher workflow and launch its claims autonomously.
 
+### Known blockers — read first, do not re-derive or re-report
+
+The failures below are settled and recorded in the Gate 1 OODA state. The authoritative list lives at `~/workspace/goals/gate-1-onboarding-canary-passes/hidden_files/ooda/known-blockers.md` — if this copy ever disagrees with that file, the file wins. Their fixes are already queued in the main repo BUILD. If you observe one, log exactly one line — `known-blocker: <id> — <one-line observation>` — and move on. Do NOT write root-cause analysis and do NOT write "follow-up needed"; the follow-up is already owned.
+
+- **Blocker 22 — wrong publication caller (settled 2026-09-20):** workflow children cannot call `artifact_edit` (the builder requires a parent-conversation session id they don't have). The 0.14.x trigger/observation path is dead by architecture; `submitted` writes from it are phantom. Fix in BUILD: one-party worker-owned artifact publication. (0.14.6: publication is a handoff with strong suggestions, not deterministic patch application. Each attempt carries a fresh deterministic version — `sha256("publish-version:v1:" + task_id + ":" + commit + ":" + attempt)` — synthesized into the staged diff as `.crew-publish-version`. Acknowledgement is the exact version string echoed, nothing else — Eric's contract: "If we hear that the artifact acknowledges our version, that's it. We don't verify against content.")
+- **Blocker 23 — retry harness cannot access Crew state (settled 2026-09-20):** `lib/retry-publish.js` imported `better-sqlite3` (not shipped; the release uses `node:sqlite`) and targeted `crew.db` instead of the real `crew-state.db`. Every retry prepare returned `db-unavailable` and failed closed before any lock, edit, or journal write. Fixed in BUILD (0.14.5): ported to `node:sqlite` + `$CREW_HOME/crew-state.db`, the missing `CREW_REPO` for the merge lock supplied, and the trigger step converted from a spawned child to the session-carrying tick worker's direct `artifact_edit` call (blocker 22). (0.14.6: the retry harness, the publish-absence classifier, and the content-verification chain are RETIRED — subsumed into the single version attempt loop: a 30-minute window per attempt with immediate reissue (no backoff), a 2-hour total budget from first issuance, and the ack scan as the sole verdict. There is no separate retry queue and no content verifier.)
+- **Blocker 28 — Step 0 sees completed runs too (settled 2026-09-20):** a COMPLETED platform run can still contain FAILED `agent()` calls — the old Step 0 query (failed runs only) was blind to it. The Step 0 check now also sweeps completed runs in the last 15 minutes with failed agent() calls, through the same `record-platform-failure` / `retry-platform-failure` path. If you observe a failed agent() call inside a completed run, log `known-blocker: 28 — <one line>` and move on.
+
+(Maintainer note: this snapshot is refreshed from known-blockers.md at release time. The poller always treats the file as authoritative.)
+
 ### Steps
 
 0. **Check for platform workflow failures (opacity killer):** The platform records workflow run failures in `runtime.workflow_runs` — these are invisible in the crew DB unless you check. A workflow that dies on a fatal `agent()` error (e.g. "subagent bootstrap is no longer authorized") leaves its task stranded with no explanation.
@@ -18,6 +28,15 @@ You are the dispatch trigger for Muse Crew. Run the authoritative dispatcher wor
      `node {crewHome}/lib/crew-api.js --crew-home {crewHome} record-platform-failure --json '{"platform_run_id": "<run_id>", "error_message": "<error>", "platform_created_at": "<created_at>"}'`
    - Then retry each failure (clears stale reservation, re-queues task, or parks after 3 attempts):
      `node {crewHome}/lib/crew-api.js --crew-home {crewHome} retry-platform-failure --json '{"platform_run_id": "<run_id>"}'`
+   - **Also** sweep COMPLETED runs containing failed agent() calls (2026-09-20, blocker 28 — the failed-runs query above is blind to a run that completed with a dead child):
+     ```sql
+     SELECT w.run_id, w.created_at, c.error
+     FROM runtime.workflow_runs w
+     JOIN runtime.workflow_agent_calls c ON c.run_id = w.run_id AND c.status = 'failed'
+     WHERE w.created_at > now() - interval '15 minutes' AND w.status = 'completed'
+     ORDER BY w.created_at DESC
+     ```
+   - Route each completed-run failure through the same two commands — `record-platform-failure`, then `retry-platform-failure` — exactly as above.
    - Log the results. This ensures transient platform failures don't strand tasks.
 
 1. **Load tools:** Call tool_search_load_tool_namespace with paths ["workflow_launch"].
@@ -35,74 +54,55 @@ You are the dispatch trigger for Muse Crew. Run the authoritative dispatcher wor
    - If the acknowledge fails (no reservation exists), DO NOT LAUNCH — the dispatcher did not acquire this task. This is a safety invariant.
    - The launched workflow self-claims the task and clears the reservation as its first actions. If the task was already claimed or is done, the claim fails closed and the run stands down quietly — this is the mechanical duplicate protection, not an error.
 
-   If the dispatcher returned no claims or the claims array is empty, log NO_DISPATCH and CONTINUE to Step 4.4 — do NOT exit. Unknown-recovery (4.4), verification (4.5) and evidence (6) run independently of dispatch claims. A no-claims tick must still recover parked publishes, verify them, and deliver evidence. (Fixed 2026-09-14: the old "exit on NO_DISPATCH" skipped verification permanently.)
-
-4.4. **Unknown-recovery (docs/publish-unknown-recovery.md):** tasks parked with "Publish outcome unknown" are the receipt-less trigger gap (2026-09-18, blocker 15). The note is the state machine; deterministic code owns every transition; you are the ferry (scan → classifier → record / retry protocol). Run this BEFORE Step 4.5 so a re-triggered build's mirrored verification-requested is visible to the verification scan on a later tick. Log every list the scan returns.
-   - Scan (code): `node {crewHome}/lib/crew-api.js --crew-home {crewHome} scan-publish-unknown`
-     Returns `{ waiting: [...], due: [...], retry_due: [...], mirrored: [...], skipped: [...] }`. `waiting` = parked < 30m — leave alone, no claim. `mirrored`/`skipped` = already handled by code — log only, take no action.
-   - For each entry in `due`: classify (code), then record the decision (code). Use the entry's fields verbatim.
-     - `node {crewHome}/lib/classify-publish-absence.js --repo-path "<repo_path>" --commit <commit> --base <base> --slug "<slug>" --trigger-ts "<trigger_ts>" --park-ts "<park_ts>" --task-id <task_id> --manifest-before '<manifest_before JSON>'`
-       Serialize the entry's `manifest_before` field to compact JSON for the `--manifest-before` value; when the entry's `manifest_before` is null, omit the flag (the classifier falls back to the time-based advance check and the Step 4.5 verifier fails closed without a baseline).
-       Exit 0 prints the decision JSON (`{ ok:true, decision, reasons, details }`) — or `{ ok:false, ... }` for a semantic non-verdict. Exit non-zero (usage/git/IO failure) → log the stderr line and LEAVE THE TASK: do NOT record anything; the claim expires and the next tick re-claims. A classifier crash is never a verdict.
-     - `node {crewHome}/lib/crew-api.js --crew-home {crewHome} record-unknown-classification --json '{"task_id": "<task_id>", "claim_expiry": "<claim_expiry>", "decision": <classifier stdout JSON>}'`
-       Paste the classifier's stdout verbatim as the decision value. If it returns `recorded: false` → log the reason and continue (another tick owns the task). The routes are the code's — log the returned decision and `routed` value:
-       verified → `publish: verification-requested` (no re-trigger); provably-dropped → `publish: dropped` (queues the retry protocol); applied-not-built / ambiguous → `publish: ambiguous` (terminal); superseded → `publish: superseded` (terminal); deferred → nothing (the claim expires; the next scan re-claims).
-     - Never invent a decision. Never re-trigger the edit for a `due` entry — classification only.
-   - For each entry in `retry_due` (a provably-dropped edit with a free retry budget — exactly one retry per task, enforced from note history; the scan only emits `retry_due` when no `publish: retry-issued` exists in the task's history): run the deterministic retry protocol via `lib/retry-publish.js`. The command owns all lock handling, journaling, diff generation, ledger writes, and cleanup with try/finally lock release — you only mediate the unavoidable `artifact_edit` tool call.
-     
-     Phase 1 — prepare (deterministic):
-     `node {crewHome}/lib/retry-publish.js --crew-home {crewHome} --task-id <task_id> --phase prepare`
-     - Exit 0 with `{"ok": true, "outcome": "ready", ...}`: the merge lock is HELD. The output carries `diff_path`, `diff_sha256`, and `slug`. Proceed to the trigger below.
-     - Exit 0 with `{"ok": true, "outcome": "superseded"|"lock-held"|"not-dropped", ...}`: terminal for this tick. Do NOT proceed to the trigger. If `outcome` is `not-dropped`, the output carries the full `classification` — pass it to `record-retry-recheck`: `node {crewHome}/lib/crew-api.js --crew-home {crewHome} record-retry-recheck --json '{"task_id": "<task_id>", "decision": <classification JSON>}'` and STOP for this task.
-     - Exit non-zero: the command failed (lock released via try/finally). Log the stderr line and STOP — do NOT trigger.
-     
-     Trigger (agent-mediated — the ONLY prose-owned step):
-     Spawn ONE child (subagent) whose first instruction loads the artifact namespace (`tool_search.load_tool_namespace` with paths `["artifact"]`), with this exact brief — the same shape as the workflow's first attempt:
-        "The change to apply is the unified diff in the file \"<diff_path>\" (sha256 <diff_sha256>).
-        1. Verify the file: run sha256sum on it. If the printed hash is not exactly <diff_sha256>, STOP and end your turn — do not call artifact_edit.
-        2. Read the file's full content.
-        3. Call artifact_edit with slug \"<slug>\" and verbatim_request:
-        'Apply the following change to your source tree, then rebuild and deploy.
-
-        UNIFIED DIFF (relative to your source tree):
+   If the dispatcher returned no claims or the claims array is empty, log NO_DISPATCH and CONTINUE to Step 4.4 — do NOT exit. Intent scan (4.4), ack scan (4.5) and evidence (6) run independently of dispatch claims. A no-claims tick must still issue parked publish intents, scan for acknowledgements, and deliver evidence. (Fixed 2026-09-14: the old "exit on NO_DISPATCH" skipped publication permanently.)
+
+4.4. **Publish intent scan (0.14.6):** the workflow parks at Publish with a version-carrying publish-intent ledger entry; issuance belongs to the tick. Deterministic code owns every transition; you are the ferry (scan → issue → record). Run this BEFORE Step 4.5 so an issued edit's ack window is open to the acknowledgement scan on a later tick. Log every list the scan returns.
+   - Scan (code): `node {crewHome}/lib/crew-api.js --crew-home {crewHome} scan-publish-intent`
+     This atomically claims parked publish intents for this tick (1-hour lease, so a second tick cannot double-issue). It returns `{ intent: [...], skipped: [...], requeued: [...] }`. Each intent entry carries `task_id`, `commit`, `attempt`, `slug`, `repo_path`, `project_id`, `ledger_path`, `base`, `diff_path`, `diff_sha256`, `version` (`<commit>:<attempt>`), `files` (changed paths), `claimed_at`, `claim_expiry`, `reclaimed` (true when a previous tick died mid-issuance). Copy the entry's fields verbatim — never re-derive them.
+   - `skipped` = log only, take no action. `requeued` (the intent was superseded — a newer commit restaged and the task is back in the workflow) = log only, take no action.
+   - For each entry in `intent`: issue it in Step 4.4b. Issuance is one-party and version-bound; the suggestion handoff and the record protocol live there.
+
+4.4b. **One-party intent issuance (0.14.6, blocker 22):** publication is a handoff with strong suggestions — byte-for-byte control is not the contract. The staged diff already contains the synthesized protocol receipt `.crew-publish-version` (content = this attempt's version + newline); EXACT acknowledgement of the version is the sole positive completion criterion (Eric's contract). Issuance belongs to YOU, the session-carrying tick worker, calling `artifact_edit` directly in this turn. Never spawn a child for it (blocker 22: children cannot reach `artifact_edit`).
+   - For each intent entry from the 4.4 scan (copy the entry's `task_id`, `commit`, `attempt`, `version`, and `claim_expiry` verbatim — never re-derive them):
+     1. **Verify the staged diff (code):** `sha256sum "<diff_path>"` must print exactly `diff_sha256`. If the file is missing, regenerate deterministically — the version pair regenerates the identical version and identical bytes — and re-verify:
+        `node {crewHome}/lib/compute-publish-diff.js --repo-path "<repo_path>" --base <base> --commit <commit> --task-id "<task_id>" --attempt <attempt> --out "<diff_path>"`
+        then re-run the sha256sum. If the regeneration exits non-zero, or the hash still does not match after regeneration, the diff is UNISSUABLE — record it terminally (code, never prose):
+        `node {crewHome}/lib/crew-api.js --crew-home {crewHome} record-intent-unissuable --json '{"task_id": "<task_id>", "claim_expiry": "<claim_expiry>", "reason": "<missing-staged-diff|diff-unregenerable|hash-mismatch-after-regeneration>"}'`
+        (copy `claim_expiry` verbatim from the scan entry — it is the compare-and-swap). This writes the terminal `publish: publish-unissuable` note and an issuer-stamped ledger entry — parked for human attention. Never re-claim, never loop on an hourly reclaim; a diff that cannot be checksummed never becomes an edit.
+     2. **Re-claim check — the version receipt decides (code):** when the entry's `reclaimed` is true, a previous tick died mid-issuance and may have issued the edit without recording it. Read the artifact's on-disk version receipt `~/workspace/ts-spaces/<slug>/.crew-publish-version-<task_id>` (trim whitespace) and compare it to the entry's `version`. If it EQUALS the dead attempt's version → the edit landed: call `record-version-ack --json '{"task_id":"<task_id>","version":"<entry version>","via":"disk"}'` and NEVER re-issue. If it differs or the file is unreadable → the edit provably did not land (the receipt is the only positive signal): proceed to issuance. Never decide this from prose, from `artifact_status`, or from an inspector's summary.
+     3. **Issue the edit directly — in this turn, never in a child.** Load the artifact namespace in your own turn (`tool_search.load_tool_namespace` with paths `["artifact"]`) and call `artifact_edit` with the entry's `slug` and this suggestion handoff (paste the verified staged diff file's full content):
+        'Adopt the following change into your source tree, then rebuild and redeploy.
+
+        CHANGE: task <task_id>, commit <first 12 hex of commit>. Files: <comma-separated files list from the entry's `files`>.
+
+        SUGGESTED PATCH (staged unified diff, relative to your source tree — treat as a strong suggestion, apply with judgment):
         ```diff
-        <the full content of the verified file, pasted verbatim>
+        <the full content of the verified staged file, pasted>
         ```
 
-        Rules:
-        - For each file in the diff, apply its hunks to the same path in your source tree (use git apply or equivalent).
-        - For a new file (--- /dev/null), create it with the added (+) lines as its full content.
-        - For a deleted file (+++ /dev/null), delete it.
-        - If any hunk does not apply cleanly, STOP and report the failure — do not improvise or skip hunks.
-        - Do not make any other source changes.
-        - After applying, rebuild and deploy.'
-        Edit-request contract (read carefully):
-        - Call artifact_edit exactly once with the slug and verbatim_request above. Never retry the edit yourself: if the edit is not accepted, do NOT call artifact_edit again — end your turn.
-        - If artifact_edit explicitly refuses the edit (the call is rejected — e.g. the artifact does not exist), do NOT call artifact_edit again: end your turn with exactly one line and nothing else: ARTIFACT_EDIT_REFUSED: <the refusal text, one line>.
-        - If artifact_edit is not available after the load, do NOT improvise — end your turn.
-        - You do NOT call setprovenance, artifact_inspect, or post-deploy yourself.
-        No report is needed: do not return JSON, do not summarize what you did, do not echo the diff. End your turn after the artifact_edit call."
-        Wait for the child to finish. The child's final text is your only signal.
-     
-     Phase 2 — complete (deterministic):
-     `node {crewHome}/lib/retry-publish.js --crew-home {crewHome} --task-id <task_id> --phase complete --edit-outcome <accepted|refused> [--refusal-text "<first line>"]`
-     - If the child's final text starts with `ARTIFACT_EDIT_REFUSED`: `--edit-outcome refused --refusal-text "<first line of the refusal>"`.
-     - Otherwise: `--edit-outcome accepted`.
-     - The command writes the outcome notes, appends the `-retry1` ledger entry (with the pre-retry `manifest_before` baseline), mirrors verification-requested, and RELEASES the lock in a finally block. Exit 0 means the protocol completed.
-     
-   - Crash rules (fail closed, never re-trigger blind): if this tick dies anywhere in the retry protocol, the note journal is the recovery state. `publish: retry-intended` without `retry-issued` → the next scan mirrors `verification-requested` (never re-triggers). `publish: retry-issued` without a mirrored request → the next scan mirrors it. A leaked merge lock expires after 600s. The next tick's scan never emits `retry_due` for a task with `retry-issued` in history — exactly one retry, enforced from notes, not from the ledger.
-
-4.5. **Parent publish verification (docs/publish-verification.md):** The publisher parks instead of stamping provenance; the parent — this tick, the live root agent — verifies content and stamps. Deterministic code detects, reads back, and certifies; you are only the ferry between the deterministic steps (scan → sensor → verifier).
-   - Scan (code): `node {crewHome}/lib/crew-api.js --crew-home {crewHome} scan-verification-pending`
-     This atomically claims each verification-pending task (1-hour lease, so a second tick cannot double-verify) and reconciles verified-but-still-parked tasks to `in_progress`. It returns `{ to_verify: [...], reconciled: [...] }`. Log both lists. If the scan exits 2 (e.g. the active release cannot be resolved), log the error loudly and continue — do NOT work around it.
-   - **Read-back (deterministic sensor, 2026-09-15):** no platform inspection tool is needed — `lib/readback-disk.js` reads the platform's on-disk working copy of the artifact source (`~/workspace/ts-spaces/<slug>/`) and emits the machine-readable findings block the verifier parses. For each entry in `to_verify`, resolve the base via `get-provenance` (`source_commit`; the empty-tree sha `4b825dc642cb6eb9a060e54bf8d69288fbee4904` when nothing is stamped yet — a first publish):
-     `node {crewHome}/lib/crew-api.js --crew-home {crewHome} get-provenance --json '{"project_id": "<project_id>"}'`
-     (use the entry's `project_id` verbatim), then run:
-     `node {crewHome}/lib/readback-disk.js --repo-path "<repo_path>" --commit <commit> --base <base> --slug "<deploy_slug>" --task-id <task_id> > /tmp/readback-<task_id>.txt 2> /tmp/readback-<task_id>.err`
-     Use the entry's `repo_path` and `deploy_slug` verbatim. If the sensor exits 0, the result file holds the findings block — hand it to the verify step below. If it exits non-zero, do NOT save or use stdout: log `publish: verification-procedural-error <commit> <first line of the .err file>` and leave the task parked — the next tick retries. A sensor failure is procedural (the read could not be performed), never a content verdict. Do NOT judge content yourself, and do NOT stamp provenance.
-   - **Verify (code):** `node {crewHome}/lib/verify-publish.js --crew-home {crewHome} --task-id <task_id> --commit <commit> --base <base> --repo-path "<repo_path>" --slug "<deploy_slug>" --crew-release <crew_release> --project-id <project_id> --inspection-id <task_id>-disk --result-file /tmp/readback-<task_id>.txt`
-     Pass `--build-agent-id <id>` from the entry's `build_agent_id` when it is present. Pass `--attempt <attempt>` from the entry's `attempt` when it is present (2026-09-18, blocker 4: the verifier binds the ledger entry by exact (task_id, commit, attempt) — without the attempt, a retry's trigger is indistinguishable from the original's). Use the SAME `<base>` the sensor ran with and the entry's `project_id` verbatim. The verifier parses the findings, compares mechanically against the base..commit diff, checks supersession, and stamps only on a match. Its terminal verdicts (`publish: verified` → task re-queued; `publish: verification-failed` → stays parked) are final — log them and continue.
-   - Never stamp provenance from prose. Never infer a verdict from an inspector's summary text. The verify script's machine-checked comparison is the only certification.
+        PROTOCOL (the one hard requirement):
+        - One file in the patch is `.crew-publish-version-<task_id>` — a protocol receipt, not product code. Apply it like any other file.
+        - When you report the result, quote the exact 64-character version `<version>` verbatim in your report text. If you cannot or will not apply this change, say REFUSED and quote the version anyway.
+        - Do not make any other source changes.'
+        The diff and rules are suggestions now, not byte-exact commands (this also sidesteps the platform newline-escaping defect on verbatim requests — the receipt file is what matters, not byte fidelity).
+        Edit-request contract: call artifact_edit exactly once. Never retry the edit yourself. Tool unavailable (the artifact namespace would not load), a timeout, a transport error, or any otherwise ambiguous result is inconclusive: record NOTHING for this task, log the ambiguity in one line, and let the claim expire; the next scan re-claims and step 2's receipt check decides. An unrecorded outcome is the only honest record of an unknown one.
+        After the call returns, inspect the result text. (2026-09-20 REVIEW) Do NOT record an "acknowledged" builder report — the positive builder-report path was circular (the worker knows the version, so the report proves nothing) and is removed; the ack scan reads the version receipt from the artifact's disk as the sole positive evidence. If the result is an explicit refusal → `node {crewHome}/lib/crew-api.js --crew-home {crewHome} record-builder-report --json '{"task_id":"<task_id>","version":"<version>","outcome":"refused","report_text":"<refusal text verbatim>"}'` (the command MECHANICALLY rejects unless `report_text` contains the exact version — if the refusal text lacks the version, do NOT call record-builder-report; just proceed to the record step with `refused`).
+     4. **Record the outcome (code):**
+        `node {crewHome}/lib/crew-api.js --crew-home {crewHome} record-intent-issuance --json '{"task_id": "<task_id>", "claim_expiry": "<claim_expiry>", "edit_outcome": "<accepted|refused>", "refusal_text": "<first line>"}'`
+        (omit `refusal_text` unless refused). Copy `claim_expiry` verbatim from the scan entry — it is the compare-and-swap. If the command returns `recorded: false`, log the reason and stop: another tick owns the task. `accepted` writes the issuer-stamped `submitted` ledger entry and mirrors `publish: edit-issued <commit> attempt=<n> version=<commit>:<attempt>` (the 4.5 ack scan claims it on a later tick); `refused` writes `rejected` and the terminal `publish: publish-refused` note. There is no outcome for an inconclusive call (step 3) — do not call record-intent-issuance at all when the edit's fate is unknown.
+     - Prose never mints `publish:` notes directly. Any tick-authored publish note goes through exactly one path (code asserts the verb against the closed registry, rejects unknown verbs):
+       `node {crewHome}/lib/crew-api.js --crew-home {crewHome} record-publish-note --json '{"task_id":"<task_id>","note":"<full note text>"}'`
+   - Crash rules (fail closed, never blind re-issue): if this tick dies between the artifact_edit call and the record step, the next scan re-claims with `reclaimed: true` and step 2's version-receipt check decides between ack (`record-version-ack` with `via: "disk"`) and a fresh issuance. The issuance contract is at-most-one RECORDED issuance per attempt; a duplicate physical issuance across a lease expiry is content-identical (the same checksummed staged diff) and bounded by the ack scan's 2-hour budget.
+
+4.5. **Acknowledgement scan (version, 0.14.6):** the version acknowledgement is the entire publish verdict — Eric's contract: "If we hear that the artifact acknowledges our version, that's it. We don't verify against content." No content verification, no manifest comparison, no read-back. A dedicated 5-minute `crew-ack-scan` cron runs the same scan on an observation-only tick (it never issues edits) so verdicts land quickly; this tick ALSO runs the scan AFTER 4.4b so an issued edit's verdict path is synchronous. Deterministic code evaluates the evidence and owns every transition; you only log.
+   - Scan (code): `node {crewHome}/lib/crew-api.js --crew-home {crewHome} scan-ack-pending`
+     For each issued attempt inside its 30-minute window, code checks the on-disk version receipt at `~/workspace/ts-spaces/<slug>/.crew-publish-version-<task_id>` (the SOLE positive evidence — 2026-09-20 REVIEW removed the circular builder-report positive path) plus durably recorded builder reports for explicit refusals. It returns `{ acknowledged: [...], refused: [...], reissued: [...], timeouts: [...], skipped: [...] }`. Log every list.
+   - `acknowledged` = fully handled by code — take NO action, just log. The version was acknowledged (exact string match on disk). Code stamps provenance and writes the terminal `publish: version-acknowledged` note; the task is requeued. Any acknowledgement for the same task/commit counts — including a late earlier attempt's version — the receipt is what matters, not which attempt was latest.
+   - `refused` = fully handled by code — take NO action, just log. A recorded builder report echoed the version with outcome `refused`. Code writes the terminal `publish: publish-refused` note. An explicit refusal is never re-issued.
+   - `timeouts` = fully handled by code — take NO action, just log. The 2-hour total budget from first issuance is exhausted with no acknowledgement; code writes the terminal `publish: version-timeout` note — parked for human attention. `timeouts` is terminal-budget exhaustion only — a window expiry is a `reissued`, never a timeout.
+   - `reissued` = fresh intents for the next attempt — a 30-minute window expired with no acknowledgement, so code re-issued with a fresh version (by derivation), immediately claimable (no backoff). This tick does NOT issue them; the NEXT tick's `scan-publish-intent` claims them. Log only.
+   - `skipped` = window still open or evidence absent — log only, take no action.
+   - Never stamp provenance from prose. Never infer a verdict from an inspector's summary text. The exact version string is the sole positive signal.
 
 5. **Monitor launched workflows until terminal (stay-alive — 2026-09-13):** The platform ties async workflow `agent()` authorization to the launcher's lifetime: if THIS tick ends while a workflow is still running, the workflow's next `agent()` call fails with "subagent bootstrap is no longer authorized" / "subagent reservation owner is terminal". Prevention beats recovery here, so this tick is configured with a 90-minute execution timeout (`timeout_secs: 5400` in seed/crons.json) and you MUST stay alive until every launched run reaches a terminal state. Do not exit early while a launched run is still `running` — your death is what kills it.
    - For each launched run_id, poll its status every ~2 minutes via muse.db:

package/seed/crons.json

@@ -23,6 +23,18 @@
       },
       "timeout_secs": 600,
       "title": "Muse Crew automatic update watcher"
+    },
+    {
+      "body_template": "cron-body-ack-scan.md",
+      "enabled": true,
+      "id": "crew-ack-scan",
+      "mode": "task",
+      "schedule": {
+        "every": "5m",
+        "kind": "interval"
+      },
+      "timeout_secs": 600,
+      "title": "Muse Crew acknowledgement scan"
     }
   ],
   "version": 1