muse-crew 0.13.0 → 0.13.1

package/API.md

@@ -124,6 +124,9 @@ Create or update an agent session record. Sessions track which identity is worki
 | `notes` | string (≤ 3000) | no | |
 | `failure_reason` | string (≤ 3000) or null | no | |
 | `caveats` | array of `{text, severity}` | no | |
+| `already_merged_sha` | 7–40 lowercase hex or null | no | **Do not set this yourself.** The workflow sets it automatically when it verifies that a task's work is already on the main branch (e.g., landed by a prior run). Written by workflow code (not by the agent's text output) after the `rev-parse` + `merge-base --is-ancestor` check passes; a bad value is a usage error. Review loads it from the field instead of parsing the notes. Null semantics: omitting the field preserves the existing value; passing explicit `null` clears it. `record-phase` always preserves (it never clears). |
+
+The `already_merged_sha` field exists because session `notes` are hard-capped at 3000 chars: a truthful already-merged declaration at the tail of a long Build report was silently truncated, and Review could not recover it. The sha is managed by the workflow — the workflow writes it after verification, and downstream phases read the field, never the agent's text.
 
 ### `heartbeat-session`
 

package/docs/guide.md

@@ -34,7 +34,7 @@ When this guide says "call an action," it means calling an action defined in the
 - A Muse account with access to workflows, crons, and artifacts.
 - The `muse-crew` package installed via npm, or the repo cloned locally.
 - A directory chosen for the crew home (e.g., `~/workspace/.jarvis`).
-- A task service artifact already created. The [Orchestra Dashboard](https://github.com/emojimanegg1/orchestra-dashboard) is the reference implementation — clone its repo, create the artifact, and note its slug.
+- A task service artifact already created. (An "artifact" is a Muse platform primitive — a hosted web app created through the Muse UI. The crew never creates artifacts; it only edits existing ones.) The [Orchestra Dashboard](https://github.com/emojimanegg1/orchestra-dashboard) is the reference implementation — clone its repo, create an artifact from it via the Muse UI, and note its slug. **Rule: every `deploy_slug` must point to an artifact that already exists.** Init checks that `~/workspace/ts-spaces/<slug>/` exists and will stop with an error if it doesn't — without this check, the first task would reach Publish and fail with a confusing error message. Publish edits an existing artifact; it never creates one.
 
 ### Running init
 

package/docs/publish-verification.md

@@ -46,8 +46,12 @@ The workflow dropped the report entirely on 2026-09-16 (clean-room task
 `e2a8d9f8`): the trigger's JSON closeout contract traveled over the
 stochastic text channel and the runtime's JSON-candidate heuristic misfired
 on its prose ("workflow agent output was not JSON"), parking a task whose
-edit may have gone through. The trigger is now awaited-but-unconsumed — no schema,
-no consumed return value — and there is no builder report to observe:
+edit may have gone through. The trigger is now awaited and scanned for a
+single explicit refusal signal — `ARTIFACT_EDIT_REFUSED: <text>` as the
+entire trimmed turn output — and nothing else is consumed from the return.
+An exact refusal is conclusive negative evidence (parks `rejected`, skips
+observation polling); any other output (including prose quoting the signal)
+is inconclusive and follows the existing fail-closed observation path.
 `applied_report` is `missing-report` on ledger lines for issued triggers
 (pre-trigger parks and unattributed-unknown parks write null — no trigger
 was observed, so there is nothing to report). The

package/lib/crew-api.js

@@ -65,6 +65,20 @@ function validateEnvironmentType(value) {
   throw usageError("environment_type must be 'artifact', 'terminal', or null.");
 }
 
+// already_merged_sha validation (room #16 blocker 11, 2026-09-18): the
+// workflow-verified already-merged sha as structured session control state.
+// undefined means "not provided" (preserves the existing value); explicit
+// null clears the field; otherwise a 7-40 hex string, normalized to
+// lowercase. Anything else is a usage error. The CHECK constraint in
+// schema.sql enforces the same shape at the SQL layer.
+// layer; this is the API-boundary validation.
+function validateAlreadyMergedSha(value) {
+  if (value === undefined || value === null) return null;
+  const s = String(value).trim().toLowerCase();
+  if (/^[0-9a-f]{7,40}$/.test(s)) return s;
+  throw usageError("already_merged_sha must be a 7-40 char hex string or null.");
+}
+
 // ---------------------------------------------------------------------------
 // Crew home resolution (fail closed)
 // ---------------------------------------------------------------------------
@@ -249,6 +263,23 @@ function openDb(crewHome) {
         if (!/duplicate column name/i.test(e.message)) throw e;
       }
     }
+    // Migration: add already_merged_sha column if missing (room #16 blocker
+    // 11, 2026-09-18). The workflow-verified already-merged sha as structured
+    // control state — Build's declaration used to travel to Review only
+    // through session notes, which are hard-capped at 3000 chars
+    // (record-phase below), so a truthful declaration at the report's tail
+    // never arrived. The workflow writes the sha here itself after the
+    // mechanical ancestor check; NULL = no verified declaration. Same
+    // idempotent PRAGMA-check pattern; no backfill (a missing value means
+    // "not verified", never fabricated).
+    if (!cols.some((c) => c.name === "already_merged_sha")) {
+      try {
+        db.exec("ALTER TABLE agent_sessions ADD COLUMN already_merged_sha TEXT CHECK (already_merged_sha IS NULL OR (already_merged_sha NOT GLOB '*[^0-9a-f]*' AND length(already_merged_sha) BETWEEN 7 AND 40))");
+      } catch (e) {
+        // Another process may have added it concurrently; ignore duplicate-column errors.
+        if (!/duplicate column name/i.test(e.message)) throw e;
+      }
+    }
     const projectCols = db.prepare("PRAGMA table_info(projects)").all();
     // Migration: add visual_protocol column if missing (per-project visual
     // protocol toggle, 2026-09-12). Same idempotent PRAGMA-check pattern;
@@ -376,6 +407,10 @@ function mapSession(row) {
     caveats: parseCaveats(row.caveats),
     failure_reason: row.failure_reason,
     last_heartbeat: row.last_heartbeat ?? null,
+    // Room #16 blocker 11: the workflow-verified already-merged sha (NULL
+    // when no verified declaration). Structured control state — Review
+    // hydrates from this field, never from capped prose.
+    already_merged_sha: row.already_merged_sha ?? null,
   };
 }
 
@@ -1340,18 +1375,24 @@ commands["upsert-session"] = (db, args) => {
     caveats: args.caveats === undefined ? (current?.caveats ?? "[]") : JSON.stringify(args.caveats),
     failure_reason: args.failure_reason === undefined ? (current?.failure_reason ?? null) : args.failure_reason,
     last_heartbeat: now(),
+    // Room #16 blocker 11: preserve the verified sha across upserts unless
+    // explicitly provided (validated at the API boundary).
+    already_merged_sha: args.already_merged_sha === undefined
+      ? (current?.already_merged_sha ?? null)
+      : validateAlreadyMergedSha(args.already_merged_sha),
   };
   if (current) {
     db.prepare(
       `UPDATE agent_sessions SET task_id=@task_id, identity=@identity, step=@step,
        status=@status, started_at=@started_at, ended_at=@ended_at, notes=@notes,
-       caveats=@caveats, failure_reason=@failure_reason, last_heartbeat=@last_heartbeat WHERE id=@id`).run(row);
+       caveats=@caveats, failure_reason=@failure_reason, last_heartbeat=@last_heartbeat,
+       already_merged_sha=@already_merged_sha WHERE id=@id`).run(row);
   } else {
     db.prepare(
       `INSERT INTO agent_sessions (id, task_id, identity, step, status, started_at,
-        ended_at, notes, caveats, failure_reason, last_heartbeat)
+        ended_at, notes, caveats, failure_reason, last_heartbeat, already_merged_sha)
        VALUES (@id, @task_id, @identity, @step, @status, @started_at,
-        @ended_at, @notes, @caveats, @failure_reason, @last_heartbeat)
+        @ended_at, @notes, @caveats, @failure_reason, @last_heartbeat, @already_merged_sha)
        ON CONFLICT DO NOTHING`).run(row);
   }
   return { session: mapSession(row) };
@@ -1715,6 +1756,10 @@ commands["record-phase"] = (db, args) => {
     caveats: session.caveats === undefined ? "[]" : JSON.stringify(session.caveats),
     failure_reason: session.failure_reason ?? null,
     last_heartbeat: timestamp,
+    // Room #16 blocker 11: the workflow-verified already-merged sha, written
+    // by the workflow itself after the mechanical ancestor check — never
+    // builder prose. Validated at the API boundary; NULL = not verified.
+    already_merged_sha: validateAlreadyMergedSha(session.already_merged_sha),
   };
   const eventRow = {
     id: uuid(), type: event.type, task_id: args.task_id,
@@ -1724,12 +1769,15 @@ commands["record-phase"] = (db, args) => {
   try {
     db.prepare(
       `INSERT INTO agent_sessions (id, task_id, identity, step, status, started_at,
-        ended_at, notes, caveats, failure_reason, last_heartbeat)
+        ended_at, notes, caveats, failure_reason, last_heartbeat, already_merged_sha)
        VALUES (@id, @task_id, @identity, @step, @status, @started_at,
-        @ended_at, @notes, @caveats, @failure_reason, @last_heartbeat)
+        @ended_at, @notes, @caveats, @failure_reason, @last_heartbeat, @already_merged_sha)
+       -- record-phase never clears already_merged_sha: a phase record is not a
+       -- field update, so both undefined and null preserve the existing value.
        ON CONFLICT(id) DO UPDATE SET status=@status, ended_at=@ended_at,
         notes=@notes, caveats=@caveats, failure_reason=@failure_reason,
-        last_heartbeat=@last_heartbeat`).run(sessionRow);
+        last_heartbeat=@last_heartbeat,
+        already_merged_sha=COALESCE(@already_merged_sha, already_merged_sha)`).run(sessionRow);
     db.prepare(
       `INSERT INTO events (id, type, task_id, identity, message, timestamp)
        VALUES (@id, @type, @task_id, @identity, @message, @timestamp)`).run(eventRow);

package/lib/schema.sql

@@ -93,7 +93,19 @@ CREATE TABLE IF NOT EXISTS agent_sessions (
   notes          TEXT NOT NULL DEFAULT '',
   caveats        TEXT NOT NULL DEFAULT '[]',
   failure_reason TEXT,
-  last_heartbeat TEXT
+  last_heartbeat TEXT,
+  -- Room #16 blocker 11 (2026-09-18): the workflow-verified already-merged
+  -- sha as structured control state. Build's `repo_diff: none
+  -- (already-merged: <sha>)` declaration used to travel to Review only
+  -- through capped prose (session notes are truncated at 3000 chars), so a
+  -- truthful declaration at the report's tail never arrived. The workflow
+  -- writes the sha here itself after the mechanical ancestor check — the
+  -- column is workflow-owned, never builder prose. NULL = no verified
+  -- declaration for this session. The CHECK enforces the full shape:
+  -- 7-40 lowercase hex chars (NOT GLOB '*[^0-9a-f]*' means no non-hex char
+  -- anywhere — GLOB '[0-9a-f]*' alone would only check the first char).
+  already_merged_sha TEXT CHECK (already_merged_sha IS NULL OR
+    (already_merged_sha NOT GLOB '*[^0-9a-f]*' AND length(already_merged_sha) BETWEEN 7 AND 40))
 );
 
 CREATE TABLE IF NOT EXISTS events (

package/package.json

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

package/workflows/bugfix.js

@@ -549,14 +549,34 @@ function extractMarkerLines(workerText) {
 // builder correctly makes no commit because the deliverable is already on
 // main (a prior merge or hand-repair landed it), it declares
 // `repo_diff: none (already-merged: <sha>)` naming the main commit that
-// carries the work. The sha is hex-only (7-40 chars) so the workflow can
-// interpolate it into the mechanical ancestor check without injection
-// risk. Pure — pinned byte-identical across standard/bugfix/chore.
+// carries the work. Room #16 blocker 11 (2026-09-18): the line anchor
+// missed Wren's mid-paragraph declaration, and the persisted notes truncated
+// the tail — so the anchor is gone and a sha followed by `)`, whitespace, or
+// end-of-string (truncation) is accepted. The sha is hex-only (7-40 chars)
+// so the workflow can interpolate it into the mechanical ancestor check
+// without injection risk; a over-long hex run never matches (the lookahead
+// fails on the extra hex char). Pure — pinned byte-identical across
+// standard/bugfix/chore.
 function extractAlreadyMerged(workerText) {
-  var m = /^repo_diff:\s*none\s*\(already-merged:\s*([0-9a-f]{7,40})\)/im.exec(workerText || "");
+  var m = /repo_diff:\s*none\s*\(already-merged:\s*([0-9a-f]{7,40})(?=[\s)]|$)/i.exec(workerText || "");
   return m ? { sha: m[1].toLowerCase() } : { sha: null };
 }
 
+// Explicit artifact refusal (room #16 blocker 10, 2026-09-18): the rebuild
+// trigger child ends its turn with `ARTIFACT_EDIT_REFUSED: <text>` when
+// artifact_edit explicitly refuses the edit (e.g. the artifact does not
+// exist). A refusal is conclusive negative evidence — the edit provably did
+// NOT go through — distinct from an unconsumed trigger return (unknown).
+// Pure — pinned byte-identical across standard/bugfix/chore.
+// The signal must be the ENTIRE trimmed turn output (not a line within prose):
+// the trigger child is instructed to end its turn with exactly this line and
+// nothing else. A confused child quoting the instructions back in prose must
+// NOT produce a conclusive negative — that degrades to unknown (fail-closed).
+function extractRefusal(workerText) {
+  var m = /^ARTIFACT_EDIT_REFUSED:\s*(.+?)\s*$/.exec(String(workerText || "").trim());
+  return m ? m[1].slice(0, 300) : null;
+}
+
 // Worktree confinement: the Build agent must declare the exact worktree
 // path it built in on a `worktree:` marker line. The workflow compares it
 // against WORKTREE_HINT mechanically (exact string match) — never by
@@ -1378,23 +1398,40 @@ while (i < STEPS.length) {
   } else if (step.name === "Review") {
     // Already-merged hydration: when this run did not execute Build itself
     // (dispatcher resume at Review after a platform death between phases),
-    // recover the workflow-attested verification from the latest completed
-    // Build session notes. The `already_merged_verified:` line was written
-    // by the workflow after a mechanical ancestor check — it is trusted;
-    // the builder's bare declaration never is. Absent the line, the
-    // mechanical fact below reads "none declared" and Cass fails closed.
+    // recover the workflow-verified sha. Room #16 blocker 11: the structured
+    // session field is read FIRST — the `already_merged_verified:` notes line
+    // is only a fallback, because session notes are hard-capped at 3000
+    // chars and a truthful declaration at the report's tail was silently
+    // truncated. The structured value was written by the workflow after a
+    // mechanical ancestor check — it is trusted; the builder's bare
+    // declaration never is. Absent both, the mechanical fact below reads
+    // "none declared" and Cass fails closed. The hydration read is best-effort:
+    // a transport throw degrades to "none declared" rather than crashing Review.
     if (!alreadyMergedSha) {
-      var hydNotes = await agent(
-        "Read the latest completed Build session notes for task " + taskId + ".\n" +
-        "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
-        "In the returned sessions array, find the most recent session (by started_at) with task_id \"" + taskId + "\", step \"Build\", and status \"completed\". Return ONLY its notes field, verbatim, with no commentary.",
-        { key: "hydrate-already-merged" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Hydrating already-merged verification" }
-      );
-      var hydStr = (typeof hydNotes === "string") ? hydNotes : JSON.stringify(hydNotes);
-      var hvm = /already_merged_verified:\s*([0-9a-f]{7,40})/i.exec(hydStr);
-      if (hvm) {
-        alreadyMergedSha = hvm[1].toLowerCase();
-        log("Hydrated already-merged verification from Build session notes: " + alreadyMergedSha);
+      var hydResult = null;
+      try {
+        hydResult = await agent(
+          "Read the latest completed Build session for task " + taskId + ".\n" +
+          "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
+          "In the returned sessions array, find the most recent session (by started_at) with task_id \"" + taskId + "\", step \"Build\", and status \"completed\". Return exactly two sections, verbatim, with no commentary:\n" +
+          "SHA: <the session's already_merged_sha field value, or the word null when it is null>\n" +
+          "NOTES:\n<the session's notes field, verbatim>",
+          { key: "hydrate-already-merged" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Hydrating already-merged verification" }
+        );
+      } catch (hydErr) {
+        log("Hydration read failed (" + String(hydErr && hydErr.message || hydErr) + "); treating as none declared.");
+      }
+      var hydStr = hydResult ? ((typeof hydResult === "string") ? hydResult : JSON.stringify(hydResult)) : "";
+      var hydSha = /^SHA:\s*([0-9a-f]{7,40})\s*$/im.exec(hydStr);
+      if (hydSha) {
+        alreadyMergedSha = hydSha[1].toLowerCase();
+        log("Hydrated already-merged verification from structured session field: " + alreadyMergedSha);
+      } else {
+        var hvm = /already_merged_verified:\s*([0-9a-f]{7,40})/i.exec(hydStr);
+        if (hvm) {
+          alreadyMergedSha = hvm[1].toLowerCase();
+          log("Hydrated already-merged verification from Build session notes (fallback): " + alreadyMergedSha);
+        }
       }
     }
     instructions = "Review independently and cold. You have NOT seen any reasoning from the builder.\nDo NOT access the task dashboard, event log, or any comments. Your review is based solely on the spec and the code.\n\n" +
@@ -1537,6 +1574,85 @@ while (i < STEPS.length) {
         // Skipped entirely when no lock was held — nothing merged, nothing
         // to ship.
         if (!publishSkippedNoLock) {
+        // The trigger key of the attempt that last ran, for the publish ledger.
+        // Minted once here (not re-minted per use site) so the ledger always
+        // records the exact key that was issued — and so a re-minted duplicate
+        // can never drift from it. Defined before the preflight so pre-trigger
+        // parks (room #16 blocker 10) record the same attempt key.
+        var rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId, totalReworkCount);
+        // STEP 0.5 (mechanical, room #16 blocker 10): assert the artifact
+        // target exists before any artifact_status / artifact_edit call. The
+        // project was classified as an artifact surface (deploy_slug set),
+        // but setup never provisioned the artifact — Publish then entered
+        // the trigger path against a slug with no on-disk target and the
+        // edit failed opaquely ("web artifact <slug> was not found on
+        // disk"), which the ledger could only record as unknown. A missing
+        // target is conclusive negative evidence: the edit provably did NOT
+        // go through, so this parks rejected (not unknown) with the actual
+        // missing path — no trigger issued, no blind retry, no observation
+        // polling. The check is a pure filesystem stat; the path is
+        // workflow-computed, never agent prose. An inconclusive check
+        // (throw / unparseable signal) is fail-closed unknown: without
+        // proof the target exists, no edit is issued. The slug is
+        // interpolated into a shell command — a slug outside [a-zA-Z0-9_-]
+        // (e.g. from a hand-edited space.json) is treated as inconclusive
+        // rather than risking shell injection.
+        var artifactTargetDir = "~/workspace/ts-spaces/" + PUBLISH_SLUG + "/";
+        var preflightSignal = "";
+        var preflightInconclusive = false;
+        // Misconfiguration fast path: artifact surface with no slug is not a
+        // signal problem — it's a project setup defect. Park rejected with a
+        // truthful reason, not "inconclusive."
+        if (!PUBLISH_SLUG) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: null,
+            applied_report: null,
+            outcome: "rejected",
+            detail: "artifact surface with empty deploy_slug (preflight): the project is classified as artifact but has no deploy_slug — misconfiguration, not a missing artifact. No edit was issued."
+          }, totalReworkCount);
+          return await parkTask("Publish cannot proceed for task " + taskId + ": the project is classified as an artifact surface but has no deploy_slug. This is a project configuration defect — set a deploy_slug for the project, then re-run Publish. Human attention needed.");
+        }
+        if (!/^[a-zA-Z0-9_-]+$/.test(PUBLISH_SLUG)) {
+          preflightInconclusive = true;
+          log("Publish artifact preflight for task " + taskId + ": PUBLISH_SLUG has an unsafe shape — inconclusive, fail-closed");
+        } else try {
+          var preflight = await agent(
+            "Check whether the artifact target directory exists.\n" +
+            "Run in shell: test -d ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/ && echo ARTIFACT_TARGET: present || echo ARTIFACT_TARGET: missing\n" +
+            "Return JSON { \"signal\": \"<the exact ARTIFACT_TARGET line>\" } and nothing else.",
+            { key: attemptKey("publish-artifact-preflight-" + taskId, totalReworkCount), label: "Checking artifact target exists",
+              schema: { type: "object", properties: { signal: { type: "string" } }, required: ["signal"] } }
+          );
+          preflightSignal = String((preflight && preflight.signal) || "");
+        } catch (preflightErr) {
+          preflightInconclusive = true;
+          log("Publish artifact preflight for task " + taskId + " threw (" + (preflightErr && preflightErr.message ? preflightErr.message : preflightErr) + ") — inconclusive, fail-closed");
+        }
+        if (!preflightInconclusive && /ARTIFACT_TARGET:\s*missing/.test(preflightSignal)) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: null,
+            applied_report: null,
+            outcome: "rejected",
+            detail: "artifact target directory missing (preflight): " + artifactTargetDir + " does not exist — setup never provisioned the artifact for deploy_slug " + PUBLISH_SLUG + ". The edit provably did not go through: no trigger issued, no blind retry"
+          }, totalReworkCount);
+          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact target directory " + artifactTargetDir + " does not exist. The project is classified as an artifact surface (deploy_slug " + PUBLISH_SLUG + ") but setup never provisioned the artifact — this is conclusive (rejected, not unknown): no edit was issued. Create the artifact via the Muse UI (Publish edits an existing artifact; it never creates one), then re-run init and Publish. Human attention needed.");
+        }
+        if (preflightInconclusive || !/ARTIFACT_TARGET:\s*present/.test(preflightSignal)) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: null,
+            applied_report: null,
+            outcome: "unknown",
+            detail: "artifact preflight inconclusive (no parsable ARTIFACT_TARGET signal): target existence unproven, so the trigger was NOT issued; unknown parks fail closed with no blind retry"
+          }, totalReworkCount);
+          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact target preflight was inconclusive (no parsable signal). Target existence is unproven, so no edit was issued and nothing was retried blindly. Human attention needed.");
+        }
+        log("Publish artifact preflight for task " + taskId + ": target " + artifactTargetDir + " present");
         // (below) the diff computation, rebuild trigger, application
         // verification, bounded poll, and provenance stamp. The builder
         // only makes the artifact_edit call and reports the applied
@@ -1647,14 +1763,10 @@ while (i < STEPS.length) {
           "- After applying, rebuild and deploy.'\n" +
           "Edit-request contract (read carefully):\n" +
           "- 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.\n" +
+          "- 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>.\n" +
           "- If artifact_edit is not available after the load, do NOT improvise — end your turn.\n" +
           "- You do NOT call setprovenance, artifact_inspect, or post-deploy yourself.\n" +
           "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.\n";
-        // The trigger key of the attempt that last ran, for the publish ledger.
-        // Minted once here (not re-minted per use site) so the ledger always
-        // records the exact key that was issued — and so a re-minted duplicate
-        // can never drift from it.
-        var rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId, totalReworkCount);
         // The artifact build's agent_id, attributed to this edit by the
         // workflow-owned observation below. The agent_id is the artifact
         // system's in-flight correlation ID (research 2026-09-12):
@@ -1820,9 +1932,27 @@ while (i < STEPS.length) {
         // re-trigger duplicated the edit on 2026-09-12).
         var rebuildTrigger = null;
         try {
-          var triggerResultLength = String(await agent(rebuildPrompt,
-            { key: rebuildAttemptKey, label: "Triggering artifact rebuild" }) || "").length;
-          log("Publish rebuild trigger for task " + taskId + " returned (" + triggerResultLength + " chars; awaited but return intentionally unconsumed)");
+          var triggerText = String(await agent(rebuildPrompt,
+            { key: rebuildAttemptKey, label: "Triggering artifact rebuild" }) || "");
+          log("Publish rebuild trigger for task " + taskId + " returned (" + triggerText.length + " chars; awaited; scanned only for the explicit refusal signal)");
+          // Explicit refusal (room #16 blocker 10): the child ends its turn
+          // with ARTIFACT_EDIT_REFUSED when artifact_edit explicitly refused.
+          // Conclusive negative evidence — the edit provably did NOT go
+          // through — so this parks rejected and skips observation polling.
+          // A missing/unparseable signal is NOT a refusal: it stays unknown
+          // and fail-closed below.
+          var refusalText = extractRefusal(triggerText);
+          if (refusalText) {
+            await recordPublishLedger({
+              commit: mergeCommitForPublish,
+              attempt: rebuildAttemptKey,
+              agent_id: null,
+              applied_report: null,
+              outcome: "rejected",
+              detail: "artifact_edit explicitly refused the edit (parsed ARTIFACT_EDIT_REFUSED signal): " + refusalText + " — conclusive negative: the edit provably did not go through, no observation polling, no blind retry"
+            }, totalReworkCount);
+            return await parkTask("Publish cannot proceed for task " + taskId + ": artifact_edit explicitly refused the edit (" + refusalText + "). This is conclusive (rejected, not unknown): the edit did not go through. Repair or provision the artifact target, then re-run Publish. Human attention needed.");
+          }
         } catch (triggerErr) {
           log("Publish rebuild trigger for task " + taskId + " threw (" + (triggerErr && triggerErr.message ? triggerErr.message : triggerErr) + ") — outcome unknown until observation confirms it; the edit may have gone through");
         }
@@ -3062,8 +3192,12 @@ while (i < STEPS.length) {
     "Update the session and log the event.\n" +
     "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
       task_id: taskId,
+      // Room #16 blocker 11: the workflow-verified already-merged sha as
+      // structured control state. Only the Build gate sets alreadyMergedSha
+      // (after the mechanical ancestor check); the API validates the shape
+      // and a later write without the field never clears it (COALESCE).
       session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name,
-        status: status, notes: summary },
+        status: status, notes: summary, already_merged_sha: (step.name === "Build" ? alreadyMergedSha : null) },
       event: { task_id: taskId, type: status, identity: step.identity,
         message: step.name + " " + status + " by " + step.identity }
     }),
@@ -3096,6 +3230,15 @@ while (i < STEPS.length) {
       return await parkTask("Exceeded shared rework budget (" + MAX_TOTAL_REWORK + " total rework attempts across Review and QA) after " + step.name + " rejection. Worktree preserved.");
     }
     rejectionNotes = summary;
+    // Already-merged corrective (room #16 blocker 11): when Review rejected
+    // an empty branch but the work is already on main (the workflow verified
+    // the sha), Wren must declare it — not re-implement or re-commit
+    // already-landed work. Scoped to the empty-branch rejection; any other
+    // rejection already carries its own specific notes.
+    if (step.name === "Review" && alreadyMergedSha && /no commits ahead of main/i.test(summary)) {
+      rejectionNotes += "\n\nCORRECTIVE (from the workflow, not the reviewer): the deliverable is already on main — the workflow mechanically verified that " + alreadyMergedSha + " is an ancestor of main. Do NOT re-implement the work and do NOT create a new commit for it. In your Build report, declare exactly: repo_diff: none (already-merged: " + alreadyMergedSha + ") — then end with VERDICT: PASS.";
+      log("Rework corrective appended for task " + taskId + ": already-merged " + alreadyMergedSha + " — Wren must declare, not rebuild");
+    }
     i = BUILD_INDEX;
     log(step.name + " rejected — bouncing to Build (rework #" + totalReworkCount + " of " + MAX_TOTAL_REWORK + ")");
     continue;

package/workflows/chore.js

@@ -601,14 +601,34 @@ function extractMarkerLines(workerText) {
 // builder correctly makes no commit because the deliverable is already on
 // main (a prior merge or hand-repair landed it), it declares
 // `repo_diff: none (already-merged: <sha>)` naming the main commit that
-// carries the work. The sha is hex-only (7-40 chars) so the workflow can
-// interpolate it into the mechanical ancestor check without injection
-// risk. Pure — pinned byte-identical across standard/bugfix/chore.
+// carries the work. Room #16 blocker 11 (2026-09-18): the line anchor
+// missed Wren's mid-paragraph declaration, and the persisted notes truncated
+// the tail — so the anchor is gone and a sha followed by `)`, whitespace, or
+// end-of-string (truncation) is accepted. The sha is hex-only (7-40 chars)
+// so the workflow can interpolate it into the mechanical ancestor check
+// without injection risk; a over-long hex run never matches (the lookahead
+// fails on the extra hex char). Pure — pinned byte-identical across
+// standard/bugfix/chore.
 function extractAlreadyMerged(workerText) {
-  var m = /^repo_diff:\s*none\s*\(already-merged:\s*([0-9a-f]{7,40})\)/im.exec(workerText || "");
+  var m = /repo_diff:\s*none\s*\(already-merged:\s*([0-9a-f]{7,40})(?=[\s)]|$)/i.exec(workerText || "");
   return m ? { sha: m[1].toLowerCase() } : { sha: null };
 }
 
+// Explicit artifact refusal (room #16 blocker 10, 2026-09-18): the rebuild
+// trigger child ends its turn with `ARTIFACT_EDIT_REFUSED: <text>` when
+// artifact_edit explicitly refuses the edit (e.g. the artifact does not
+// exist). A refusal is conclusive negative evidence — the edit provably did
+// NOT go through — distinct from an unconsumed trigger return (unknown).
+// Pure — pinned byte-identical across standard/bugfix/chore.
+// The signal must be the ENTIRE trimmed turn output (not a line within prose):
+// the trigger child is instructed to end its turn with exactly this line and
+// nothing else. A confused child quoting the instructions back in prose must
+// NOT produce a conclusive negative — that degrades to unknown (fail-closed).
+function extractRefusal(workerText) {
+  var m = /^ARTIFACT_EDIT_REFUSED:\s*(.+?)\s*$/.exec(String(workerText || "").trim());
+  return m ? m[1].slice(0, 300) : null;
+}
+
 // Worktree confinement: the Build agent must declare the exact worktree
 // path it built in on a `worktree:` marker line. The workflow compares it
 // against WORKTREE_HINT mechanically (exact string match) — never by
@@ -1265,23 +1285,40 @@ while (i < STEPS.length) {
   } else if (step.name === "Review") {
     // Already-merged hydration: when this run did not execute Build itself
     // (dispatcher resume at Review after a platform death between phases),
-    // recover the workflow-attested verification from the latest completed
-    // Build session notes. The `already_merged_verified:` line was written
-    // by the workflow after a mechanical ancestor check — it is trusted;
-    // the builder's bare declaration never is. Absent the line, the
-    // mechanical fact below reads "none declared" and Cass fails closed.
+    // recover the workflow-verified sha. Room #16 blocker 11: the structured
+    // session field is read FIRST — the `already_merged_verified:` notes line
+    // is only a fallback, because session notes are hard-capped at 3000
+    // chars and a truthful declaration at the report's tail was silently
+    // truncated. The structured value was written by the workflow after a
+    // mechanical ancestor check — it is trusted; the builder's bare
+    // declaration never is. Absent both, the mechanical fact below reads
+    // "none declared" and Cass fails closed. The hydration read is best-effort:
+    // a transport throw degrades to "none declared" rather than crashing Review.
     if (!alreadyMergedSha) {
-      var hydNotes = await agent(
-        "Read the latest completed Build session notes for task " + taskId + ".\n" +
-        "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
-        "In the returned sessions array, find the most recent session (by started_at) with task_id \"" + taskId + "\", step \"Build\", and status \"completed\". Return ONLY its notes field, verbatim, with no commentary.",
-        { key: "hydrate-already-merged" + (reworkCount > 0 ? "-r" + reworkCount : ""), label: "Hydrating already-merged verification" }
-      );
-      var hydStr = (typeof hydNotes === "string") ? hydNotes : JSON.stringify(hydNotes);
-      var hvm = /already_merged_verified:\s*([0-9a-f]{7,40})/i.exec(hydStr);
-      if (hvm) {
-        alreadyMergedSha = hvm[1].toLowerCase();
-        log("Hydrated already-merged verification from Build session notes: " + alreadyMergedSha);
+      var hydResult = null;
+      try {
+        hydResult = await agent(
+          "Read the latest completed Build session for task " + taskId + ".\n" +
+          "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
+          "In the returned sessions array, find the most recent session (by started_at) with task_id \"" + taskId + "\", step \"Build\", and status \"completed\". Return exactly two sections, verbatim, with no commentary:\n" +
+          "SHA: <the session's already_merged_sha field value, or the word null when it is null>\n" +
+          "NOTES:\n<the session's notes field, verbatim>",
+          { key: "hydrate-already-merged" + (reworkCount > 0 ? "-r" + reworkCount : ""), label: "Hydrating already-merged verification" }
+        );
+      } catch (hydErr) {
+        log("Hydration read failed (" + String(hydErr && hydErr.message || hydErr) + "); treating as none declared.");
+      }
+      var hydStr = hydResult ? ((typeof hydResult === "string") ? hydResult : JSON.stringify(hydResult)) : "";
+      var hydSha = /^SHA:\s*([0-9a-f]{7,40})\s*$/im.exec(hydStr);
+      if (hydSha) {
+        alreadyMergedSha = hydSha[1].toLowerCase();
+        log("Hydrated already-merged verification from structured session field: " + alreadyMergedSha);
+      } else {
+        var hvm = /already_merged_verified:\s*([0-9a-f]{7,40})/i.exec(hydStr);
+        if (hvm) {
+          alreadyMergedSha = hvm[1].toLowerCase();
+          log("Hydrated already-merged verification from Build session notes (fallback): " + alreadyMergedSha);
+        }
       }
     }
     instructions = "Review independently and cold. No prior context from the builder.\nDo NOT access the task dashboard, event log, or any comments. Your review is based solely on the spec and the code.\n\n" +
@@ -1424,6 +1461,85 @@ while (i < STEPS.length) {
         // Skipped entirely when no lock was held — nothing merged, nothing
         // to ship.
         if (!publishSkippedNoLock) {
+        // The trigger key of the attempt that last ran, for the publish ledger.
+        // Minted once here (not re-minted per use site) so the ledger always
+        // records the exact key that was issued — and so a re-minted duplicate
+        // can never drift from it. Defined before the preflight so pre-trigger
+        // parks (room #16 blocker 10) record the same attempt key.
+        var rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId, reworkCount);
+        // STEP 0.5 (mechanical, room #16 blocker 10): assert the artifact
+        // target exists before any artifact_status / artifact_edit call. The
+        // project was classified as an artifact surface (deploy_slug set),
+        // but setup never provisioned the artifact — Publish then entered
+        // the trigger path against a slug with no on-disk target and the
+        // edit failed opaquely ("web artifact <slug> was not found on
+        // disk"), which the ledger could only record as unknown. A missing
+        // target is conclusive negative evidence: the edit provably did NOT
+        // go through, so this parks rejected (not unknown) with the actual
+        // missing path — no trigger issued, no blind retry, no observation
+        // polling. The check is a pure filesystem stat; the path is
+        // workflow-computed, never agent prose. An inconclusive check
+        // (throw / unparseable signal) is fail-closed unknown: without
+        // proof the target exists, no edit is issued. The slug is
+        // interpolated into a shell command — a slug outside [a-zA-Z0-9_-]
+        // (e.g. from a hand-edited space.json) is treated as inconclusive
+        // rather than risking shell injection.
+        var artifactTargetDir = "~/workspace/ts-spaces/" + PUBLISH_SLUG + "/";
+        var preflightSignal = "";
+        var preflightInconclusive = false;
+        // Misconfiguration fast path: artifact surface with no slug is not a
+        // signal problem — it's a project setup defect. Park rejected with a
+        // truthful reason, not "inconclusive."
+        if (!PUBLISH_SLUG) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: null,
+            applied_report: null,
+            outcome: "rejected",
+            detail: "artifact surface with empty deploy_slug (preflight): the project is classified as artifact but has no deploy_slug — misconfiguration, not a missing artifact. No edit was issued."
+          }, reworkCount);
+          return await parkTask("Publish cannot proceed for task " + taskId + ": the project is classified as an artifact surface but has no deploy_slug. This is a project configuration defect — set a deploy_slug for the project, then re-run Publish. Human attention needed.");
+        }
+        if (!/^[a-zA-Z0-9_-]+$/.test(PUBLISH_SLUG)) {
+          preflightInconclusive = true;
+          log("Publish artifact preflight for task " + taskId + ": PUBLISH_SLUG has an unsafe shape — inconclusive, fail-closed");
+        } else try {
+          var preflight = await agent(
+            "Check whether the artifact target directory exists.\n" +
+            "Run in shell: test -d ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/ && echo ARTIFACT_TARGET: present || echo ARTIFACT_TARGET: missing\n" +
+            "Return JSON { \"signal\": \"<the exact ARTIFACT_TARGET line>\" } and nothing else.",
+            { key: attemptKey("publish-artifact-preflight-" + taskId, reworkCount), label: "Checking artifact target exists",
+              schema: { type: "object", properties: { signal: { type: "string" } }, required: ["signal"] } }
+          );
+          preflightSignal = String((preflight && preflight.signal) || "");
+        } catch (preflightErr) {
+          preflightInconclusive = true;
+          log("Publish artifact preflight for task " + taskId + " threw (" + (preflightErr && preflightErr.message ? preflightErr.message : preflightErr) + ") — inconclusive, fail-closed");
+        }
+        if (!preflightInconclusive && /ARTIFACT_TARGET:\s*missing/.test(preflightSignal)) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: null,
+            applied_report: null,
+            outcome: "rejected",
+            detail: "artifact target directory missing (preflight): " + artifactTargetDir + " does not exist — setup never provisioned the artifact for deploy_slug " + PUBLISH_SLUG + ". The edit provably did not go through: no trigger issued, no blind retry"
+          }, reworkCount);
+          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact target directory " + artifactTargetDir + " does not exist. The project is classified as an artifact surface (deploy_slug " + PUBLISH_SLUG + ") but setup never provisioned the artifact — this is conclusive (rejected, not unknown): no edit was issued. Create the artifact via the Muse UI (Publish edits an existing artifact; it never creates one), then re-run init and Publish. Human attention needed.");
+        }
+        if (preflightInconclusive || !/ARTIFACT_TARGET:\s*present/.test(preflightSignal)) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: null,
+            applied_report: null,
+            outcome: "unknown",
+            detail: "artifact preflight inconclusive (no parsable ARTIFACT_TARGET signal): target existence unproven, so the trigger was NOT issued; unknown parks fail closed with no blind retry"
+          }, reworkCount);
+          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact target preflight was inconclusive (no parsable signal). Target existence is unproven, so no edit was issued and nothing was retried blindly. Human attention needed.");
+        }
+        log("Publish artifact preflight for task " + taskId + ": target " + artifactTargetDir + " present");
         // (below) the diff computation, rebuild trigger, application
         // verification, bounded poll, and provenance stamp. The builder
         // only makes the artifact_edit call and reports the applied
@@ -1534,14 +1650,10 @@ while (i < STEPS.length) {
           "- After applying, rebuild and deploy.'\n" +
           "Edit-request contract (read carefully):\n" +
           "- 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.\n" +
+          "- 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>.\n" +
           "- If artifact_edit is not available after the load, do NOT improvise — end your turn.\n" +
           "- You do NOT call setprovenance, artifact_inspect, or post-deploy yourself.\n" +
           "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.\n";
-        // The trigger key of the attempt that last ran, for the publish ledger.
-        // Minted once here (not re-minted per use site) so the ledger always
-        // records the exact key that was issued — and so a re-minted duplicate
-        // can never drift from it.
-        var rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId, reworkCount);
         // The artifact build's agent_id, attributed to this edit by the
         // workflow-owned observation below. The agent_id is the artifact
         // system's in-flight correlation ID (research 2026-09-12):
@@ -1707,9 +1819,27 @@ while (i < STEPS.length) {
         // re-trigger duplicated the edit on 2026-09-12).
         var rebuildTrigger = null;
         try {
-          var triggerResultLength = String(await agent(rebuildPrompt,
-            { key: rebuildAttemptKey, label: "Triggering artifact rebuild" }) || "").length;
-          log("Publish rebuild trigger for task " + taskId + " returned (" + triggerResultLength + " chars; awaited but return intentionally unconsumed)");
+          var triggerText = String(await agent(rebuildPrompt,
+            { key: rebuildAttemptKey, label: "Triggering artifact rebuild" }) || "");
+          log("Publish rebuild trigger for task " + taskId + " returned (" + triggerText.length + " chars; awaited; scanned only for the explicit refusal signal)");
+          // Explicit refusal (room #16 blocker 10): the child ends its turn
+          // with ARTIFACT_EDIT_REFUSED when artifact_edit explicitly refused.
+          // Conclusive negative evidence — the edit provably did NOT go
+          // through — so this parks rejected and skips observation polling.
+          // A missing/unparseable signal is NOT a refusal: it stays unknown
+          // and fail-closed below.
+          var refusalText = extractRefusal(triggerText);
+          if (refusalText) {
+            await recordPublishLedger({
+              commit: mergeCommitForPublish,
+              attempt: rebuildAttemptKey,
+              agent_id: null,
+              applied_report: null,
+              outcome: "rejected",
+              detail: "artifact_edit explicitly refused the edit (parsed ARTIFACT_EDIT_REFUSED signal): " + refusalText + " — conclusive negative: the edit provably did not go through, no observation polling, no blind retry"
+            }, reworkCount);
+            return await parkTask("Publish cannot proceed for task " + taskId + ": artifact_edit explicitly refused the edit (" + refusalText + "). This is conclusive (rejected, not unknown): the edit did not go through. Repair or provision the artifact target, then re-run Publish. Human attention needed.");
+          }
         } catch (triggerErr) {
           log("Publish rebuild trigger for task " + taskId + " threw (" + (triggerErr && triggerErr.message ? triggerErr.message : triggerErr) + ") — outcome unknown until observation confirms it; the edit may have gone through");
         }
@@ -2624,7 +2754,11 @@ while (i < STEPS.length) {
     "Update session and log event.\n" +
     "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
       task_id: taskId,
-      session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: status, notes: summary },
+      // Room #16 blocker 11: the workflow-verified already-merged sha as
+      // structured control state. Only the Build gate sets alreadyMergedSha
+      // (after the mechanical ancestor check); the API validates the shape
+      // and a later write without the field never clears it (COALESCE).
+      session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: status, notes: summary, already_merged_sha: (step.name === "Build" ? alreadyMergedSha : null) },
       event: { task_id: taskId, type: status, identity: step.identity, message: step.name + " " + status + " by " + step.identity }
     }) + "\n",
     {
@@ -2640,6 +2774,15 @@ while (i < STEPS.length) {
       return await parkTask("Exceeded " + MAX_REWORK + " rework attempts after Review rejection. Worktree preserved.");
     }
     rejectionNotes = summary;
+    // Already-merged corrective (room #16 blocker 11): when Review rejected
+    // an empty branch but the work is already on main (the workflow verified
+    // the sha), Wren must declare it — not re-implement or re-commit
+    // already-landed work. Scoped to the empty-branch rejection; any other
+    // rejection already carries its own specific notes.
+    if (step.name === "Review" && alreadyMergedSha && /no commits ahead of main/i.test(summary)) {
+      rejectionNotes += "\n\nCORRECTIVE (from the workflow, not the reviewer): the deliverable is already on main — the workflow mechanically verified that " + alreadyMergedSha + " is an ancestor of main. Do NOT re-implement the work and do NOT create a new commit for it. In your Build report, declare exactly: repo_diff: none (already-merged: " + alreadyMergedSha + ") — then end with VERDICT: PASS.";
+      log("Rework corrective appended for task " + taskId + ": already-merged " + alreadyMergedSha + " — Wren must declare, not rebuild");
+    }
     i = BUILD_INDEX;
     log("Review rejected — bouncing to Build (rework #" + reworkCount + ")");
     continue;

package/workflows/crew-init.js

@@ -429,6 +429,45 @@ if (projectResult && projectResult.action === "created" &&
 }
 } // end dashboard-mode project registration
 
+// ── Artifact target verification (room #16 blocker 10, 2026-09-18) ──
+// Setup owns the invariant: deploy_slug ⇒ artifact exists. The dashboard
+// project is registered with deploy_slug = dashboardSlug, but registration
+// alone does not create the artifact — the artifact is a platform primitive
+// created by the human via the Muse UI (docs/guide.md prerequisite: "A task
+// service artifact already created"). If the target directory is missing,
+// init blocks loudly: a dangling deploy_slug would otherwise let the first
+// task reach Publish and fail opaquely. This is not a provisioner — the
+// human creates the artifact; init only verifies and refuses to proceed
+// without it.
+if (dashboardSlug) {
+  // The slug is interpolated into a shell command — reject an unsafe shape
+  // rather than risking injection (dashboardSlug comes from init args).
+  if (!/^[a-zA-Z0-9_-]+$/.test(dashboardSlug)) {
+    return { __hatchWorkflowControl: "blocked", result: {
+      blocked_reason: "Dashboard slug has an unsafe shape",
+      message: "dashboardSlug \"" + dashboardSlug + "\" contains characters outside [a-zA-Z0-9_-]. The slug is used in shell paths and as the artifact key — choose a safe slug and re-run init."
+    } };
+  }
+  var artifactTargetCheck = await agent(
+    "Verify the dashboard artifact target exists.\n" +
+    "Run in shell: test -d ~/workspace/ts-spaces/" + dashboardSlug + "/ && echo ARTIFACT_TARGET: present || echo ARTIFACT_TARGET: missing\n" +
+    "Return JSON { \"signal\": \"<the exact ARTIFACT_TARGET line>\" } and nothing else.",
+    {
+      key: "artifact-target-verify",
+      label: "Verifying dashboard artifact target exists",
+      schema: { type: "object", properties: { signal: { type: "string" } }, required: ["signal"] }
+    }
+  );
+  var artifactSignal = String((artifactTargetCheck && artifactTargetCheck.signal) || "");
+  if (!/ARTIFACT_TARGET:\s*present/.test(artifactSignal)) {
+    return { __hatchWorkflowControl: "blocked", result: {
+      blocked_reason: "Dashboard artifact target missing",
+      message: "The dashboard project is registered with deploy_slug \"" + dashboardSlug + "\", but the artifact target directory ~/workspace/ts-spaces/" + dashboardSlug + "/ does not exist. An artifact is a Muse platform primitive (a hosted web app) — the crew never creates artifacts, it only edits existing ones. Create the artifact from your dashboard repo via the Muse UI first (see docs/guide.md prerequisites), then re-run init. Init will not complete with a deploy_slug that points to nothing: the first task's Publish would otherwise fail with a confusing error."
+    } };
+  }
+  log("Artifact target verified: ~/workspace/ts-spaces/" + dashboardSlug + "/ exists");
+}
+
 // ── Project repo setup (2026-09-18) ─────────────────────────────────
 // One deterministic composer — lib/setup-project-repo.js — scaffolds
 // $REPO/.orchestration/, applies the consented .gitignore update, and COMMITS

package/workflows/standard.js

@@ -561,14 +561,34 @@ function extractMarkerLines(workerText) {
 // builder correctly makes no commit because the deliverable is already on
 // main (a prior merge or hand-repair landed it), it declares
 // `repo_diff: none (already-merged: <sha>)` naming the main commit that
-// carries the work. The sha is hex-only (7-40 chars) so the workflow can
-// interpolate it into the mechanical ancestor check without injection
-// risk. Pure — pinned byte-identical across standard/bugfix/chore.
+// carries the work. Room #16 blocker 11 (2026-09-18): the line anchor
+// missed Wren's mid-paragraph declaration, and the persisted notes truncated
+// the tail — so the anchor is gone and a sha followed by `)`, whitespace, or
+// end-of-string (truncation) is accepted. The sha is hex-only (7-40 chars)
+// so the workflow can interpolate it into the mechanical ancestor check
+// without injection risk; a over-long hex run never matches (the lookahead
+// fails on the extra hex char). Pure — pinned byte-identical across
+// standard/bugfix/chore.
 function extractAlreadyMerged(workerText) {
-  var m = /^repo_diff:\s*none\s*\(already-merged:\s*([0-9a-f]{7,40})\)/im.exec(workerText || "");
+  var m = /repo_diff:\s*none\s*\(already-merged:\s*([0-9a-f]{7,40})(?=[\s)]|$)/i.exec(workerText || "");
   return m ? { sha: m[1].toLowerCase() } : { sha: null };
 }
 
+// Explicit artifact refusal (room #16 blocker 10, 2026-09-18): the rebuild
+// trigger child ends its turn with `ARTIFACT_EDIT_REFUSED: <text>` when
+// artifact_edit explicitly refuses the edit (e.g. the artifact does not
+// exist). A refusal is conclusive negative evidence — the edit provably did
+// NOT go through — distinct from an unconsumed trigger return (unknown).
+// Pure — pinned byte-identical across standard/bugfix/chore.
+// The signal must be the ENTIRE trimmed turn output (not a line within prose):
+// the trigger child is instructed to end its turn with exactly this line and
+// nothing else. A confused child quoting the instructions back in prose must
+// NOT produce a conclusive negative — that degrades to unknown (fail-closed).
+function extractRefusal(workerText) {
+  var m = /^ARTIFACT_EDIT_REFUSED:\s*(.+?)\s*$/.exec(String(workerText || "").trim());
+  return m ? m[1].slice(0, 300) : null;
+}
+
 // Worktree confinement: the Build agent must declare the exact worktree
 // path it built in on a `worktree:` marker line. The workflow compares it
 // against WORKTREE_HINT mechanically (exact string match) — never by
@@ -1259,23 +1279,40 @@ while (i < STEPS.length) {
   } else if (step.name === "Review") {
     // Already-merged hydration: when this run did not execute Build itself
     // (dispatcher resume at Review after a platform death between phases),
-    // recover the workflow-attested verification from the latest completed
-    // Build session notes. The `already_merged_verified:` line was written
-    // by the workflow after a mechanical ancestor check — it is trusted;
-    // the builder's bare declaration never is. Absent the line, the
-    // mechanical fact below reads "none declared" and Cass fails closed.
+    // recover the workflow-verified sha. Room #16 blocker 11: the structured
+    // session field is read FIRST — the `already_merged_verified:` notes line
+    // is only a fallback, because session notes are hard-capped at 3000
+    // chars and a truthful declaration at the report's tail was silently
+    // truncated. The structured value was written by the workflow after a
+    // mechanical ancestor check — it is trusted; the builder's bare
+    // declaration never is. Absent both, the mechanical fact below reads
+    // "none declared" and Cass fails closed. The hydration read is best-effort:
+    // a transport throw degrades to "none declared" rather than crashing Review.
     if (!alreadyMergedSha) {
-      var hydNotes = await agent(
-        "Read the latest completed Build session notes for task " + taskId + ".\n" +
-        "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
-        "In the returned sessions array, find the most recent session (by started_at) with task_id \"" + taskId + "\", step \"Build\", and status \"completed\". Return ONLY its notes field, verbatim, with no commentary.",
-        { key: "hydrate-already-merged" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Hydrating already-merged verification" }
-      );
-      var hydStr = (typeof hydNotes === "string") ? hydNotes : JSON.stringify(hydNotes);
-      var hvm = /already_merged_verified:\s*([0-9a-f]{7,40})/i.exec(hydStr);
-      if (hvm) {
-        alreadyMergedSha = hvm[1].toLowerCase();
-        log("Hydrated already-merged verification from Build session notes: " + alreadyMergedSha);
+      var hydResult = null;
+      try {
+        hydResult = await agent(
+          "Read the latest completed Build session for task " + taskId + ".\n" +
+          "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
+          "In the returned sessions array, find the most recent session (by started_at) with task_id \"" + taskId + "\", step \"Build\", and status \"completed\". Return exactly two sections, verbatim, with no commentary:\n" +
+          "SHA: <the session's already_merged_sha field value, or the word null when it is null>\n" +
+          "NOTES:\n<the session's notes field, verbatim>",
+          { key: "hydrate-already-merged" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Hydrating already-merged verification" }
+        );
+      } catch (hydErr) {
+        log("Hydration read failed (" + String(hydErr && hydErr.message || hydErr) + "); treating as none declared.");
+      }
+      var hydStr = hydResult ? ((typeof hydResult === "string") ? hydResult : JSON.stringify(hydResult)) : "";
+      var hydSha = /^SHA:\s*([0-9a-f]{7,40})\s*$/im.exec(hydStr);
+      if (hydSha) {
+        alreadyMergedSha = hydSha[1].toLowerCase();
+        log("Hydrated already-merged verification from structured session field: " + alreadyMergedSha);
+      } else {
+        var hvm = /already_merged_verified:\s*([0-9a-f]{7,40})/i.exec(hydStr);
+        if (hvm) {
+          alreadyMergedSha = hvm[1].toLowerCase();
+          log("Hydrated already-merged verification from Build session notes (fallback): " + alreadyMergedSha);
+        }
       }
     }
     instructions = "Review independently and cold. You have NOT seen any reasoning from the builder.\nDo NOT access the task dashboard, event log, or any comments. Your review is based solely on the spec and the code.\n\n" +
@@ -1418,6 +1455,85 @@ while (i < STEPS.length) {
         // Skipped entirely when no lock was held — nothing merged, nothing
         // to ship.
         if (!publishSkippedNoLock) {
+        // The trigger key of the attempt that last ran, for the publish ledger.
+        // Minted once here (not re-minted per use site) so the ledger always
+        // records the exact key that was issued — and so a re-minted duplicate
+        // can never drift from it. Defined before the preflight so pre-trigger
+        // parks (room #16 blocker 10) record the same attempt key.
+        var rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId, totalReworkCount);
+        // STEP 0.5 (mechanical, room #16 blocker 10): assert the artifact
+        // target exists before any artifact_status / artifact_edit call. The
+        // project was classified as an artifact surface (deploy_slug set),
+        // but setup never provisioned the artifact — Publish then entered
+        // the trigger path against a slug with no on-disk target and the
+        // edit failed opaquely ("web artifact <slug> was not found on
+        // disk"), which the ledger could only record as unknown. A missing
+        // target is conclusive negative evidence: the edit provably did NOT
+        // go through, so this parks rejected (not unknown) with the actual
+        // missing path — no trigger issued, no blind retry, no observation
+        // polling. The check is a pure filesystem stat; the path is
+        // workflow-computed, never agent prose. An inconclusive check
+        // (throw / unparseable signal) is fail-closed unknown: without
+        // proof the target exists, no edit is issued. The slug is
+        // interpolated into a shell command — a slug outside [a-zA-Z0-9_-]
+        // (e.g. from a hand-edited space.json) is treated as inconclusive
+        // rather than risking shell injection.
+        var artifactTargetDir = "~/workspace/ts-spaces/" + PUBLISH_SLUG + "/";
+        var preflightSignal = "";
+        var preflightInconclusive = false;
+        // Misconfiguration fast path: artifact surface with no slug is not a
+        // signal problem — it's a project setup defect. Park rejected with a
+        // truthful reason, not "inconclusive."
+        if (!PUBLISH_SLUG) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: null,
+            applied_report: null,
+            outcome: "rejected",
+            detail: "artifact surface with empty deploy_slug (preflight): the project is classified as artifact but has no deploy_slug — misconfiguration, not a missing artifact. No edit was issued."
+          }, totalReworkCount);
+          return await parkTask("Publish cannot proceed for task " + taskId + ": the project is classified as an artifact surface but has no deploy_slug. This is a project configuration defect — set a deploy_slug for the project, then re-run Publish. Human attention needed.");
+        }
+        if (!/^[a-zA-Z0-9_-]+$/.test(PUBLISH_SLUG)) {
+          preflightInconclusive = true;
+          log("Publish artifact preflight for task " + taskId + ": PUBLISH_SLUG has an unsafe shape — inconclusive, fail-closed");
+        } else try {
+          var preflight = await agent(
+            "Check whether the artifact target directory exists.\n" +
+            "Run in shell: test -d ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/ && echo ARTIFACT_TARGET: present || echo ARTIFACT_TARGET: missing\n" +
+            "Return JSON { \"signal\": \"<the exact ARTIFACT_TARGET line>\" } and nothing else.",
+            { key: attemptKey("publish-artifact-preflight-" + taskId, totalReworkCount), label: "Checking artifact target exists",
+              schema: { type: "object", properties: { signal: { type: "string" } }, required: ["signal"] } }
+          );
+          preflightSignal = String((preflight && preflight.signal) || "");
+        } catch (preflightErr) {
+          preflightInconclusive = true;
+          log("Publish artifact preflight for task " + taskId + " threw (" + (preflightErr && preflightErr.message ? preflightErr.message : preflightErr) + ") — inconclusive, fail-closed");
+        }
+        if (!preflightInconclusive && /ARTIFACT_TARGET:\s*missing/.test(preflightSignal)) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: null,
+            applied_report: null,
+            outcome: "rejected",
+            detail: "artifact target directory missing (preflight): " + artifactTargetDir + " does not exist — setup never provisioned the artifact for deploy_slug " + PUBLISH_SLUG + ". The edit provably did not go through: no trigger issued, no blind retry"
+          }, totalReworkCount);
+          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact target directory " + artifactTargetDir + " does not exist. The project is classified as an artifact surface (deploy_slug " + PUBLISH_SLUG + ") but setup never provisioned the artifact — this is conclusive (rejected, not unknown): no edit was issued. Create the artifact via the Muse UI (Publish edits an existing artifact; it never creates one), then re-run init and Publish. Human attention needed.");
+        }
+        if (preflightInconclusive || !/ARTIFACT_TARGET:\s*present/.test(preflightSignal)) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: null,
+            applied_report: null,
+            outcome: "unknown",
+            detail: "artifact preflight inconclusive (no parsable ARTIFACT_TARGET signal): target existence unproven, so the trigger was NOT issued; unknown parks fail closed with no blind retry"
+          }, totalReworkCount);
+          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact target preflight was inconclusive (no parsable signal). Target existence is unproven, so no edit was issued and nothing was retried blindly. Human attention needed.");
+        }
+        log("Publish artifact preflight for task " + taskId + ": target " + artifactTargetDir + " present");
         // (below) the diff computation, rebuild trigger, application
         // verification, bounded poll, and provenance stamp. The builder
         // only makes the artifact_edit call and reports the applied
@@ -1528,14 +1644,10 @@ while (i < STEPS.length) {
           "- After applying, rebuild and deploy.'\n" +
           "Edit-request contract (read carefully):\n" +
           "- 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.\n" +
+          "- 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>.\n" +
           "- If artifact_edit is not available after the load, do NOT improvise — end your turn.\n" +
           "- You do NOT call setprovenance, artifact_inspect, or post-deploy yourself.\n" +
           "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.\n";
-        // The trigger key of the attempt that last ran, for the publish ledger.
-        // Minted once here (not re-minted per use site) so the ledger always
-        // records the exact key that was issued — and so a re-minted duplicate
-        // can never drift from it.
-        var rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId, totalReworkCount);
         // The artifact build's agent_id, attributed to this edit by the
         // workflow-owned observation below. The agent_id is the artifact
         // system's in-flight correlation ID (research 2026-09-12):
@@ -1701,9 +1813,27 @@ while (i < STEPS.length) {
         // re-trigger duplicated the edit on 2026-09-12).
         var rebuildTrigger = null;
         try {
-          var triggerResultLength = String(await agent(rebuildPrompt,
-            { key: rebuildAttemptKey, label: "Triggering artifact rebuild" }) || "").length;
-          log("Publish rebuild trigger for task " + taskId + " returned (" + triggerResultLength + " chars; awaited but return intentionally unconsumed)");
+          var triggerText = String(await agent(rebuildPrompt,
+            { key: rebuildAttemptKey, label: "Triggering artifact rebuild" }) || "");
+          log("Publish rebuild trigger for task " + taskId + " returned (" + triggerText.length + " chars; awaited; scanned only for the explicit refusal signal)");
+          // Explicit refusal (room #16 blocker 10): the child ends its turn
+          // with ARTIFACT_EDIT_REFUSED when artifact_edit explicitly refused.
+          // Conclusive negative evidence — the edit provably did NOT go
+          // through — so this parks rejected and skips observation polling.
+          // A missing/unparseable signal is NOT a refusal: it stays unknown
+          // and fail-closed below.
+          var refusalText = extractRefusal(triggerText);
+          if (refusalText) {
+            await recordPublishLedger({
+              commit: mergeCommitForPublish,
+              attempt: rebuildAttemptKey,
+              agent_id: null,
+              applied_report: null,
+              outcome: "rejected",
+              detail: "artifact_edit explicitly refused the edit (parsed ARTIFACT_EDIT_REFUSED signal): " + refusalText + " — conclusive negative: the edit provably did not go through, no observation polling, no blind retry"
+            }, totalReworkCount);
+            return await parkTask("Publish cannot proceed for task " + taskId + ": artifact_edit explicitly refused the edit (" + refusalText + "). This is conclusive (rejected, not unknown): the edit did not go through. Repair or provision the artifact target, then re-run Publish. Human attention needed.");
+          }
         } catch (triggerErr) {
           log("Publish rebuild trigger for task " + taskId + " threw (" + (triggerErr && triggerErr.message ? triggerErr.message : triggerErr) + ") — outcome unknown until observation confirms it; the edit may have gone through");
         }
@@ -2818,7 +2948,11 @@ while (i < STEPS.length) {
     "Update the session and log the event.\n" +
     "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
       task_id: taskId,
-      session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: status, notes: summary },
+      // Room #16 blocker 11: the workflow-verified already-merged sha as
+      // structured control state. Only the Build gate sets alreadyMergedSha
+      // (after the mechanical ancestor check); the API validates the shape
+      // and a later write without the field never clears it (COALESCE).
+      session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: status, notes: summary, already_merged_sha: (step.name === "Build" ? alreadyMergedSha : null) },
       event: { task_id: taskId, type: status, identity: step.identity, message: step.name + " " + status + " by " + step.identity }
     }),
     {
@@ -2835,6 +2969,15 @@ while (i < STEPS.length) {
       return await parkTask("Exceeded shared rework budget (" + MAX_TOTAL_REWORK + " total rework attempts across Review and QA) after " + step.name + " rejection. Worktree preserved.");
     }
     rejectionNotes = summary;
+    // Already-merged corrective (room #16 blocker 11): when Review rejected
+    // an empty branch but the work is already on main (the workflow verified
+    // the sha), Wren must declare it — not re-implement or re-commit
+    // already-landed work. Scoped to the empty-branch rejection; any other
+    // rejection already carries its own specific notes.
+    if (step.name === "Review" && alreadyMergedSha && /no commits ahead of main/i.test(summary)) {
+      rejectionNotes += "\n\nCORRECTIVE (from the workflow, not the reviewer): the deliverable is already on main — the workflow mechanically verified that " + alreadyMergedSha + " is an ancestor of main. Do NOT re-implement the work and do NOT create a new commit for it. In your Build report, declare exactly: repo_diff: none (already-merged: " + alreadyMergedSha + ") — then end with VERDICT: PASS.";
+      log("Rework corrective appended for task " + taskId + ": already-merged " + alreadyMergedSha + " — Wren must declare, not rebuild");
+    }
     i = BUILD_INDEX;
     log(step.name + " rejected — bouncing to Build (rework #" + totalReworkCount + " of " + MAX_TOTAL_REWORK + ")");
     continue;