voidmachine 5.0.3 → 5.0.5

package/core-assets/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "harness",
-  "version": "5.0.3",
+  "version": "5.0.5",
   "description": "VoidCorp universal craftsman skills (void-tdd, void-typescript-strict, void-hexagonal-architecture, void-domain-driven-design, void-functional, void-code-review, void-api-and-interface-design, void-source-driven-development, void-context, void-learn, void-decide, void-claude-md, void-observability, void-security-guidance, ...) plus 12 PreToolUse enforcement hooks (tdd-guard, no-any, protect-sensitive-files, block-dangerous-bash, no-ai-design-slop, ...) and PostToolUse/SessionStart lifecycle hooks (incl. trim-large-output token frugality), five read-only critics including doctrine-critic, native architecture/security/QA specialists, and the void-graph, void-doctor and void-audit gestures, which are skills like everything else.",
   "author": {
     "name": "VoidCorp",

package/core-assets/data/catalog.v3.json

@@ -5,7 +5,7 @@
   "source": {
     "kind": "adapter",
     "version": "3.0.0-alpha.1",
-    "rootHash": "sha256:69ada8c7a668574252b442c0bb1cde65d4d878973c9c59cc86871a147393bba9"
+    "rootHash": "sha256:56012433234f5e7d537066868543df205e92f817003384489c7e698778a49ab2"
   },
   "nodes": [
     {
@@ -3551,7 +3551,7 @@
             }
           ],
           "id": "skill:void-autopilot",
-          "lines": 394,
+          "lines": 395,
           "name": "void-autopilot",
           "owner": "folpe",
           "pack": null,
@@ -3560,7 +3560,7 @@
             "codex"
           ],
           "source": "packages/core/skills/void-autopilot/SKILL.md",
-          "staticTokens": 6967,
+          "staticTokens": 7051,
           "type": "skill"
         }
       },
@@ -4340,7 +4340,7 @@
             "codex"
           ],
           "source": "packages/core/skills/void-implement/SKILL.md",
-          "staticTokens": 5664,
+          "staticTokens": 5800,
           "type": "skill"
         }
       },
@@ -4677,7 +4677,7 @@
             }
           ],
           "id": "skill:void-orchestrate",
-          "lines": 311,
+          "lines": 327,
           "name": "void-orchestrate",
           "owner": "folpe",
           "pack": null,
@@ -4686,7 +4686,7 @@
             "codex"
           ],
           "source": "packages/core/skills/void-orchestrate/SKILL.md",
-          "staticTokens": 4402,
+          "staticTokens": 4673,
           "type": "skill"
         }
       },
@@ -5373,7 +5373,7 @@
             }
           ],
           "id": "skill:void-verify",
-          "lines": 184,
+          "lines": 203,
           "name": "void-verify",
           "owner": "folpe",
           "pack": null,
@@ -5382,7 +5382,7 @@
             "codex"
           ],
           "source": "packages/core/skills/void-verify/SKILL.md",
-          "staticTokens": 2267,
+          "staticTokens": 2552,
           "type": "skill"
         }
       },

package/core-assets/data/certification.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "harnessVersion": "5.0.3",
+  "harnessVersion": "5.0.5",
   "capabilities": [
     {
       "id": "skill:pack-mobile/void-eas-build-profile",

package/core-assets/data/model.json

@@ -1703,7 +1703,7 @@
         }
       ],
       "id": "skill:void-autopilot",
-      "lines": 394,
+      "lines": 395,
       "name": "void-autopilot",
       "owner": "folpe",
       "pack": null,
@@ -1712,7 +1712,7 @@
         "codex"
       ],
       "source": "packages/core/skills/void-autopilot/SKILL.md",
-      "staticTokens": 6967,
+      "staticTokens": 7051,
       "type": "skill"
     },
     {
@@ -2204,7 +2204,7 @@
         "codex"
       ],
       "source": "packages/core/skills/void-implement/SKILL.md",
-      "staticTokens": 5664,
+      "staticTokens": 5800,
       "type": "skill"
     },
     {
@@ -2415,7 +2415,7 @@
         }
       ],
       "id": "skill:void-orchestrate",
-      "lines": 311,
+      "lines": 327,
       "name": "void-orchestrate",
       "owner": "folpe",
       "pack": null,
@@ -2424,7 +2424,7 @@
         "codex"
       ],
       "source": "packages/core/skills/void-orchestrate/SKILL.md",
-      "staticTokens": 4402,
+      "staticTokens": 4673,
       "type": "skill"
     },
     {
@@ -2859,7 +2859,7 @@
         }
       ],
       "id": "skill:void-verify",
-      "lines": 184,
+      "lines": 203,
       "name": "void-verify",
       "owner": "folpe",
       "pack": null,
@@ -2868,7 +2868,7 @@
         "codex"
       ],
       "source": "packages/core/skills/void-verify/SKILL.md",
-      "staticTokens": 2267,
+      "staticTokens": 2552,
       "type": "skill"
     }
   ],

package/core-assets/hooks/_void-hook.mjs

@@ -11093,6 +11093,7 @@ function executeContextContinuity(rawInput, root, runtime3, now) {
 
 init_define_VOID_SYNTAX_WORKER_IDENTITY();
 import { spawnSync as spawnSync2 } from "node:child_process";
+import { realpathSync as realpathSync5 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join12 } from "node:path";
 
@@ -12984,6 +12985,39 @@ function metadataCommands(snapshot, event, sequence, contextPercent, workspaceMi
   return commands;
 }
 
+init_define_VOID_SYNTAX_WORKER_IDENTITY();
+var discoverySchema = object2({ result: object2({ process_info: object2({
+  pane_id: string2(),
+  foreground_processes: array(object2({
+    pid: number2().check(int(), _gte(2))
+  })).check(_minLength(1), _maxLength(256))
+}) }) });
+function foreground(output, pane) {
+  try {
+    const value = JSON.parse(output.toString("utf8"));
+    if (record3(value)?.["error"] !== void 0) return void 0;
+    const result = discoverySchema.safeParse(value);
+    if (!result.success || result.data.result.process_info.pane_id !== pane) return void 0;
+    return result.data.result.process_info.foreground_processes.map((item) => item.pid);
+  } catch {
+    return void 0;
+  }
+}
+function proveOwnership(pids, call) {
+  let pid = process.pid;
+  const visited = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < 64; depth++) {
+    if (visited.has(pid)) return "parent-cycle";
+    visited.add(pid);
+    if (pids.includes(pid)) return void 0;
+    const parent = call("ps", ["-o", "ppid=", "-p", String(pid)]).toString("utf8").trim();
+    if (!/^[0-9]+$/.test(parent) || !Number.isSafeInteger(Number(parent))) return "invalid-parent";
+    pid = Number(parent);
+    if (pid <= 1) return "ownership-unproven";
+  }
+  return "parent-depth-exceeded";
+}
+
 init_define_VOID_SYNTAX_WORKER_IDENTITY();
 import { createHash as createHash4 } from "node:crypto";
 import { closeSync as closeSync3, constants as constants4, fstatSync as fstatSync3, lstatSync as lstatSync4, opendirSync, openSync as openSync3, readSync as readSync3, realpathSync as realpathSync4 } from "node:fs";
@@ -13294,9 +13328,9 @@ function executeHerdrMetadata(raw, root, env, runtime3, run = runCommand) {
   };
   try {
     const common = call("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"]).trim();
+    const inventory = () => paneList.parse(JSON.parse(call("herdr", ["pane", "list"]))).result.panes;
     const snapshot = readOrchestra(join12(env["HOME"] ?? homedir2(), ".local/state/orchestra"), common, root, () => {
-      const response = paneList.parse(JSON.parse(call("herdr", ["pane", "list"])));
-      return response.result.panes.flatMap((pane) => typeof pane.label === "string" && typeof pane.cwd === "string" ? [{
+      return inventory().flatMap((pane) => typeof pane.label === "string" && typeof pane.cwd === "string" ? [{
         pane_id: pane.pane_id,
         workspace_id: pane.workspace_id,
         label: pane.label,
@@ -13304,7 +13338,29 @@ function executeHerdrMetadata(raw, root, env, runtime3, run = runCommand) {
         ...pane.tokens === void 0 ? {} : { tokens: pane.tokens }
       }] : []);
     });
-    if (snapshot === void 0) return { status: "skipped", details: { reason: "no-orchestra-mission" } };
+    if (snapshot === void 0) {
+      if (event !== "SessionStart") return { status: "skipped", details: { reason: "no-orchestra-mission" } };
+      const paneId = env["HERDR_PANE_ID"];
+      if (!paneId || !env["HERDR_SOCKET_PATH"]) throw Error("missing-herdr-context");
+      const panes = inventory();
+      const matches2 = panes.filter((pane2) => pane2.pane_id === paneId);
+      const pane = matches2[0];
+      if (matches2.length !== 1 || !pane || !pane.cwd || realpathSync5(pane.cwd) !== realpathSync5(root)) {
+        throw Error("Herdr caller pane missing or foreign worktree");
+      }
+      if (pane.label && panes.filter((other) => other.label === pane.label && typeof other.cwd === "string" && realpathSync5(other.cwd) === realpathSync5(root)).length !== 1) {
+        throw Error("ambiguous Herdr coordinator identity");
+      }
+      const pids = foreground(Buffer.from(call("herdr", ["pane", "process-info", "--pane", paneId])), paneId);
+      if (pids === void 0) throw Error("invalid Herdr process discovery");
+      const denied = proveOwnership(pids, (command, args) => Buffer.from(call(command, args)));
+      if (denied !== void 0) throw Error(denied);
+      return { status: "ok", details: { host: "herdr", mission: "absent" }, output: { hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext: `Validated Herdr caller: ${paneId}. No Orchestra mission selected.
+Use void-orchestrate before delegating a ticket: register the mission, create or reuse its worker tab, and launch the worker once. Revalidate live identity before acting; this hook never launches workers.`
+      } } };
+    }
     const workspace = snapshot.coordinator ? record3(record3(JSON.parse(call("herdr", ["workspace", "get", snapshot.pane.workspace_id])))?.["result"]) : void 0;
     const workspaceMission = record3(record3(workspace?.["workspace"])?.["tokens"])?.["mission"];
     const percent = measureHerdrContext(input, root, runtime3, now);
@@ -13341,8 +13397,17 @@ Read mission.md and the current brief/report before resuming; Herdr IDs are hint
     };
   } catch (error) {
     const reason = (error instanceof Error ? error.message : String(error)).slice(0, 500);
-    return { status: "degraded", details: { reason }, diagnostic: `herdr-metadata: ${reason}
-` };
+    return {
+      status: "degraded",
+      details: { reason },
+      diagnostic: `herdr-metadata: ${reason}
+`,
+      ...event === "SessionStart" ? { output: { hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext: `Herdr discovery refused: ${reason}.
+Do not act on this host until resolved. Native delegation independent of that action may continue.`
+      } } } : {}
+    };
   }
 }
 
@@ -13356,41 +13421,10 @@ var runCommand2 = (command, args, options) => {
   if (result.error !== void 0 || result.status !== 0) throw Error("process-failed");
   return result.stdout;
 };
-var discoverySchema = object2({ result: object2({ process_info: object2({
-  pane_id: string2(),
-  foreground_processes: array(object2({
-    pid: number2().check(int(), _gte(2))
-  })).check(_minLength(1), _maxLength(256))
-}) }) });
 function refused(reason) {
   return { status: "degraded", details: { reason }, diagnostic: `herdr-session: ${reason}
 ` };
 }
-function foreground(output, pane) {
-  try {
-    const value = JSON.parse(output.toString("utf8"));
-    if (record3(value)?.["error"] !== void 0) return void 0;
-    const result = discoverySchema.safeParse(value);
-    if (!result.success || result.data.result.process_info.pane_id !== pane) return void 0;
-    return result.data.result.process_info.foreground_processes.map((item) => item.pid);
-  } catch {
-    return void 0;
-  }
-}
-function proveOwnership(pids, call) {
-  let pid = process.pid;
-  const visited = /* @__PURE__ */ new Set();
-  for (let depth = 0; depth < 64; depth++) {
-    if (visited.has(pid)) return "parent-cycle";
-    visited.add(pid);
-    if (pids.includes(pid)) return void 0;
-    const parent = call("ps", ["-o", "ppid=", "-p", String(pid)]).toString("utf8").trim();
-    if (!/^[0-9]+$/.test(parent) || !Number.isSafeInteger(Number(parent))) return "invalid-parent";
-    pid = Number(parent);
-    if (pid <= 1) return "ownership-unproven";
-  }
-  return "parent-depth-exceeded";
-}
 function nativeHook(env) {
   const path2 = join13(
     env["CODEX_HOME"] || join13(env["HOME"] || homedir3(), ".codex"),
@@ -13453,7 +13487,7 @@ function executeHerdrSession(input, env, runtime3, run = runCommand2, clock = ()
 
 init_define_VOID_SYNTAX_WORKER_IDENTITY();
 import { randomUUID } from "node:crypto";
-import { lstatSync as lstatSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync11, readdirSync as readdirSync3, realpathSync as realpathSync5, renameSync as renameSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { lstatSync as lstatSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync11, readdirSync as readdirSync3, realpathSync as realpathSync6, renameSync as renameSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute7, join as join16 } from "node:path";
 
 init_define_VOID_SYNTAX_WORKER_IDENTITY();
@@ -13512,20 +13546,20 @@ function claimedPath(root, sessionId) {
     if (!within(runs, path2) || lstatSync5(dirname6(path2), { throwIfNoEntry: false })?.isDirectory() !== true) {
       return void 0;
     }
-    return within(realpathSync5(runs), realpathSync5(dirname6(path2))) ? path2 : void 0;
+    return within(realpathSync6(runs), realpathSync6(dirname6(path2))) ? path2 : void 0;
   } catch {
     return void 0;
   }
 }
 function waitingRun(root, cwd, now) {
   try {
-    const here = realpathSync5(cwd);
+    const here = realpathSync6(cwd);
     const directory = join16(root, "agents", "pending");
     return readdirSync3(directory).filter((name) => !name.startsWith(".")).slice(0, 64).some((name) => {
       const marker = record3(JSON.parse(readFileSync11(join16(directory, name), "utf8")));
       const createdAt = marker?.["createdAt"];
       const runCwd = marker?.["cwd"];
-      return typeof createdAt === "number" && now - createdAt < PARKING_WINDOW_MS && typeof runCwd === "string" && realpathSync5(runCwd) === here;
+      return typeof createdAt === "number" && now - createdAt < PARKING_WINDOW_MS && typeof runCwd === "string" && realpathSync6(runCwd) === here;
     });
   } catch {
     return false;
@@ -13953,7 +13987,7 @@ import { createHash as createHash5 } from "node:crypto";
 import {
   lstatSync as lstatSync7,
   mkdirSync as mkdirSync5,
-  realpathSync as realpathSync6,
+  realpathSync as realpathSync7,
   writeFileSync as writeFileSync4
 } from "node:fs";
 import { join as join18, relative as relative7 } from "node:path";
@@ -14024,11 +14058,11 @@ ${errors}
 
 function safeOutputDirectory(root) {
   try {
-    const canonicalRoot = realpathSync6(root);
+    const canonicalRoot = realpathSync7(root);
     const directory = voidMachinePath(root, "outputs");
     mkdirSync5(directory, { recursive: true, mode: 448 });
     const info = lstatSync7(directory);
-    const canonicalDirectory2 = realpathSync6(directory);
+    const canonicalDirectory2 = realpathSync7(directory);
     if (!info.isDirectory() || info.isSymbolicLink() || !within(canonicalRoot, canonicalDirectory2)) {
       return void 0;
     }
@@ -14064,7 +14098,7 @@ function executeTrim(rawInput, root, env) {
   const hash = createHash5("sha256").update(extracted.text).digest("hex").slice(0, 12);
   const tool = extracted.tool.replaceAll(/[^A-Za-z0-9_]/g, "_").slice(0, 80);
   const file = join18(directory, `${tool}-${process.pid}-${Date.now()}-${hash}.log`);
-  const spillPath = relative7(realpathSync6(root), file).replaceAll("\\", "/");
+  const spillPath = relative7(realpathSync7(root), file).replaceAll("\\", "/");
   const plan = planOutputTrim(extracted.text, {
     tool: extracted.tool,
     thresholdBytes,
@@ -14351,13 +14385,13 @@ Resolve before claiming done. This never blocks.
 
 init_define_VOID_SYNTAX_WORKER_IDENTITY();
 import { spawnSync as spawnSync8 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync8, lstatSync as lstatSync8, openSync as openSync4, readSync as readSync4, realpathSync as realpathSync7 } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync8, lstatSync as lstatSync8, openSync as openSync4, readSync as readSync4, realpathSync as realpathSync8 } from "node:fs";
 import { dirname as dirname8, isAbsolute as isAbsolute10, join as join21, resolve as resolve9 } from "node:path";
 var GIT_TIMEOUT_MS2 = 5e3;
 var GIT_MAX_OUTPUT_BYTES = 1e6;
 function canonical2(path2) {
   try {
-    return realpathSync7(resolve9(path2));
+    return realpathSync8(resolve9(path2));
   } catch {
     return resolve9(path2);
   }

package/core-assets/skills/void-autopilot/SKILL.md

@@ -90,8 +90,8 @@ skip a step, merge, or decide that a refusal does not apply to it.
 
 **Orchestrator.** Runs the loop. Evaluates no ticket, edits no code, reads no diff.
 
-**Workers**, one per slot. Each carries one ticket from claim to an open pull request, in its own
-worktree, by running `void-implement` whole.
+**Workers**, one per slot, are commit-only. Each carries one ticket to a committed candidate
+and proof references in its own worktree; the coordinator owns pushes and pull requests.
 
 **Reviewer.** The independent pass of `void-implement`, invoked by ORCH through
 `void-orchestrate` in a fresh read-only context on the exact head SHA. `autopilot review`
@@ -203,8 +203,8 @@ in flight set it when they create or push their branch and drop it with a merged
 own settings still count. So start each worktree from
 `origin/<base>` and never move a local base branch while units are in flight. The baseline
 recorded at `assign` is written once: a second `--before` for the same ticket is refused, so a unit
-cannot re-record the state it left as the state it found. It is compared by the worker before it
-pushes, with `autopilot fingerprint --after <ticket>`, and again by the kernel before it arms a
+cannot re-record the state it left as the state it found. It is compared by the coordinator before it
+publishes, with `autopilot fingerprint --after <ticket>`, and again by the kernel before it arms a
 merge. A changed or missing baseline sends the ticket to a human, unpublished; only that person
 deletes the record.
 
@@ -273,21 +273,22 @@ It runs `void-implement` whole in that worktree, and starts its mission with the
 mission what it has done: each specialist result through `mission specialist-event`, each proof
 through `mission verify`, a committed candidate through `mission writer-event`. The journal accepts
 only these typed events, no free note; what is not yet one of them does not survive a respawn, and
-uncommitted edits survive only in the worktree. When its proofs are green it runs
-`autopilot fingerprint --after <ticket>`, pushes its own branch, opens one pull request towards the
-base, ready for review rather than as a draft, and moves the ticket to In Review. The reviewer the
-orchestrator invokes is that cycle's independent review; it reviews ready pull requests only, so a
-draft waits.
+uncommitted edits survive only in the worktree. During development, the coordinator may create or reuse a draft pull request
+for the branch; drafts are permitted for development, never for merge admission. After the worker
+returns its commit and green proofs, the coordinator runs `autopilot fingerprint --after <ticket>`,
+pushes, and must mark the same pull request ready (create one only if absent), then move the ticket
+to In Review. The independent reviewer examines ready pull requests only; an unfinished draft waits.
 Blocking findings come back as a hand-back and are corrected as a batch, per `void-implement`.
 
 On a hand-back the worker reads the reason: failing checks, blocking findings, a conflict, or a
 base that moved. It updates its branch by merging the base into it,
-never by rewriting pushed history, re-runs its proofs, and pushes again.
+never by rewriting pushed history, re-runs its proofs, and returns its commit to the coordinator.
+The coordinator updates the same PR; the worker does not create another one.
 
 May: run every `void-implement` pass whose predicate fires, run its own gates, apply a migration in
-dev/local only, push its own branch without force, and open or update its own pull request.
+dev/local only, and return its commits and proofs to the coordinator.
 
-May not: enable auto-merge, merge anything, post or record a verdict, run `autopilot review`, move a ticket to Done, close or cancel a ticket, touch another ticket's branch or worktree,
+May not: enable auto-merge, merge anything, post or record a verdict, run `autopilot review`, push, create or change pull requests, move a ticket to Done, close or cancel a ticket, touch another ticket's branch or worktree,
 prune the mission journals, or write the git state the repository shares -- `refs/stash`, tags,
 notes, remotes, the repository config.
 
@@ -332,7 +333,7 @@ head, then sends the ticket to a human. An ejected head whose own checks fail go
 worker as failing checks. A pull request in conflict with the base goes back to its worker. The
 worker classifies the conflict as the typed `conflict` judgment on the conflicting head, posted
 through `autopilot judgment conflict-class`: `mechanical` it resolves, re-runs
-its proofs and pushes; `semantic` -- two intents that disagree -- it leaves alone, and the kernel
+its proofs and returns its commit for coordinator publication; `semantic` -- two intents that disagree -- it leaves alone, and the kernel
 sends the ticket to a human. A worker never picks a side of a semantic conflict to keep the loop
 moving.
 

package/core-assets/skills/void-implement/SKILL.md

@@ -102,7 +102,7 @@ Run in order. Each pass names the skill it composes and the predicate that fires
 3. **Source grounding** (ALWAYS; the source depends on what the change touches). Read the relevant sources before the first line, per the Anti-rustine section of `PHILOSOPHY.md`. For a third-party configuration, schema or call signature, compose `void-source-driven-development`: official documentation **of the installed version**, never an upgrade by default. For internal code, read the owning contract, types, source and project docs of what you are about to change. Assumed semantics produce bugs that cost hours to find, and the assumption is invisible in the diff — which is why this runs before the writing rather than at review. Cite a source briefly when it helps understand or record a choice; a missing citation never blocks on its own.
 4. **Migration safety** (IF it changes a DB schema or ships a migration). Compose `void-migrations` (and `void-drizzle-migration-safe` on a Drizzle/Postgres stack): zero-downtime, two-phase, batched backfill, locking analysis. **Once the migration is generated and safety-reviewed, apply it to the dev/local database before the TDD and E2E passes run** — otherwise those tests execute against a stale schema and prove nothing about the new shape. **This cycle only ever applies to dev/local; production migrations run through CI / GitHub Actions on merge, never from a worker or this session** (see the `void-migrations` anti-rule). A schema change must never reach the rest of the cycle without this pass.
 5. **Convene the panel** (ALWAYS once, in `team` mode). With `panel.provider: orchestrator`, consume ORCH's supplied panel and never launch another. Otherwise call `mission dispatch --json`: its first `invoke-specialists` action is at `stage: 'pre-implementation'`, before code. Compose `void-orchestrate` for native invocation. Pass the envelope's runtime, agentName, missionId, contextPack, reviewSubject and reviewScope unchanged; record actual starts and complete results using `mission specialist-event`. Reconcile an existing invocation before dispatch; uncertain identity means no launch. Keep at most four simultaneous agents, wait in bounded slices, and never fail an agent merely because a wait timed out. Findings brief the single writer; a concrete blocked verdict is resolved before implementation. Later controller stages reuse this transport and never replay preparation. Missing required capability is diagnosed, never fabricated.
-6. **TDD implementation** (ALWAYS). The single lead writer composes `void-tdd` + `void-testing`. Red, green, refactor. Unit tests for the behavior, green before moving on. Review specialists remain read-only.
+6. **TDD implementation** (ALWAYS). During development, the coordinator may create or reuse a draft pull request for the branch. Keep work-in-progress PRs in draft and run focused local checks; do not wait for full remote CI per iteration. `void-verify` owns the transition to complete integration checks and its portable CI template. The single lead writer composes `void-tdd` + `void-testing`. Red, green, refactor. Unit tests for the behavior, green before moving on. Review specialists remain read-only.
 7. **Async + idempotency** (IF it sends email, calls an external side-effecting API, enqueues a job, or mints a single-use token). Compose `void-async-safety`: idempotency keys, replay/dedup window, bounded retries, single-use enforcement.
 8. **End-to-end tests** (IF it touches a user-facing flow). Write/extend the E2E suite (Playwright). The path a user actually walks, not just the unit.
 9. **UX/UI pass** (IF it touches a UI surface). The interface is held to production craft, not just "it renders". Compose `void-frontend-design` (build-time craft) + `void-ui-review` (the audit/critique ceiling: AI-slop test, squint test, interaction-state coverage, technical audit) + `void-accessibility`, across the baseline (BACK+FRONT parity, mobile and desktop, and the states a user actually hits — loading / error / empty). Browser-verified QA (live screenshots) runs via `void-qa` (the claude-in-chrome MCP). A UI ticket is not shippable until this pass is **verified, not assumed**.
@@ -115,7 +115,7 @@ Run in order. Each pass names the skill it composes and the predicate that fires
     This exists because the passes above have a measured hit rate of zero on a whole class of defect. Six shipped on 2026-08-06 with typecheck, lint, 2,700 tests and five CI checks green: five were caught by using the thing on the real tree, one by the harness itself, none by CI and none by the human merge gate. One of them reported "5 path(s) not extracted" about files it had read, parsed and indexed — the exact lie the feature existed to prevent — and it surfaced by running the command on the repo, after merge. Under autopilot nobody comes back to the previous ticket, so a defect found that way is a defect not found at all.
     **A fixture is not a dogfood.** The fixture is the shortcut that would have missed every one of the six: the two oversized generated artifacts that exposed the false count existed only in the real tree. **And "the command did not crash" is not an observation** — the output has to be read, and quoted rather than summarised as "works". A surface that genuinely cannot run here (a deploy, a remote service) has its limitation named, never worked around in silence. Keep the run read-only or reversible.
 14. **Dispose of what you found** (ALWAYS). A cycle surfaces defects that are not this ticket: an incoherent skill, a stale doc, a contract that lies. Do not file them on their merits. Compare each against the unit you are building, judged against the program objective: it either blocks this unit and is fixed here, or it beats this unit and becomes the next one, or it is **dropped**. Write one recap line per finding naming what it lost to. Record only evidence that cannot be reconstructed — a failure seen once, a measurement — with the command that replays it. The admission rules are `void-ticket`'s; this pass is where they fire.
-15. **Ship** (ALWAYS). Compose `void-commit-discipline`, open the PR, attach the PR and verification evidence, then move a tracker-backed ticket to **In Review**. Move it to **Done** only after merge and final verification of the merged state. Commits are **bisectable** — one logical change each, dependency-ordered (infra → domain + tests → edge/UI + tests), each independently valid. Under `void-autopilot` the worker pushes its own branch and opens the PR, but never enables auto-merge, merges, posts the review status or moves the ticket to Done; the loop's reviewer performs the independent review of step 11 on the PR head SHA.
+15. **Ship** (ALWAYS). Compose `void-commit-discipline`, reuse the existing PR for the branch (create one only if absent), attach verification evidence, and mark the same pull request ready when the candidate meets the review handoff requirements. Then move a tracker-backed ticket to **In Review**. Move it to **Done** only after merge and final verification of the merged state. Commits are **bisectable** — one logical change each, dependency-ordered (infra → domain + tests → edge/UI + tests), each independently valid. Under `void-autopilot` the worker is commit-only: it returns the commit and proof references to the coordinator, who owns pushes, PR creation/readiness and tracker updates. The worker never enables auto-merge, merges, posts the review status or moves the ticket to Done; the loop's reviewer performs the independent review of step 11 on the PR head SHA.
 
 ---
 

package/core-assets/skills/void-orchestrate/SKILL.md

@@ -40,6 +40,22 @@ or act on an unrelated project. Native work independent of that action may conti
   mandatory independent review or required isolation remains a blocker; do not
   replace it with self-review or silently weaken its requirement.
 
+## First ticket and optional worker tabs
+
+SessionStart discovers Herdr even before central mission files exist. Its advice
+requires a fresh caller pane at the canonical checkout and process ownership;
+environment variables alone never authorize a host action. Revalidate before launch.
+On a new implementation ticket, reuse the assigned writer if one exists. Otherwise,
+in a validated Herdr session, register the mission and planned worker first, then
+create one background tab in the resolved coordinator workspace with the assigned
+worktree as cwd. Read the installed `herdr tab` schema, preserve focus with
+`--no-focus`, and use the returned root pane for the single agent start below.
+Reattach a matching existing worker instead of opening another tab. The coordinator
+stays in its existing pane. Hooks only discover and advise; they never create tabs,
+launch agents or write central files. Without Herdr, use native delegation normally.
+An invalid host or explicit mission selection refuses only that host action;
+independent native work may continue with the limitation stated.
+
 ## Brief and bound the delegation
 
 Use a fresh context by default. Choose a supported fork only when the task needs

package/core-assets/skills/void-verify/.source

@@ -10,3 +10,5 @@ Sources for `void-verify` skill (see `docs/plans/skill-audits/void-verify.md` fo
 Strategy: distill. Slim skill. Adapted for void-machine's specific signal set (12 items, each mapped to a skill or hook).
 
 No new hooks (composes with all existing).
+
+- GitHub Actions event, concurrency and merge-queue documentation: https://docs.github.com/en/actions/reference/workflows-and-actions/events-that-trigger-workflows ; https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency ; https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue

package/core-assets/skills/void-verify/SKILL.md

@@ -19,6 +19,25 @@ If you find yourself wanting to skip the checklist "because it's a small change,
 
 ---
 
+## Local development and integration
+
+During development, run the smallest meaningful configured test command against the
+changed behavior, plus affected types and local hooks. Keep the PR in draft; do not
+wait for full remote CI after each edit or commit. Fresh local evidence still gates
+claims about the behavior tested. `commands.testUnit` and `commands.typecheck` in
+`.void/config.json` describe project commands; preserve their argv.
+
+When the candidate is committed and independently reviewed, run the applicable final
+checks below and mark the PR ready. Wait for real required CI on that head and, if
+configured, the merge group before integration. Local success cannot replace a required
+server check. Returning to draft cancels obsolete PR work without resetting reviews.
+
+For an explicitly requested CI setup or optimization, use the installed
+[executable admission guard and workflow template](references/ci-feedback.md).
+They defer draft validation with an explicit non-success outcome, rerun on readiness,
+and preserve merge queue checks. Never install them or change remote protection merely
+because this skill was invoked.
+
 ## The checklist
 
 Read item by item. Do not run from memory. Each item is OBSERVED, not assumed.

package/core-assets/skills/void-verify/references/ci-admission.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// tdd-cover: e2e packages/cli/src/lib/ci-feedback.test.ts
+// An admission refusal is not test evidence. Keep this step inside the required
+// quality job: a skipped required job reports success in GitHub Actions.
+import { readFileSync } from 'node:fs';
+
+try {
+  const name = process.env.GITHUB_EVENT_NAME;
+  if (!['pull_request', 'merge_group', 'push', 'workflow_dispatch'].includes(name)) {
+    throw new Error('CI_INVALID_EVENT: unsupported or missing GitHub event.');
+  }
+  const event = JSON.parse(readFileSync(process.env.GITHUB_EVENT_PATH, 'utf8'));
+  if (name === 'pull_request') {
+    if (typeof event?.pull_request?.draft !== 'boolean') {
+      throw new Error('CI_INVALID_EVENT: pull request draft state is missing or malformed.');
+    }
+    if (event.pull_request.draft) {
+      throw new Error('CI_DEFERRED_DRAFT: preparation only; run focused tests locally, then mark ready for review to start integration validation. No tests were run.');
+    }
+  }
+  process.stdout.write('CI_ADMITTED: run the complete integration checks for this revision.\n');
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : 'CI_INVALID_EVENT: unreadable event.'}\n`);
+  process.exitCode = 1;
+}

package/core-assets/skills/void-verify/references/ci-feedback.md

@@ -0,0 +1,51 @@
+# Fast local feedback, real integration checks
+
+The sibling files are shipped with this skill and copied by `init` into the selected
+runtime's skill directory. Resolve them relative to the SKILL.md you actually loaded,
+not from a developer checkout or a global installation.
+
+On an explicit CI configuration request:
+
+1. Inspect existing workflows, required check names, package manager, branch names,
+   review publication and release dependencies. Preserve their owners. Do not overwrite
+   existing workflows with this example or install a second quality workflow.
+2. Adopt the behavior in `quality.yml` into the existing quality workflow. Copy
+   `ci-admission.mjs` to `.github/scripts/ci-admission.mjs`. Keep the admission step
+   inside an existing **required** quality job, before dependency installation, without
+   `continue-on-error`, `always()` on later quality steps, or a job-level draft skip.
+3. Set up the project's actual package manager and immutable lockfile installation.
+   The example uses npm. For pnpm/Bun use their pinned setup and frozen install.
+   Define `ci:verify` in package.json to run the actual complete lint, typecheck, build,
+   and test commands appropriate to the project. Do not equate `testUnit` with the
+   whole integration suite; discover the project's existing CI contract. Missing
+   `ci:verify` fails rather than silently passing. Never use `--if-present` or `true`.
+4. Preserve remote protection and exact-head checks. Keep the required check names
+   stable. Review protection adoption separately if no quality check is required;
+   this template alone does not configure GitHub protection. Retain the separate
+   `void-enforce` floor and independent review. This template does not replace either.
+5. Test draft, ready without another commit, new head, return to draft, merge group,
+   and manual run. `CI_DEFERRED_DRAFT` is expected non-admission during preparation,
+   not a failed test: tests have not run. Readiness runs the full suite even at the
+   same SHA. Never treat a skipped required job as successful test evidence.
+
+Development runs configured local tests for the changed behavior and affected types.
+There is no network hook or mandatory remote wait per edit. Only obsolete PR runs are
+cancelled. Distinct merge groups, manual runs and release runs must have distinct
+concurrency keys: `cancel-in-progress: false` alone still replaces pending runs in a
+shared group. Keep integration checks before entry to the protected branch; checking
+only after merge permits broken integration.
+
+GitHub couples required PR and merge queue checks. Preserve both. Remove a redundant
+post-merge run only after checking that no release, promotion or artifact consumer
+needs it, and that the protected integration path proves the merged result. The
+example has no push trigger; add one where it provides distinct release evidence.
+
+Rollback: restore the prior workflow triggers and admission step together. Restoring
+full draft CI costs runner time but does not weaken the floor. Leave protection and
+review evidence unchanged. Existing missions and receipts are not migrated.
+
+Sources read for GitHub Actions (hosted service):
+- https://docs.github.com/en/actions/reference/workflows-and-actions/events-that-trigger-workflows#pull_request
+- https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency
+- https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue
+- https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-jobs-with-conditions