feat(#3778): dispatch plan:pre planner contributions before quick planning (#3934)

* feat(#3778): dispatch plan:pre planner contributions in quick.md

- Add plan:pre capability gate to quick.md Step 5, mirroring plan-phase.md's
  existing render + generic contribution dispatch pattern
- Inject planner-targeted contribution fragments into the planner prompt,
  after AGENT_SKILLS_PLANNER, matching D-08 ordering
- Add tests/quick-plan-pre-capabilities.test.cjs proving the dispatch is
  generic (D-01) via real scanWiredKinds/coveredKindsInRegion functions
- Record quick.md's byte-growth rationale in this commit trailer for every
  gsd-core-verbatim runtime

Emitted-Drift-Ack-Growth: quick.md — #3778: Step 5 (Spawn planner, quick mode) gains a `plan:pre` capability gate, mirroring `plan-phase.md:420-424` and `:797`. This is shipped shell and prose read by an agent at runtime, not compiled, so the reasoning has to travel with the feature rather than being deferred to a reference doc: (1) the dispatch paragraph phrases role routing possessively ("the role each entry's `into` names") rather than as an `into ==` equality, because `coveredKindsInRegion` (scripts/gen-loop-host-contract.cjs) voids a segment's `kind == "contribution"` coverage credit when a role or capability equality shares that same segment — an equality phrasing here would silently fail the generic-dispatch proof required by D-01; (2) `activeHooks` is read directly in-context from `PLAN_PRE_HOOKS_JSON`/`HOOKS_JSON` and the unfiltered `rendered` digest is explicitly forbidden from being pasted, because `rendered` carries every kind and role — including non-planner-targeted contributions such as a `into: "checker"` twin — and pasting it would leak checker-scoped guidance into the planner's prompt (T-01-02 in the threat model); (3) the injection block sits inside `<planning_context>` AFTER `${AGENT_SKILLS_PLANNER}` and after the Project skills line, matching plan-phase's `:741` -> `:797` ordering (D-08), so agent-skills content is never shadowed by capability-contributed prose. No prose was moved into an eagerly `@`-imported reference to shrink the measured file — @gsd-core/references/loop-hook-dispatch.md already existed before this change and is deferred to for the generic contract only, exactly as plan-phase.md already does.

* test(#3778): expand quick.md plan:pre dispatch coverage to all nine locked conditions

Extend tests/quick-plan-pre-capabilities.test.cjs with D-02 (silent
omit-when-empty), D-03 (single shared planner spawn), D-06 (array-order
dispatch phrasing), D-07 (planner-only into filter), and D-08 (render call
< agent-skills placeholder < injection block < spawn ordering) assertions,
all extracted via a brace-bounded slice anchored on the literal injection
instruction rather than a naive first-brace scan (${AGENT_SKILLS_PLANNER}
and the surrounding prompt's ${VALIDATE_MODE ? ...} ternaries also contain
brace pairs).

Add a capability-registry.test.cjs describe block proving the registry-wide
D-07 exclusion is meaningful: at least one plan:pre contribution exists,
every plan:pre contribution has a non-empty into/fragment.inline, and the
registry as a whole carries at least one non-planner-into contribution.

Add a loop-host-contract.test.cjs regression pin for D-09: quick.md stays
absent from STEP_WORKFLOWS, parseLoopHostBlock still throws on quick.md's
real content, and buildContract() still yields exactly 5 entries.

Verified red-without-Task-1 by temporarily reverting quick.md to its
pre-f30de9cc content and re-running these three suites (D-08 failed as
expected), then restored via git checkout and re-confirmed green.

* docs(#3778): note quick planning also renders plan:pre in the tutorial

The tutorial's Step 6 named only /gsd-plan-phase as the trigger for the
plan:pre hook set. Since quick.md now dispatches the same hook set
(f30de9cc), the sentence understated the capability's real reach.

* feat(#3778): add changeset fragment

* chore(#3778): reference the upstream issue in the changeset fragment

The fragment was the only one of 81 in .changeset/ without a trailing
(#NNNN) reference or a bold lead-in. serializeChangelog auto-appends
only the pr: field, so the rendered CHANGELOG entry carried no link
back to issue #3778.

* test(#3778): scope the D-07 registry assertion to what it actually proves

The registry-wide non-planner check was named "D-07 exclusion is
meaningful", which overclaims: it proves only that `into` takes
non-planner values somewhere in the registry, not that anything is
excluded at plan:pre. Every plan:pre contribution is currently
into: "planner", so the filter is a forward-looking safeguard there.

Narrowing the assertion to plan:pre (as review suggested) would fail
today. Asserting plan:pre is all-planner would be brittle — it would
break the day a legitimate non-planner plan:pre contribution lands,
which is exactly when the safeguard starts doing work. So the
assertion is unchanged and only the name and comment are corrected.

* chore(#3778): point the changeset fragment at the upstream PR

The fragment carried pr: 3, the fork staging PR. changeset lint derives
the real PR number from GITHUB_EVENT_PATH, so on the upstream PR that
would read as pr-field drift. Point it at open-gsd/gsd-core#3934.

* test(#3778): require contributions in Quick revision prompts

* test(loop-host): require Quick auxiliary registration

* fix(#3778): preserve contributions in Quick plan revisions

* fix(#3778): validate Quick as a planner contribution host

* fix(#3778): tighten Quick contribution contract

* test(#3778): drop unnecessary source-contract exemption

* fix(#3778): require Quick planner target coverage

* docs(#3778): describe targeted auxiliary coverage

---------

Co-authored-by: davdittrich <davdittrich@gmail.com>
Co-authored-by: CI Rebase Check <ci@gsd-redux>
Co-authored-by: Tom Boucher <trekkie@nomorestars.com>

tests/loop-host-contract.test.cjs

@@ -74,6 +74,11 @@ function makeValidWorkflowFiles() {
       // Cross-check content: must contain the agent names
       'gsd-phase-researcher gsd-planner gsd-plan-checker',
     ),
+    'quick.md': [
+      'PLAN_PRE_HOOKS_JSON=$(gsd_run loop render-hooks plan:pre --raw)',
+      'For each active entry where `kind == "contribution"` and `into == "planner"`: inject.',
+      '',
+    ].join('\n'),
     'execute-phase.md': makeWorkflow(
       'execute', ['execute:pre', 'execute:wave:pre', 'execute:wave:post', 'execute:post'],
       ['executor', 'verifier'],
@@ -438,6 +443,97 @@ describe('module exports', () => {
   });
 });
 
+// ─── #3778 — quick.md is auxiliary without becoming a 6th serialized step ────
+
+describe('Quick auxiliary loop-host contract (#3778)', () => {
+  function makeQuickWorkflow({ includePoint = true, includeKind = true, into = 'planner' } = {}) {
+    const target = into === null ? '' : ` and \`into == "${into}"\``;
+    return [
+      includePoint ? 'PLAN_PRE_HOOKS_JSON=$(gsd_run loop render-hooks plan:pre --raw)' : '',
+      includeKind ? `For each active entry where \`kind == "contribution"\`${target}: inject.` : '',
+      '',
+    ].join('\n');
+  }
+
+  test('Quick is a generator-owned plan auxiliary host with its own contribution expectation', () => {
+    const plan = STEP_WORKFLOWS.find((workflow) => workflow.step === 'plan');
+    assert.deepEqual(plan.auxiliaryHosts, [
+      { file: 'quick.md', point: 'plan:pre', kinds: ['contribution'], into: 'planner' },
+    ]);
+
+    const files = makeValidWorkflowFiles();
+    files['quick.md'] = makeQuickWorkflow();
+    const tmpDir = makeTempWorkflowsDir(files);
+    try {
+      const contract = buildContract(tmpDir);
+      assert.strictEqual(contract.length, 5, 'auxiliary hosts must not create a sixth serialized step');
+      assert.strictEqual(
+        new Set(contract.flatMap((entry) => entry.points)).size,
+        12,
+        'auxiliary hosts must not create a duplicate lifecycle point',
+      );
+    } finally {
+      cleanup(tmpDir);
+    }
+  });
+
+  test('buildContract rejects Quick without its plan:pre render seam', () => {
+    const files = makeValidWorkflowFiles();
+    files['quick.md'] = makeQuickWorkflow({ includePoint: false });
+    const tmpDir = makeTempWorkflowsDir(files);
+    try {
+      assert.throws(
+        () => buildContract(tmpDir),
+        /quick\.md: auxiliary host missing expected point "plan:pre"/,
+      );
+    } finally {
+      cleanup(tmpDir);
+    }
+  });
+
+  test('buildContract rejects Quick without its contribution dispatch', () => {
+    const files = makeValidWorkflowFiles();
+    files['quick.md'] = makeQuickWorkflow({ includeKind: false });
+    const tmpDir = makeTempWorkflowsDir(files);
+    try {
+      assert.throws(
+        () => buildContract(tmpDir),
+        /quick\.md: auxiliary host point "plan:pre" missing expected kind "contribution"/,
+      );
+    } finally {
+      cleanup(tmpDir);
+    }
+  });
+
+  test('buildContract rejects a Quick contribution dispatch targeting the wrong role', () => {
+    const files = makeValidWorkflowFiles();
+    files['quick.md'] = makeQuickWorkflow({ into: 'orchestrator' });
+    const tmpDir = makeTempWorkflowsDir(files);
+    try {
+      assert.throws(
+        () => buildContract(tmpDir),
+        /quick\.md: auxiliary host point "plan:pre" missing expected kind "contribution"/,
+      );
+    } finally {
+      cleanup(tmpDir);
+    }
+  });
+
+  test('buildContract rejects a Quick contribution dispatch without its planner target', () => {
+    const files = makeValidWorkflowFiles();
+    files['quick.md'] = makeQuickWorkflow({ into: null });
+    const tmpDir = makeTempWorkflowsDir(files);
+    try {
+      assert.throws(
+        () => buildContract(tmpDir),
+        /quick\.md: auxiliary host point "plan:pre" missing expected kind "contribution"/,
+      );
+    } finally {
+      cleanup(tmpDir);
+    }
+  });
+});
+
 // ─── 8. Regression: FIX 1 — per-step point ownership ────────────────────────
 
 describe('assertPointsCoverage per-step ownership (FIX 1)', () => {