muse-crew 0.7.9 → 0.7.11

package/workflows/chore.js

@@ -529,52 +529,22 @@ function verifyAppliedChanges(expected, applied) {
   return { ok: true };
 }
 
-// Publish read-back request builder: the verbatim_request the workflow hands
-// to artifact_inspect (via a child) after the artifact build lands. Pure
-// function — no I/O, no clock. The request carries the merged diff as the
-// expected change and asks for an independent read of the artifact's actual
-// source: for each file, the exact current text of the changed regions plus
-// a per-line present/absent finding. The parent (docs/publish-verification.md)
-// compares these findings against the diff mechanically and stamps provenance
-// only on a match. This breaks the circularity that hollowed canary run 8
-// (2026-09-11): verifyAppliedChanges compares the builder's applied-report
-// against the diff the report was derived from — a fabricated report passes
-// by construction. Independent read-back cannot be fabricated from the diff;
-// it must match the artifact's real content.
-function buildPublishReadbackRequest(taskId, commit, diff, buildAgentId) {
-  // Build-ID correlation (2026-09-12): buildAgentId is the build.agent_id the
-  // workflow observed for the publish attempt (the artifact system's in-flight
-  // build correlation ID — not a durable post-completion identifier). The read-back request carries it so the parent can
-  // prove the read-back inspected the live build of THIS attempt — not a
-  // different build's output. Null/empty means the edit was accepted but
-  // never correlated to a builder run. Pure function of inputs — no I/O,
-  // no clock.
-  var buildIdLine = (typeof buildAgentId === "string" && buildAgentId.length > 0)
-    ? "Expected builder build agent_id: " + buildAgentId + " (the artifact system's in-flight correlation ID for this publish attempt — not a durable post-completion identifier).\n"
-    : "No build agent_id was observed for this publish attempt (the edit was accepted but never correlated to a builder run) — say so explicitly in your report.\n";
-  return (
-    "Publish content read-back for task " + taskId + ", merge commit " + commit + ".\n" +
-    "The unified diff below was supposed to be applied to this artifact's source tree and deployed. Do NOT modify anything.\n" +
-    "Do NOT rely on the builder's applied-changes report — it is derived from this same diff, so it cannot confirm the content. Read the artifact's CURRENT source directly.\n" +
-    "\n" +
-    buildIdLine +
-    "Report the live build's agent_id as seen in artifact_status (or state explicitly that no build/agent_id is visible). If an expected agent_id is given above and the live one differs, say so exactly — the read-back may be inspecting a different build's output.\n" +
-    "\n" +
-    "UNIFIED DIFF (expected change):\n" +
-    "```diff\n" + diff + "\n```\n" +
-    "\n" +
-    "For each file in the diff:\n" +
-    "1. Read the file's CURRENT content in the artifact source tree.\n" +
-    "2. Quote the exact current text of the regions around the changed lines.\n" +
-    "3. For every added (+) line in the diff, state whether that exact line is PRESENT in the current source.\n" +
-    "4. For every removed (-) line in the diff, state whether that exact line is ABSENT from the current source.\n" +
-    "5. Report build/deploy health and the console error count.\n" +
-    "\n" +
-    "Return the per-file present/absent findings with the quoted observed lines. Do not modify anything.\n" +
-    "This read-back feeds the parent content-verification protocol (docs/publish-verification.md): the parent stamps provenance only when every added line is present and every removed line is absent."
-  );
-}
-
+// Publish read-back request (currently unavailable): the verbatim_request
+// the parent protocol (docs/publish-verification.md) would hand to an
+// independent read-back tool after the artifact build lands. artifact_inspect
+// was removed by the platform (2026-09-14); artifact.inspect is malfunction
+// diagnosis, not a substitute — so no agent-callable read-back tool exists
+// and this request cannot currently be issued. Pure function — no I/O, no
+// clock. The request carries the merged diff as the expected change and asks
+// for an independent read of the artifact's actual source: for each file, the
+// exact current text of the changed regions plus a per-line present/absent
+// finding. Until a read-back path exists, the parent cannot independently
+// confirm content and verification parks at "publish: verification-requested"
+// (see docs/publish-verification.md). This preserves the circularity break
+// that hollowed canary run 8 (2026-09-11): verifyAppliedChanges compares the
+// builder's applied-report against the diff the report was derived from — a
+// fabricated report passes by construction. Independent read-back cannot be
+// fabricated from the diff; it must match the artifact's real content.
 // Pre-publish base observation (diagnostic, 2026-09-12): instruction fragment
 // for the builder's edit request, asking it to report the sha256 of each
 // touched file's CURRENT content BEFORE applying the diff. Pure function —
@@ -1260,7 +1230,7 @@ while (i < STEPS.length) {
   var instructions = "";
 
   if (step.name === "Triage") {
-    instructions = "Validate the task, check clarity, note dependencies, confirm the chore workflow assignment.\nReport back in plain prose — what you found.\nEXPERIENTIAL FLAG: does this task change anything rendered and visible in the project's user-facing artifact (pages, components, styles, layout, copy, visual states)? If yes it is experiential and gets baseline captures. End your report with exactly one line on its own, lowercase, unrephrased: experiential: yes — or experiential: no. This line is machine-read.";
+    instructions = "Validate the task against the project's repo at " + REPO_PATH + " — that exact checkout, not any other copy of the project on disk. If you run git commands, cd " + REPO_PATH + " first.\nCheck clarity, note dependencies, confirm the chore workflow assignment.\nReport back in plain prose — what you found.\nEXPERIENTIAL FLAG: does this task change anything rendered and visible in the project's user-facing artifact (pages, components, styles, layout, copy, visual states)? If yes it is experiential and gets baseline captures. End your report with exactly one line on its own, lowercase, unrephrased: experiential: yes — or experiential: no. This line is machine-read.";
 
   } else if (step.name === "Map") {
     var mapGatePara = "";
@@ -1272,7 +1242,7 @@ while (i < STEPS.length) {
         " If the baseline evidence is missing with no baseline:none recorded, do not write the spec — report 'baseline evidence missing — Map gate bounce required' and stop.\n" +
         "Declare capture targets for the post-change visual capture: end your report with a line `capture_targets: <comma-separated views/controls this change affects>` (optional; falls back to the task description).";
     }
-    instructions = "Research options, pick the path, write a clear spec for the builder.\nThe builder will edit source files in a git worktree of the project at " + REPO_PATH + ".\nProject: " + PROJECT_DESC + "\nTo understand the current code, read source files directly using the read tool. Do NOT use artifact_inspect — it is async and will not return in time.\nIdentify the exact files and changes needed. Be specific: file paths, what to add or change.\nReport back in plain prose — what you specified." + mapGatePara;
+    instructions = "Research options, pick the path, write a clear spec for the builder.\nThe builder will edit source files in a git worktree of the project at " + REPO_PATH + ".\nProject: " + PROJECT_DESC + "\nTo understand the current code, read source files directly using the read tool. Do NOT use artifact_inspect — it was removed by the platform (2026-09-14) and does not exist; do not substitute artifact.inspect (malfunction diagnosis, not an inspection tool).\nIdentify the exact files and changes needed. Be specific: file paths, what to add or change.\nReport back in plain prose — what you specified." + mapGatePara;
 
   } else if (step.name === "Build") {
     instructions = "STEP 1: Prepare your worktree.\n" +
@@ -1388,11 +1358,12 @@ while (i < STEPS.length) {
       // (fail-closed). There is deliberately NO workflow-side provenance
       // stamp: the builder's applied-report is circular (canary run 8,
       // 2026-09-11), so the stamp moved to the parent — after the build
-      // lands, the workflow triggers an independent artifact_inspect
-      // read-back, records the session completed, and parks with
-      // "publish: verification-requested". The parent stamps provenance only
-      // after the read-back confirms the content (docs/publish-verification.md);
-      // Chore has no QA: the parent's stamp read-back is the final gate.
+      // lands, the workflow records the session completed and parks with
+      // "publish: verification-requested". The parent owns verification
+      // (docs/publish-verification.md); the independent read-back step is
+      // currently unavailable (no agent-callable read-back tool exists —
+      // artifact_inspect was removed by the platform 2026-09-14).
+      // Chore has no QA: the parent's verification is the final gate.
       var artifactPublish = null;
       var publishLockRefreshed = false;
       var publishSkippedNoLock = false;
@@ -1440,14 +1411,45 @@ while (i < STEPS.length) {
         // changes — no prose claim to trust. If the artifact tool namespace
         // is missing from this child it reports honestly and the workflow
         // retries once with a fresh key (bounded); anything else parks.
+        // Publish diff base (2026-09-14, task 0c53af4e): the carried diff is
+        // BASE..HEAD where BASE is the previously-stamped provenance
+        // source_commit — NOT HEAD^1. A push-time reconcile merge puts the
+        // task's own changes behind an intermediate merge, so HEAD^1..HEAD
+        // silently drops the task's fix while the artifact builds without
+        // it. The stamped base is the artifact's actual content; BASE..HEAD
+        // is the complete unpublished delta. Empty tree only for a genuine
+        // first publish (no provenance stamped yet).
+        var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+        var provResult = await agent(
+          crewCmd("get-provenance", {}) + "\n" +
+          "Return JSON { \"provenance\": <the CLI's provenance object, or null when nothing is stamped> } and nothing else. Do not interpret it.",
+          { key: attemptKey("publish-provenance-base-" + taskId, reworkCount), label: "Reading stamped publish base",
+            schema: { type: "object", properties: { provenance: { type: ["object", "null"] } }, required: ["provenance"] } }
+        );
+        var publishBase = (provResult.provenance && provResult.provenance.source_commit) || "";
+        publishBase = String(publishBase).trim();
+        if (!publishBase) {
+          publishBase = EMPTY_TREE_SHA;
+          log("Publish base for task " + taskId + ": no provenance stamped yet — using empty tree (first publish)");
+        } else if (!/^[0-9a-f]{40}$/.test(publishBase)) {
+          return await parkTask("Publish base '" + publishBase + "' is not a valid commit SHA — cannot compute the publish diff. Human attention needed.");
+        }
         var diffResult = await agent(
-          "Run: cd " + REPO_PATH + " && git rev-parse HEAD && echo '---PARENT---' && git rev-parse HEAD^1 && echo '---DIFF---' && git diff HEAD^1 HEAD && echo '---NAMES---' && git diff-tree --no-commit-id --name-only -r HEAD\n" +
-          "Return JSON { \"commit\": \"<HEAD trimmed>\", \"parent\": \"<HEAD^1 trimmed>\", \"diff\": \"<raw unified diff, may be multi-line>\", \"files\": \"<newline-separated paths>\" } and nothing else.",
-          { key: attemptKey("publish-artifact-diff-" + taskId, reworkCount), label: "Computing merged diff for publish",
-            schema: { type: "object", properties: { commit: { type: "string" }, parent: { type: "string" }, diff: { type: "string" }, files: { type: "string" } }, required: ["commit", "diff"] } }
+          "Run: cd " + REPO_PATH + " && BASE='" + publishBase + "' && HEAD=$(git rev-parse HEAD) && " +
+          "if [ \"$BASE\" = '" + EMPTY_TREE_SHA + "' ]; then ANCESTOR=yes; else git merge-base --is-ancestor \"$BASE\" \"$HEAD\" && ANCESTOR=yes || ANCESTOR=no; fi && " +
+          "echo '---COMMIT---' && echo \"$HEAD\" && echo '---BASE---' && echo \"$BASE\" && echo '---ANCESTOR---' && echo \"$ANCESTOR\" && " +
+          "if [ \"$ANCESTOR\" = yes ]; then echo '---DIFF---' && git diff \"$BASE\" \"$HEAD\" && echo '---NAMES---' && git diff-tree --no-commit-id --name-only -r \"$BASE\" \"$HEAD\"; fi\n" +
+          "Return JSON { \"commit\": \"<HEAD trimmed>\", \"base\": \"<BASE trimmed>\", \"ancestor\": \"<yes|no>\", \"diff\": \"<raw unified diff, may be multi-line>\", \"files\": \"<newline-separated paths>\" } and nothing else.",
+          { key: attemptKey("publish-artifact-diff-" + taskId, reworkCount), label: "Computing publish diff from stamped base",
+            schema: { type: "object", properties: { commit: { type: "string" }, base: { type: "string" }, ancestor: { type: "string" }, diff: { type: "string" }, files: { type: "string" } }, required: ["commit", "base", "ancestor", "diff"] } }
         );
+        if ((diffResult.ancestor || "").trim() !== "yes") {
+          return await parkTask("Publish base " + publishBase.slice(0, 12) + " is not an ancestor of HEAD " + (diffResult.commit || "").trim().slice(0, 12) + " — the stamped provenance does not lead to the integrated commit. Human attention needed.");
+        }
+        if ((diffResult.base || "").trim() !== publishBase) {
+          return await parkTask("Publish diff base mismatch: agent reported '" + (diffResult.base || "").trim().slice(0, 12) + "' but the stamped base is '" + publishBase.slice(0, 12) + "'. Human attention needed.");
+        }
         var mergeCommitForPublish = (diffResult.commit || "").trim();
-        var mergeParentForPublish = (diffResult.parent || "").trim();
         var mergeDiff = diffResult.diff || "";
         if (!mergeDiff.trim()) {
           return await parkTask("Publish diff is empty for commit " + (mergeCommitForPublish || "unknown") + " — a merge lock was held but there is no change to carry. Human attention needed.");
@@ -1458,11 +1460,15 @@ while (i < STEPS.length) {
         if (/^rename from /m.test(mergeDiff)) {
           return await parkTask("Publish diff contains a rename — the diff transport cannot carry renames. Human attention needed.");
         }
-        var mergeDiffLines = mergeDiff.split("\n").length;
-        if (mergeDiffLines > 200) {
-          return await parkTask("Publish diff is " + mergeDiffLines + " lines (budget 200) — too large for the diff transport. Human attention needed.");
-        }
         var expectedChanges = parseUnifiedDiff(mergeDiff);
+        // Budget counts CHANGED lines (added + removed), not raw unified-diff
+        // output lines: context lines and file headers inflated the old
+        // split("\n").length count ~2x, parking a 95-line change against a
+        // 200-line budget (Gate 1 Journey 3 attempt 3, 2026-09-13).
+        var mergeDiffChangedLines = expectedChanges.reduce(function (n, f) { return n + f.added.length + f.removed.length; }, 0);
+        if (mergeDiffChangedLines > 200) {
+          return await parkTask("Publish diff changes " + mergeDiffChangedLines + " lines (budget 200) — too large for the diff transport. Human attention needed.");
+        }
         if (expectedChanges.length === 0) {
           return await parkTask("Publish diff parsed to zero files for commit " + (mergeCommitForPublish || "unknown") + " — cannot verify application. Human attention needed.");
         }
@@ -1475,12 +1481,16 @@ while (i < STEPS.length) {
         // but never parks. The observation tells us what the publish actually
         // reads, so the subsequent fix can require the right base.
         var expectedBaseHashes = {};
-        try {
+        if (publishBase === EMPTY_TREE_SHA) {
+          // First publish: every file in the diff is new to the artifact.
+          expectedChanges.forEach(function (f) { expectedBaseHashes[f.path] = "NEW-FILE"; });
+          log("Publish expected base hashes for task " + taskId + ": empty tree (first publish) — all " + expectedChanges.length + " file(s) new");
+        } else try {
           // Shell-quote helper (no regex-with-quote: the test parser does not
           // understand regex literals containing quotes).
           var sq = function(s) { return "'" + String(s).split("'").join("'\\''") + "'"; };
           var baseHashResult = await agent(
-            "Run: cd " + REPO_PATH + " && parent=" + sq(mergeParentForPublish) + " && for f in " + expectedChanges.map(function(f) { return sq(f.path); }).join(" ") + "; do printf '%s:' \"$f\"; git show \"$parent:$f\" 2>/dev/null | sha256sum | cut -d' ' -f1; done\n" +
+            "Run: cd " + REPO_PATH + " && parent=" + sq(publishBase) + " && for f in " + expectedChanges.map(function(f) { return sq(f.path); }).join(" ") + "; do printf '%s:' \"$f\"; git show \"$parent:$f\" 2>/dev/null | sha256sum | cut -d' ' -f1; done\n" +
             "Return JSON { \"hashes\": \"<newline-separated <path>:<sha256> lines, empty hash means the file is new in this diff>\" } and nothing else.",
             { key: attemptKey("publish-base-hashes-" + taskId, reworkCount), label: "Computing expected base content hashes",
               schema: { type: "object", properties: { hashes: { type: "string" } }, required: ["hashes"] } }
@@ -1489,7 +1499,7 @@ while (i < STEPS.length) {
             var m = /^([^:]+):([0-9a-f]*)$/.exec(line.trim());
             if (m) expectedBaseHashes[m[1]] = m[2] || "NEW-FILE";
           });
-          log("Publish expected base hashes for task " + taskId + " (merge parent " + (mergeParentForPublish || "unknown").slice(0, 12) + "): " + JSON.stringify(expectedBaseHashes));
+          log("Publish expected base hashes for task " + taskId + " (stamped base " + publishBase.slice(0, 12) + "): " + JSON.stringify(expectedBaseHashes));
         } catch (e) {
           log("Publish expected base hash computation failed for task " + taskId + " (non-fatal, observation degraded): " + (e && e.message ? e.message : e));
         }
@@ -1547,6 +1557,7 @@ while (i < STEPS.length) {
             required: ["edit_started", "build_agent_id", "applied"] };
         var rebuildTrigger = null;
         var rebuildReportMissing = false; // true if the edit went through but the agent returned no applied report (structured-output failure) — the smoke-check is skipped; the parent's independent read-back is the verification
+        var rebuildEvidenceNote = null; // human-readable evidence line for the ledger when the edit is confirmed via fallback evidence (in-flight poll or durable audit dir) rather than the trigger's own report
         // 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
@@ -1565,6 +1576,32 @@ while (i < STEPS.length) {
         // (2026-09-12, task 23ca8f3f): computed once the trigger outcome is
         // known, logged loudly, never a park.
         var publishAppliedObservation = null; // "match" | "mismatch: <reason>" | "missing-report" — observation only, never a park
+        // Durable-evidence snapshot (2026-09-14): the structured-output
+        // fallback below only observes IN-FLIGHT builds. A build that
+        // finished before the poll leaves no in-flight trace — but the
+        // platform's audit harness leaves a durable one:
+        // ~/workspace/ts-spaces/<slug>/audits/<timestamp>-<id>/ per
+        // completed build. Snapshot the listing BEFORE the trigger so the
+        // fallback can diff before/after: a directory appearing during the
+        // trigger window is positive evidence the edit went through and
+        // the build completed. Best-effort and non-gating: if the snapshot
+        // fails, the durable check is skipped and the fallback behaves as
+        // before. No wall-clock in-script (deterministic replay) — the
+        // comparison is a pure before/after set diff.
+        var auditDirsBeforeTrigger = [];
+        try {
+          var auditBefore = await agent(
+            "List the artifact audit directories for slug \"" + PUBLISH_SLUG + "\" (best-effort snapshot, never a gate).\n" +
+            "Run: ls -1 ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/ 2>/dev/null\n" +
+            "Return JSON { \"dirs\": \"<newline-separated names, empty string when the audits directory does not exist or is empty>\" } and nothing else.",
+            { key: attemptKey("publish-audit-before-" + taskId, reworkCount), label: "Snapshotting audit dirs before rebuild trigger",
+              schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
+          );
+          auditDirsBeforeTrigger = String((auditBefore && auditBefore.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
+          log("Publish audit-dir snapshot before trigger for task " + taskId + ": " + auditDirsBeforeTrigger.length + " entries");
+        } catch (auditBeforeErr) {
+          log("Publish audit-dir snapshot before trigger failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditBeforeErr && auditBeforeErr.message ? auditBeforeErr.message : auditBeforeErr));
+        }
         try {
           rebuildTrigger = await agent(rebuildPrompt,
             { key: rebuildAttemptKey, label: "Triggering artifact rebuild", schema: rebuildSchema });
@@ -1623,7 +1660,46 @@ while (i < STEPS.length) {
             rebuildTrigger = { edit_started: true, error: "", applied: null };
             rebuildReportMissing = true;
             rebuildAgentId = acceptedAgentId;
+            rebuildEvidenceNote = "edit confirmed via build-state poll after structured-output failure (build " + acceptedAgentId + "); builder applied-report missing";
           } else {
+            // Durable completion check (2026-09-14): the in-flight poll
+            // above only sees RUNNING builds. Attempt 7 (2026-09-14) proved
+            // the gap: the trigger child applied the edit, the build ran
+            // and completed — the platform's audit harness captured it
+            // mid-window — then the child failed to return JSON. The
+            // fallback poll saw no in-flight build, so a successful publish
+            // parked as "unknown". Diff the audit-dir listing against the
+            // pre-trigger snapshot: a timestamped directory that appeared
+            // during the trigger window is positive evidence the edit went
+            // through and the build completed. This never re-issues the
+            // edit and never stamps provenance — it only routes to the
+            // parent's independent content read-back, which remains the
+            // real verification.
+            var newAuditDirs = [];
+            try {
+              var auditAfter = await agent(
+                "List the artifact audit directories for slug \"" + PUBLISH_SLUG + "\" (best-effort, never a gate).\n" +
+                "Run: ls -1 ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/ 2>/dev/null\n" +
+                "Return JSON { \"dirs\": \"<newline-separated names, empty string when the audits directory does not exist or is empty>\" } and nothing else.",
+                { key: attemptKey("publish-audit-after-" + taskId, reworkCount), label: "Re-listing audit dirs after trigger failure",
+                  schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
+              );
+              var auditDirsAfterTrigger = String((auditAfter && auditAfter.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
+              // Only timestamped build dirs count — the "latest" symlink
+              // and anything else are not builds.
+              newAuditDirs = auditDirsAfterTrigger.filter(function (d) {
+                return auditDirsBeforeTrigger.indexOf(d) === -1 && /^20\d\d-\d\d-\d\dT\d\d-\d\d-\d\dZ-/.test(d);
+              });
+            } catch (auditAfterErr) {
+              log("Publish audit-dir re-list after trigger failure failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditAfterErr && auditAfterErr.message ? auditAfterErr.message : auditAfterErr));
+            }
+            if (newAuditDirs.length > 0) {
+              log("Publish rebuild trigger: new audit dir(s) during the trigger window (" + newAuditDirs.join(", ") + ") — the edit went through and the build completed despite the structured-output failure. Skipping applied-report smoke-check; parent read-back is the verification.");
+              rebuildTrigger = { edit_started: true, error: "", applied: null };
+              rebuildReportMissing = true;
+              rebuildAgentId = null;
+              rebuildEvidenceNote = "edit confirmed via durable audit evidence after structured-output failure (new audit dir " + newAuditDirs[0] + "); builder applied-report missing";
+            } else {
             // No build observed — but that proves nothing (a fast-completing
             // build can finish between polls, or the check itself failed). The
             // outcome is UNKNOWN. No retry: re-issuing the edit here duplicated
@@ -1639,6 +1715,7 @@ while (i < STEPS.length) {
               detail: "structured-output failure on rebuild trigger; build-state poll saw no build (or the check itself failed); edit may have been accepted as pending_init"
             }, reworkCount);
             return await parkTask("Publish outcome unknown: the rebuild trigger's child did not return JSON, and the follow-up build-state poll could not observe a build for slug " + PUBLISH_SLUG + ". The edit may have been accepted as pending_init, so no retry was issued — a blind retry duplicated the edit on 2026-09-12. The attempt is recorded in the publish ledger at " + crewHome + "/.publish-ledger/" + PUBLISH_SLUG + ".jsonl (commit " + String(mergeCommitForPublish || "unknown").slice(0, 12) + "). Correlate the accepted edit via the ledger and the builder's eventual completion before re-driving Publish. Fail-closed.");
+            }
           }
         }
         if (!rebuildReportMissing && !rebuildTrigger.edit_started && rebuildTrigger.error === "artifact_tools missing after load") {
@@ -1708,7 +1785,7 @@ while (i < STEPS.length) {
             applied_report: publishAppliedObservation,
             outcome: "submitted",
             detail: rebuildReportMissing
-              ? "edit confirmed via build-state poll after structured-output failure (build " + (rebuildAgentId || "agent_id unknown") + "); builder applied-report missing"
+              ? (rebuildEvidenceNote || "edit confirmed via build-state poll after structured-output failure (build " + (rebuildAgentId || "agent_id unknown") + "); builder applied-report missing")
               : "edit accepted; builder applied-report received"
           }, reworkCount);
         } else if (rebuildTrigger) {
@@ -1806,12 +1883,12 @@ while (i < STEPS.length) {
             // builder's applied-report is derived from the carried diff, so
             // verifyAppliedChanges above is circular — a fabricated report
             // passes by construction, and every phase went green on a hollow
-            // build. The stamp moves to the parent (docs/publish-verification.md):
-            // after an independent artifact_inspect read-back confirms the
-            // artifact's actual content matches the merged diff, the parent
-            // stamps provenance and re-queues; QA's provenance check then
-            // enforces the stamp mechanically, so an unverified publish fails
-            // loudly in QA instead of passing silently here.
+            // build. The stamp moves to the parent (docs/publish-verification.md);
+            // the independent read-back step is currently unavailable (no
+            // agent-callable read-back tool exists — artifact_inspect was
+            // removed by the platform 2026-09-14), so the parent cannot
+            // confirm content and the task parks for verification.
+            // Chore has no QA: the parent's verification is the final gate.
             publishBuildLanded = true;
             artifactPublish = { source_commit: mergeCommitForPublish, pending_parent_verification: true };
             log("Publish build landed for task " + taskId + " — provenance stamp deferred to parent content verification");
@@ -2194,48 +2271,22 @@ while (i < STEPS.length) {
   // it to HEAD: that verifies the stamp, not the content. Canary run 8
   // (2026-09-11) passed it with a hollow build — the stamp was honest, the
   // artifact was stale, all eight phases green. The stamp now moves to the
-  // parent: trigger an independent artifact_inspect read-back of the changed
-  // regions here; the parent stamps provenance only after mechanically
-  // confirming the artifact's actual content matches the merged diff. QA's
-  // provenance check enforces the stamp — an unverified publish fails loudly
-  // there instead of passing silently here.
+  // parent (docs/publish-verification.md); the independent read-back step
+  // is currently unavailable (no agent-callable read-back tool exists —
+  // artifact_inspect was removed by the platform 2026-09-14), so the parent
+  // cannot confirm content and the task parks for verification.
   // Skip-aware (park 2026-09-11): an empty-diff Integrate takes no merge
   // lock, and the deterministic publish path skips rebuild/stamp entirely —
   // there is no new content to verify, so verification is vacuous.
   // publishSkippedNoLock is workflow-computed state from the explicit
   // lock-status read in STEP 0, not agent prose.
-  var publishVerifyInspect = { triggered: false, inspection_id: "", error: "" };
-  if (step.name === "Publish" && PUBLISH_TYPE === "artifact" && PUBLISH_SLUG) {
-    if (publishSkippedNoLock) {
-      log("Publish skipped for task " + taskId + " (no merge lock held — empty-diff Integrate): content verification vacuous, nothing was shipped");
-    } else if (!publishBuildLanded) {
-      log("Publish build did not land for task " + taskId + " — no content to verify (the failure park above already fired)");
-    } else {
-    try {
-      var inspectResult = await agent(
-        ARTIFACT_LOAD_PREAMBLE +
-        "Call artifact_inspect with slug \"" + PUBLISH_SLUG + "\", repair_authorized false, and verbatim_request exactly as follows:\n" +
-        "<<<READBACK_REQUEST\n" + buildPublishReadbackRequest(taskId, mergeCommitForPublish, mergeDiff, rebuildAgentId) + "\nREADBACK_REQUEST\n" +
-        "If artifact_inspect is still not available after the load, do NOT improvise — return { \"triggered\": false, \"inspection_id\": \"\", \"error\": \"artifact_tools missing after load\" } and nothing else.\n" +
-        "Return JSON { \"triggered\": <true if the inspection started, false otherwise>, \"inspection_id\": \"<the inspection id, or empty string>\", \"error\": \"<details or empty string>\" } and nothing else.",
-        { key: attemptKey("publish-verify-inspect-" + taskId, reworkCount), label: "Triggering publish content read-back",
-          schema: { type: "object", properties: { triggered: { type: "boolean" }, inspection_id: { type: "string" }, error: { type: "string" } }, required: ["triggered"] } }
-      );
-      publishVerifyInspect.triggered = !!(inspectResult && inspectResult.triggered);
-      publishVerifyInspect.inspection_id = (inspectResult && inspectResult.inspection_id) || "";
-      publishVerifyInspect.error = (inspectResult && inspectResult.error) || "";
-      if (publishVerifyInspect.triggered) {
-        log("Publish content read-back inspection triggered for task " + taskId + ": " + publishVerifyInspect.inspection_id);
-      } else {
-        log("Publish content read-back inspect trigger failed for task " + taskId + ": " + (publishVerifyInspect.error || "not started") + " — the park below asks the parent to trigger it manually");
-      }
-    } catch (e) {
-      publishVerifyInspect.error = (e && e.message ? e.message : String(e)).slice(0, 200);
-      log("Publish content read-back inspect trigger threw for task " + taskId + ": " + publishVerifyInspect.error + " — the park below asks the parent to trigger it manually");
-    }
-    } // end: !publishSkippedNoLock && publishBuildLanded — a skipped or failed publish has nothing to verify
-  }
-
+  // The parent (tick worker) triggers the ONE read-back inspection it can
+  // actually receive (async results go to the root agent, never into a
+  // workflow run — a workflow-side trigger would be an orphan). The workflow
+  // only parks; the parent's scan builds the request deterministically via
+  // lib/build-readback-request.js and ferries the inspection.
+  // publishBuildLanded and publishSkippedNoLock are workflow-computed state;
+  // a skipped or failed publish has nothing to verify.
   // Session notes. Machine-readable marker lines are extracted from the full
   // worker report and appended AFTER the slice so a long report can never
   // amputate them; later phases (Review reading repo_diff:, QA backstop
@@ -2319,10 +2370,7 @@ while (i < STEPS.length) {
   if (passed && step.name === "Publish" && PUBLISH_TYPE === "artifact" && PUBLISH_SLUG && !publishSkippedNoLock && publishBuildLanded) {
     return await parkTask("publish: verification-requested " + mergeCommitForPublish +
       " (build " + (rebuildAgentId || "agent_id unobserved") + ")" +
-      " — artifact build landed, post-deploy finalized, provenance NOT stamped. Parent: run docs/publish-verification.md" +
-      (publishVerifyInspect.triggered
-        ? " (content read-back inspection " + publishVerifyInspect.inspection_id + " already triggered)."
-        : " (read-back inspect trigger failed: " + (publishVerifyInspect.error || "not started") + " — parent: trigger artifact_inspect manually)."));
+      " — artifact build landed, post-deploy finalized, provenance NOT stamped. Parent: run docs/publish-verification.md.");
   }
 
   i++;

package/workflows/crew-dispatch.js

@@ -424,7 +424,7 @@ function buildPlaytestDescription(journey, personaName, personaFile, maxFilings)
     "\n" +
     "Rules:\n" +
     "- Walk the journey end to end from a user's perspective, wearing the persona.\n" +
-    "- Use the normal QA surface for this project (visual inspection via artifact_inspect for artifact projects; read-only dashboard API checks otherwise).\n" +
+    "- Use the normal QA surface for this project (the published artifact's own user interface for artifact projects; read-only dashboard API checks otherwise). Note: there is currently no agent-callable visual-inspection tool (artifact_inspect was removed by the platform 2026-09-14; artifact.inspect is malfunction diagnosis, not a substitute) — judge only what you can observe directly.\n" +
     "- There is no code change under test: skip change-verification steps (provenance / publish checks) and judge only what you observe.\n" +
     "- " + filingRule + "\n" +
     "- File via the existing createtask action with filed_by \"hazel\": set workflow to \"standard\" when the fix is clear feature work, or omit workflow (untriaged) when unsure — triage routes untriaged filings to bugfix/feature as usual.\n"

package/workflows/docs.js

@@ -393,7 +393,7 @@ function describeWorkAgentFailure(stepName, identity, attempts) {
 
   var instructions = "";
   if (step.name === "Triage") {
-    instructions = "Validate the task, check clarity, confirm the docs workflow assignment.\nReport back in plain prose — your assessment.";
+    instructions = "Validate the task against the project's repo at " + REPO_PATH + " — that exact checkout, not any other copy of the project on disk. If you run git commands, cd " + REPO_PATH + " first.\nCheck clarity, confirm the docs workflow assignment.\nReport back in plain prose — your assessment.";
   } else if (step.name === "Write") {
     instructions = "Write or revise the documentation the task asks for.\nFollow Tate's voice — clear, conversational, no jargon unless it earns its place.\nDo your work in the project repository at " + REPO_PATH + " — all doc files go there, not under the crew home." +
       (rejectionNotes ? "\n\nREWORK after review rejection. Address:\n" + rejectionNotes : "") +