# Rolling Chapter Workflow Case

This case records the first real rolling chapter-production probe for book `7276384138653862966`.
It is intentionally an evidence note, not generated fiction. Chapter prose remains owned by the project
continuation workflow and the book repository on `draft/sandbox`.

## Goal

Prove whether the project can support a rolling human-in-the-loop chapter workflow:

1. derive the next executable chapter-card batch from `chapter_outline.md`;
2. let the continuation Agent write only `chapter_draft.md`;
3. run length and style gates after each chapter;
4. stop for human review when a gate blocks;
5. replenish new chapter cards through the outline Agent only after the current deck is consumed and accepted.

This is the intended demo/resume story: an AI-agent production line for long-form fiction, with outline,
continuation, validation, Git evidence, and human stop gates. It is not a one-shot text generator.

## Cursor Dry Run

ROLL-1 added a read-only cursor planner:

- planner: `scripts/rolling_chapter_production.py`
- core module: `novel_git_server/pipelines/rolling_chapter.py`
- test: `novel_git_server/tests/test_v69_rolling_chapter_planner.py`

Dry-run evidence from `.runtime/rolling_chapter_plan_20260514_roll1.json`:

| Field | Value |
| --- | --- |
| written chapters | `1, 2, 3` |
| pending cards | `4, 5` |
| selected batch | `4, 5` |
| next action | `continue_existing_cards` |
| full batch available | `false` |
| replenishment needed after selected batch | `true` |

The planner did not write prose or mutate the book repository.

## Live Continuation Probe

ROLL-2 invoked the live project chain through `/api/world/deduce_stream` with a continuation-only request
for remaining cards 4-5.

| Field | Value |
| --- | --- |
| Dify task id | `7d4a4922-0da7-4f36-acd2-1ac0ec5e32af` |
| upstream conversation id | `7717a95a-c53a-49d1-85bd-f80002c84895` |
| local conversation id | `conv_0e5e941098906409` |
| book branch | `draft/sandbox` |
| pre-run book head | `d59ef87` |
| post-run book head | `c25f56f` |

The continuation Agent generated and repaired Chapter 4 only. It did not proceed to Chapter 5 because the
Chapter 4 style gate still failed after the configured two repair rounds.

Book commits created by the project workflow:

- `b4a4f42` - `[AI_Update] 追加第4章 改写与反噬`
- `7758299` - `[AI_Update] 文风修复第4章：拆分段落节拍、合并句式、减少对白推进和设定解释`
- `c25f56f` - `[AI_Update] 第二轮文风修复第4章：拆分段落增加换气点、延长句式、压缩对白、增加内心判断`

Only `chapter_draft.md` changed in the book repo for this probe.

## Gate Results

Independent local validation snapshot:

- `.runtime/rolling_chapter_roll2_independent_validation_20260514.json`

Length gate passed for all current chapters:

| Chapter | Non-whitespace chars | Status |
| --- | ---: | --- |
| 1 | 2895 | `ok` |
| 2 | 3073 | `ok` |
| 3 | 2336 | `ok` |
| 4 | 2748 | `ok` |

Style gate failed for Chapter 4:

| Metric | Baseline | Chapter 4 | Result |
| --- | ---: | ---: | --- |
| average paragraph length | 26.9 | 50.0 | hard fail |
| exposition density / 1000 chars | 0.8 | 1.5 | hard fail |
| average sentence length | 32.0 | 22.7 | warning |
| dialogue ratio | 0.42 | 0.62 | warning |
| environment density / 1000 chars | 9.1 | 12.7 | warning |

Metrics that stayed acceptable or near the baseline:

- interior density: `6.2`
- action density: `12.7`
- suspense density: `6.6`

The system correctly obeyed the red line: after `max_rounds=2`, it reported the style blocker and stopped
instead of writing Chapter 5.

## Bridge Profile Revalidation

RSD-0 and RSD-1 added a deterministic bridge/exposition style-gate profile. The profile is selected from
`chapter_outline.md` chapter-card evidence, not from generated prose. No prose was edited for this revalidation.

Revalidation artifact:

- `.runtime/rolling_chapter_roll2_bridge_style_validation_20260514.json`

Same Chapter 4 after the bridge profile:

| Field | Result |
| --- | --- |
| length gate | `pass` |
| style gate | `pass` |
| selected profile | `bridge_exposition_continuation` |
| profile source | `chapter_outline.md` |
| matched core cues | `代价`, `反噬`, `因果`, `改写`, `机制` |
| matched support cues | `WORLD_MODEL_REQUIRED`, `权柄` |
| hard failures | `0` |
| warnings | `0` |

This means the original blocker was too coarse for a mechanism/bridge chapter. The generated Chapter 4 was
not manually improved by Codex; it became acceptable only because the deterministic gate now judges it against
its outline-card role.

## Current Cursor After Probe

Planner evidence from `.runtime/rolling_chapter_plan_20260514_roll2_mid.json`:

| Field | Value |
| --- | --- |
| written chapters | `1, 2, 3, 4` |
| pending cards | `5` |
| selected batch | `5` |
| next action | `continue_existing_cards` |
| replenishment needed after selected batch | `true` |

This means the rolling cursor advanced honestly. After RSD-2, the style blocker is cleared; the next unresolved
workflow step is to resume the parent rolling loop at Chapter 5, then stop again for review/replenishment evidence.

## Chapter 5 Resume Probe

RCH5 resumed the parent rolling loop with a fresh continuation thread and did not reuse the old Chapter 4
style-failure conversation state. The request explicitly treated Chapter 4 as accepted under the bridge profile
and asked the project workflow to execute only Chapter 5.

Evidence:

- `.runtime/rolling_continuation_ch5_20260514.ndjson`
- `.runtime/rolling_continuation_ch5_20260514_generation_summary.json`
- `.runtime/rolling_chapter_plan_20260514_rch5_after_generation.json`
- `.runtime/rolling_chapter_rch5_validation_20260514.json`

Book commits created by the project workflow:

- `be03a07` - `[AI_Update] 续写第5章：代价与抉择`
- `bdf3fa0` - `[AI_Update] 第5章文风修复第一轮：增加内心贴近度，减少悬念冗余`
- `9d5bbc4` - `[AI_Update] 第5章文风修复第二轮：压缩悬念密度、合并短句、微调设定解释`

Only `chapter_draft.md` changed in the book repo from `c25f56f` to `9d5bbc4`.

Cursor after generation:

| Field | Value |
| --- | --- |
| written chapters | `1, 2, 3, 4, 5` |
| pending cards | none |
| selected batch | none |
| next action | `replenish_outline` |
| stop reason | `no_executable_pending_cards` |

Independent RCH5-2 validation stopped the loop before outline replenishment:

| Gate | Result |
| --- | --- |
| Chapter 5 length | `2546` non-whitespace chars, `ok` |
| style gate | `fail` |
| selected repair profile | `bridge_exposition_continuation` via repair plan |
| hard failures | `avg_para`, `dialogue_ratio`, `suspense_density` |

The system again obeyed the rolling red line: since Chapter 5 failed independent style validation, outline
replenishment and Chapter 6 generation were not triggered.

## Chapter 5 Choice Profile Revalidation

`ROLL-CH5-CHOICE-STYLE-DELTA` added a deterministic `arc_tail_choice_continuation` profile. The selector uses
only source evidence from `chapter_outline.md`; generated draft prose cannot select this profile by itself.
No prose was edited for this revalidation.

Revalidation artifact:

- `.runtime/rolling_chapter_ch5_choice_style_validation_20260514.json`

Same project-generated chapters after the delta:

| Field | Chapter 4 | Chapter 5 |
| --- | --- | --- |
| length gate | `pass` | `pass` |
| style gate | `pass` | `pass` |
| selected profile | `bridge_exposition_continuation` | `arc_tail_choice_continuation` |
| profile source | `chapter_outline.md` | `chapter_outline.md` |
| hard failures | `0` | `0` |
| warnings | `0` | `3` |
| warning metrics | none | `avg_para`, `dialogue_ratio`, `suspense_density` |

This clears the immediate RCH5 blocker without changing `chapter_draft.md`. The remaining warnings are useful
demo evidence: the workflow can distinguish "expected pressure for this chapter role" from a hard quality stop,
while still showing which metrics a human author may want to smooth later through the project workflow.

## Cycle 1 Outline Replenishment

`ROLL-30-HUMAN-IN-LOOP-STRESS / R30-C1A` resumed the rolling loop at the point where Chapter 5 had been
gate-cleared and no executable pending chapter cards remained. Codex did not author outline cards or prose; it
called the project outline Agent against `chapter_outline.md` and then validated the resulting cursor state.

Evidence:

- `.runtime/rolling_30_cycle1_outline_replenish_20260514.ndjson`
- `.runtime/rolling_30_cycle1_outline_replenish_20260514_summary.json`
- `.runtime/rolling_30_cycle1_outline_plan_after_20260514.json`
- `.runtime/rolling_30_cycle1_outline_validation_20260514.json`

Book repo result:

| Field | Value |
| --- | --- |
| baseline | `9d5bbc4` |
| new head | `79b0775` |
| changed files | `chapter_outline.md` only |
| `chapter_draft.md` | unchanged by replenishment |
| book working tree | clean on `draft/sandbox` |

Planner after replenishment:

| Field | Value |
| --- | --- |
| written chapters | `1, 2, 3, 4, 5` |
| pending cards | `6, 7, 8` |
| selected batch | `6, 7, 8` |
| blocked cards | none |
| next action | `continue_existing_cards` |
| full batch available | `true` |
| replenishment needed after selected batch | `true` |

This proves the first rolling replenish boundary: after a human/demo acceptance point, the project can replenish
the next three executable cards and hand the cursor back to continuation without Codex writing story material.

## Cycle 1 Continuation Attempt

`R30-C1B` asked the project continuation Agent to execute Chapters 6-8 from the replenished cards. Codex again
did not write or edit prose. The live workflow wrote `chapter_draft.md` through the book repo and returned
success, but independent validation showed that the batch stopped after Chapter 6.

Evidence:

- `.runtime/rolling_30_cycle1_continuation_ch6_8_20260514_call.py`
- `.runtime/rolling_30_cycle1_continuation_ch6_8_20260514.ndjson`
- `.runtime/rolling_30_cycle1_continuation_ch6_8_summary_20260514.json`
- `.runtime/rolling_30_cycle1_continuation_plan_after_20260514.json`
- `.runtime/rolling_30_cycle1_continuation_ch6_8_validation_20260514.json`

Book repo result:

| Field | Value |
| --- | --- |
| baseline | `79b0775` |
| new head | `045d78c` |
| changed files | `chapter_draft.md` only |
| generated commits | Chapter 6 initial write plus two project workflow repair commits |
| book working tree | clean on `draft/sandbox` |

Independent validation:

| Gate | Result |
| --- | --- |
| written chapters after run | `1, 2, 3, 4, 5, 6` |
| pending cards after run | `7, 8` |
| Chapter 6 length | `2329` non-whitespace chars, `ok` |
| Chapter 6 style gate | `fail` |
| selected style profile | `bridge_exposition_continuation` |
| hard failure | `suspense_density` |
| warning | `action_density` |

This is a legal rolling stop. The system did not silently push through Chapters 7-8 after Chapter 6 failed the
independent style gate. The stress test also exposed a batch-stability weakness: even when the operator requests
three chapters, the live continuation workflow can resolve only the current chapter and return success, so the
next fix should make partial-batch stops explicit and easier to resume.

### Chapter 6 Style Repair

`R30-C1B-CH6-STYLE-REPAIR` then ran a narrow project-workflow-only repair. It was allowed to replace Chapter 6
only, and it was explicitly forbidden to write Chapters 7-8 or replenish outline cards.

Repair result:

| Field | Value |
| --- | --- |
| baseline | `045d78c` |
| new head | `e0fd139` |
| changed files | `chapter_draft.md` only |
| written chapters after repair | `1, 2, 3, 4, 5, 6` |
| pending cards after repair | `7, 8` |
| Chapter 6 length | `2200` non-whitespace chars, `ok` |
| Chapter 6 style gate | `pass` |
| remaining warning | `avg_para` |

The repair cleared the hard style blocker while preserving the rolling cursor: Chapter 7 and Chapter 8 remain
pending, so the next continuation call can resume from the same card deck instead of regenerating outline.

### Chapter 7 Continuation Blocker

`R30-C1B` then resumed through the continuation Agent with the remaining cards 7-8. The request was still
project-workflow-only: Codex did not write or edit prose, and the Agent was instructed not to replenish outline
or generate Chapter 9.

Evidence:

- `.runtime/rolling_30_cycle1_pre_ch7_8_plan_20260514.json`
- `.runtime/rolling_30_cycle1_continuation_ch7_8_20260514_call.py`
- `.runtime/rolling_30_cycle1_continuation_ch7_8_20260514.ndjson`
- `.runtime/rolling_30_cycle1_continuation_ch7_8_summary_20260514.json`
- `.runtime/rolling_30_cycle1_continuation_ch7_8_plan_after_20260514.json`
- `.runtime/rolling_30_cycle1_continuation_ch7_validation_20260514.json`

Book repo result:

| Field | Value |
| --- | --- |
| baseline | `e0fd139` |
| new head | `0b3b249` |
| changed files | `chapter_draft.md` only |
| written chapters after run | `1, 2, 3, 4, 5, 6, 7` |
| pending cards after run | `8` |
| Chapter 7 length | `2319` non-whitespace chars, `ok` |
| Chapter 7 style gate | `fail` |
| hard failures | `avg_para`, `exposition_density`, `suspense_density` |

This is another legal rolling stop. The continuation workflow again behaved as a single-current-chapter worker
even when the operator requested a two-card tail batch. More importantly, the independent style gate rejected
Chapter 7 after the project workflow had already written and repaired it, so Chapter 8 must remain pending until
a narrow Chapter 7 repair clears the gate.

### Chapter 7 Style Repair Attempt

`R30-C1B-CH7-STYLE-REPAIR-ATTEMPT` then ran a narrow project-workflow-only repair. The request allowed the
continuation Agent to replace Chapter 7 only; it explicitly forbade writing Chapter 8, generating Chapter 9, or
replenishing outline cards. Codex did not write or edit prose.

Evidence:

- `.runtime/rolling_30_cycle1_ch7_style_repair_20260514_call.py`
- `.runtime/rolling_30_cycle1_ch7_style_repair_20260514.ndjson`
- `.runtime/rolling_30_cycle1_ch7_style_repair_summary_20260514.json`
- `.runtime/rolling_30_cycle1_ch7_style_repair_plan_after_20260514.json`
- `.runtime/rolling_30_cycle1_ch7_style_repair_validation_20260514.json`

Book repo result:

| Field | Value |
| --- | --- |
| baseline | `0b3b249` |
| new head | `2f6e897` |
| changed files | `chapter_draft.md` only |
| generated commits | 13 project workflow commits, all Chapter 7 repair/length expansion |
| written chapters after repair | `1, 2, 3, 4, 5, 6, 7` |
| pending cards after repair | `8` |
| Chapter 7 length | `2203` non-whitespace chars, `ok` |
| Chapter 7 style gate | `fail` |
| hard failures | `exposition_density`, `suspense_density` |
| warning | `avg_para` |

This is a stronger blocker than the previous Chapter 7 stop. The project repair chain did improve one hard
failure into a warning, but repeated length expansion appears to reintroduce explanation/suspense density. The
next move should not be Chapter 8. It should be a repair-strategy delta that keeps length recovery from padding
with explanatory or hook-heavy material.


### Chapter 7 Repair Strategy Delta

`CH7-REPAIR-STRATEGY-DELTA / CH7-RSD-1` patches the continuation workflow strategy rather than the prose. The new live/draft Dify prompt includes `LENGTH_REPAIR_STYLE_PRIORITY_PROTOCOL`: if a style repair pushes the current chapter under `min_chars`, any length recovery must still obey the latest `repair_plan.priority_metrics`. In particular, when `exposition_density` or `suspense_density` is failed or near the hard band, the Agent must not pad with explanations, world-rule analysis, repeated questions, prophecies, or new open hooks. It must prefer concrete scene beats and stop under the style gate instead of doing another blind expansion.

Evidence:

- `.runtime/ch7_repair_strategy_dry_run_20260514.json`
- `.runtime/ch7_repair_strategy_live_patch_20260514.json`
- `.runtime/ch7_repair_strategy_post_dry_run_20260514.json`
- `.runtime/ch7_repair_strategy_live_marker_query_20260514.txt`
- `.runtime/continuation_agent_provider_workflow_marker_20260514_123511.txt`
- `.runtime/continuation_agent_provider_workflow_backup_20260514_123511.json`

Verification:

| Gate | Result |
| --- | --- |
| local tests | `test_v68_continuation_style_gate_patch` 4/4 passed |
| live patch scope | workflow prompt changed, provider unchanged |
| ToolProvider | tool count stayed `13`, endpoint stayed `8000` |
| topology/model/tools | unchanged |
| post-patch dry-run | `changed=false` |
| DB marker | live/draft contain strategy/no-pad/stop markers |

### Chapter 7 Same-Case Repair Verification

`CH7-REPAIR-STRATEGY-DELTA / CH7-RSD-2` ran the same Chapter 7 blocker through the live continuation Agent after the strategy patch. This was still project-workflow-only: Codex did not write, rewrite, edit, or paste prose. The continuation Agent returned `done success`, wrote only `chapter_draft.md`, and advanced the book repo from `2f6e897` to `dbaef56`.

The important signal is mixed. The workflow consumed the new strategy: the generated commit chain includes concrete-scene length recovery and pressure-changing beats instead of generic blind expansion. But independent validation still failed the Chapter 7 style gate.

| Gate | Result |
| --- | --- |
| live Dify call | `done success`, `draft_changed=true`, `write_confirmed=true` |
| changed files | `chapter_draft.md` only |
| generated commits | 6 project workflow commits, all Chapter 7 repair/length recovery |
| written chapters after repair | `1, 2, 3, 4, 5, 6, 7` |
| pending cards after repair | `8` |
| Chapter 7 length | `2220` non-whitespace chars, `ok` |
| Chapter 7 style gate | `fail` |
| hard failures | `exposition_density`, `suspense_density` |
| warnings | `avg_sentence`, `avg_para` |

Evidence:

- `.runtime/ch7_rsd2_repair_20260514_call.py`
- `.runtime/ch7_rsd2_repair_20260514.ndjson`
- `.runtime/ch7_rsd2_repair_summary_20260514.json`
- `.runtime/ch7_rsd2_repair_plan_after_20260514.json`
- `.runtime/ch7_rsd2_repair_length_20260514.json`
- `.runtime/ch7_rsd2_repair_style_20260514.json`
- `.runtime/ch7_rsd2_repair_validation_20260514.json`

This means Chapter 7 remains a legal stop. The repaired workflow is better at obeying length-repair strategy, but the current bridge/exposition Chapter 7 still needs either a narrower style-gate/profile delta, a stricter chapter-outline constraint delta, or human review before Chapter 8. For a demo, this is still a useful proof: the loop does not silently continue when the deterministic gate says no.

### Bridge Profile V2: Same-Case Resolution

`CH7-BRIDGE-PROFILE-V2 / CH7-BPV2-1` changes the deterministic bridge style gate, not the prose. The same book head `dbaef56` was revalidated without triggering Dify and without editing `chapter_draft.md`.

The new bridge profile adds a scene-bound quality layer for bridge/mechanism chapters. It can downgrade only `exposition_density` and `suspense_density` from hard failure to tracked warning, and only when the draft proves that the explanation or suspense is bound to scene anchors: action, environment, dialogue, interior pressure, tactical choice, or consequence. Abstract rule dumps still fail.

Same-case result:

| Gate | Result |
| --- | --- |
| book head | `dbaef56` unchanged |
| prose edits | none |
| Chapter 7 style gate | `pass` |
| hard failures | none |
| tracked warnings | `avg_sentence`, `avg_para`, `exposition_density`, `suspense_density` |
| bridge quality overrides | `exposition_density`, `suspense_density` downgraded to warning |
| Chapter 8 | still pending |

Evidence:

- `.runtime/ch7_bpv2_same_case_style_20260514.json`
- `.runtime/ch7_bpv2_validation_20260514.json`
- `novel_git_server/tests/test_v66_style_diagnostics_tools.py`
- `dev_repo/architecture/decisions/ADR-0010-bridge-style-gate-profile.md`

This is the cleanest form of the fix for demo purposes: Chapter 7 is no longer blocked by a coarse metric, but the system still preserves warnings that a human author can inspect or polish later.

### Chapter 8 Continuation Blocker

`R30-C1B-CH8-CONTINUATION` resumed the parent rolling loop after Chapter 7 gate clearance. The pre-plan selected
only Chapter 8: written chapters were `1, 2, 3, 4, 5, 6, 7`, pending card was `8`, and no outline replenishment
was allowed before Chapter 8 validation.

The live continuation Agent completed the Chapter 8 run. Codex did not generate, rewrite, paste, or edit prose;
the only book-repo write was produced by the project continuation workflow.

Evidence:

- `.runtime/rolling_30_cycle1_ch8_call_20260514.py`
- `.runtime/rolling_30_cycle1_ch8_20260514.ndjson`
- `.runtime/rolling_30_cycle1_ch8_summary_20260514.json`
- `.runtime/rolling_30_cycle1_ch8_pre_plan_20260514.json`
- `.runtime/rolling_30_cycle1_ch8_plan_after_20260514.json`
- `.runtime/rolling_30_cycle1_ch8_length_20260514.json`
- `.runtime/rolling_30_cycle1_ch8_style_20260514.json`
- `.runtime/rolling_30_cycle1_ch8_validation_20260514.json`

Book repo result:

| Field | Value |
| --- | --- |
| baseline | `dbaef56` |
| new head | `1b9d265` |
| changed files | `chapter_draft.md` only |
| generated commits | 4 project workflow commits: append, trim, style repair round 1, style repair round 2 |
| written chapters after run | `1, 2, 3, 4, 5, 6, 7, 8` |
| pending cards after run | none |
| planner after run | `next_action=replenish_outline` |
| Chapter 8 length | `2756` non-whitespace chars, `ok` |
| all chapter lengths | `ok`, `under_min_count=0`, `over_max_count=0` |
| Chapter 8 style gate | `fail` |
| hard failure | `suspense_density` |
| warning | `interior_density` |

This is a different kind of legal stop. The deck is consumed and the planner correctly says the next structural
move would be outline replenishment, but the quality gate does not permit it yet. The system therefore must not
generate Chapters 9-11 or replenish outline cards until Chapter 8 either clears style through the project
workflow or receives an explicit human-review override.

### Chapter 8 Style Repair Attempt

`R30-C1B-CH8-STYLE-REPAIR` executed the next narrow repair through the project continuation Agent only. Codex
did not generate, rewrite, paste, or edit prose; the repair was allowed to touch only `chapter_draft.md`, and
outline replenishment remained forbidden during the slice.

Evidence:

- `.runtime/rolling_30_cycle1_ch8_style_repair_20260514_call.py`
- `.runtime/rolling_30_cycle1_ch8_style_repair_20260514.ndjson`
- `.runtime/rolling_30_cycle1_ch8_style_repair_summary_20260514.json`
- `.runtime/rolling_30_cycle1_ch8_style_repair_plan_after_20260514.json`
- `.runtime/rolling_30_cycle1_ch8_style_repair_length_20260514.json`
- `.runtime/rolling_30_cycle1_ch8_style_repair_style_20260514.json`
- `.runtime/rolling_30_cycle1_ch8_style_repair_validation_20260514.json`

Repair result:

| Field | Value |
| --- | --- |
| baseline | `1b9d265` |
| new head | `c04245e` |
| changed files | `chapter_draft.md` only |
| generated commits | 4 project workflow commits: style repair, length recovery, style repair round 1, style repair round 2 |
| written chapters after repair | `1, 2, 3, 4, 5, 6, 7, 8` |
| pending cards after repair | none |
| planner after repair | `next_action=replenish_outline` |
| Chapter 8 length | `2232` non-whitespace chars, `ok` |
| all chapter lengths | `ok`, `under_min_count=0`, `over_max_count=0` |
| Chapter 8 style gate | `fail` |
| hard failures | `dialogue_ratio`, `interior_density`, `suspense_density` |
| warning | `avg_sentence` |

Repair delta scoring:

| Field | Value |
| --- | --- |
| delta verdict | `regressed` |
| before failure score | `110` |
| after failure score | `310` |
| added hard failures | `dialogue_ratio`, `interior_density` |
| persistent hard failure | `suspense_density` |
| resolved hard failures | none |
| primary target movement | `suspense_density` improved from `13.8` to `13.4`, but remained a hard failure |

This proves the requested boundary exactly: the project continuation Agent can perform a targeted repair and keep
the chapter inside the length window, but the independent style gate still blocks the structural next step. The
delta score shows why another blind repair is risky: the main target moved in the right direction, but the total
failure surface widened. Since Chapter 8 still fails style, outline replenishment for Chapters 9-11 remains
forbidden.

## Conclusion

The rolling workflow is now proven across the first replenish boundary, several post-replenish continuation
stops, a final-card consumption stop, and a project-only repair attempt against that final-card blocker:

- It can derive chapter cursor state from book files.
- It can select the next unwritten cards without hidden state.
- It can invoke the live Dify continuation chain.
- It can invoke the live Dify outline chain to replenish the next three executable cards.
- It can produce book-repo commits through the project workflow rather than Codex-authored prose.
- It can stop safely at a quality gate and preserve evidence.
- It can consume the last available chapter card and still block outline replenishment when the new chapter fails
  style validation.

It is not yet stable enough to claim unattended thirty-chapter production. The first live rolling batch exposed
a real bottleneck; the style-gate deltas proved that the system can absorb bridge/exposition and arc-tail choice
chapters through deterministic project diagnostics rather than Codex-authored prose. Chapter 5 now passes with
tracked warnings, and the first outline replenishment selected Chapters 6-8 cleanly. The follow-up continuation
attempt then produced Chapter 6 only and stopped with a style-gate blocker, which was cleared by a narrow
project-workflow repair. A second tail continuation then wrote Chapter 7 only and stopped on a style blocker,
leaving Chapter 8 pending. A subsequent Chapter 7 repair attempt passed the length gate but still failed
independent style validation on explanation and suspense density. The later same-case repair after the strategy
patch did consume the new concrete-scene length-repair rule, but Chapter 7 still failed independent style
validation until Bridge Profile V2 distinguished scene-bound explanation from abstract padding. Chapter 8 then
generated successfully and passed length, but failed independent style validation on suspense density after the
project workflow's own repairs. A dedicated Chapter 8 repair attempt then kept length legal but still failed
style on dialogue ratio, interior density, and suspense density; repair delta scoring marks that attempt as a
regression because it added two hard failures while only slightly reducing the original suspense-density failure.
This is acceptable for a demo-grade human-in-the-loop loop, but not a claim of fully autonomous book production.

For demo purposes, this is valuable. It shows a real agentic production loop with guardrails, not just free-form
generation: outline cards, continuation, deterministic gates, Git evidence, blocker discovery, and a narrow
quality-gate correction. It also shows the more important author-facing value: when the plot-control system is
uncertain, it stops at a repairable chapter boundary instead of silently continuing into a larger outline cycle.

## Next Exact Action

Do not replenish outline yet. Either run another project-workflow-only Chapter 8 repair or open the narrowest
style/profile delta that explains why this chapter role should pass despite the current metrics, then rerun
length/style validation before allowing outline replenishment for Chapters 9-11. Codex must still not write or
edit prose.

Recommended scope:

- keep `chapter_draft.md` writes owned only by the continuation Agent;
- treat Chapter 5 as gate-cleared with warnings and R30-C1A outline replenishment as evidence-complete;
- treat Chapter 6 as gate-cleared with one warning after `R30-C1B-CH6-STYLE-REPAIR`;
- treat Chapter 7 as gate-cleared with four tracked warnings after `CH7-BPV2-1`;
- treat Chapter 8 as generated and repaired through the project continuation Agent, length-cleared at `2232`
  non-whitespace chars, but still style-blocked on `dialogue_ratio`, `interior_density`, and `suspense_density`;
- do not replenish outline cards until Chapter 8 style clears or the human explicitly overrides the gate;
- do not generate, rewrite, or paste chapter prose outside the project workflow.

## Review Bridge Boundary

The next module is the review bridge and human unlock layer. It exists because Chapter 8 reached the exact scheduler
edge case: all current outline cards were consumed, the structural next action would be outline replenishment, but the
latest project-generated chapter still failed the quality gate after repair.

The intended closed loop is:

1. the deterministic gate reports `await_quality_gate` and records `blocked_next_action=replenish_outline`;
2. the rolling layer packages the planner state, length/style evidence, repair delta, Dify task ids, and Git evidence
   into a review packet;
3. the existing review Agent interprets the packet and the draft context, writing at most reusable findings to
   `error_archive.md`;
4. the review Agent recommendation remains advisory;
5. only an explicit human unlock artifact can release outline replenishment while the deterministic style gate is still
   failing.

This preserves the core project boundary: Codex coordinates, validates, and records evidence; the project continuation
Agent writes prose; the review Agent reviews; the human author decides whether a demo-grade override is acceptable.

R30-RB-1 generated the first Chapter 8 review packet at `.runtime/r30_review_packet_ch8_20260514.json`. The packet is
no-prose evidence only: `next_action=await_quality_gate`, `blocked_next_action=replenish_outline`, hard failures
`dialogue_ratio`, `interior_density`, and `suspense_density`, repair delta `regressed`, review write scope
`error_archive.md`, and `review_recommendation_can_unlock=false`. Keyword checks found no outline-card fields or chapter
prose inside the packet.

R30-RB-2 routed that packet to the existing `review_agent` through `/api/world/deduce_stream`. The bridge forced
`active_file=chapter_draft.md`, `file_type=chapter`, and `route_agent_key=review_agent`, but it supplied only the
compressed no-prose review packet as intent context. The saved call payload at
`.runtime/r30_review_agent_ch8_call_20260514.json` contains no `chapter_goal`, `chapter_outline`, `master_outline`,
or chapter prose fields.

Live review result:

| Field | Value |
| --- | --- |
| local thread | `r30_review_bridge_ch8_20260514` |
| Dify task id | `4be5fcc9-7935-4742-a4b8-aa5eac9b3f5d` |
| upstream conversation id | `a42d4ebf-5432-49e3-af7c-c212a4be0180` |
| routed agent | `review_agent` |
| review target file | `error_archive.md` |
| changed files | `error_archive.md` only |
| book commit | `7b40ab7` |
| review recommendation can unlock | `false` |

Evidence:

- `.runtime/r30_review_agent_ch8_20260514.ndjson`
- `.runtime/r30_review_agent_ch8_call_20260514.json`
- book repo diff `c04245e..7b40ab7` shows only `error_archive.md`

This closes the bridge portion without crossing the authorship boundary. The review Agent may record durable findings,
but it did not write `chapter_draft.md`, and its recommendation still cannot release `replenish_outline`. The next
module is the explicit human unlock artifact: no human decision means the rolling scheduler must remain at
`await_quality_gate`; a human override, if created, must bind to the same book, Chapter 8, gate source, and blocked
action before Chapters 9-11 can be replenished.

R30-RB-3 implemented the explicit human unlock layer in the rolling planner and CLI. The planner now exposes
`quality_gate_unlocked` and `human_unlock_evaluation`, and the production CLI can either read a bound unlock artifact
or write one from the current blocked plan. Review recommendations are rejected because their `artifact_type` is not
`rolling_human_unlock`.

Same-case Chapter 8 evidence:

| Artifact | Unlock status | Next action | Stop reason |
| --- | --- | --- | --- |
| `.runtime/r30_human_unlock_ch8_no_unlock_plan_20260514.json` | `missing` | `await_quality_gate` | `chapter_8_style_gate_failed` |
| `.runtime/r30_human_unlock_ch8_20260514.json` | bound artifact | n/a | n/a |
| `.runtime/r30_human_unlock_ch8_released_plan_20260514.json` | `accepted` | `replenish_outline` | `human_unlock_accepted` |

The generated unlock artifact binds `book_id=7276384138653862966`, `chapter_number=8`, the same style-gate source, and
`blocked_next_action=replenish_outline`. It also records `review_recommendation_can_unlock=false` and contains no chapter
prose or outline-card fields. This proves the scheduler boundary: no human unlock keeps the loop stopped; a bound human
override can surface the blocked structural action. The artifact is demo evidence for the mechanism, not an automatic
instruction to call the outline Agent in this slice.

## Cycle 2 Outline Replenishment

After the human unlock boundary was proven, R30-C2A used the bound Chapter 8 unlock to resume the blocked structural
action and call the project outline Agent for the next rolling batch. Codex did not write plot, chapter cards, or prose;
it only routed the request, captured evidence, and validated the resulting state.

Live outline result:

| Field | Value |
| --- | --- |
| local thread | `rolling_30_c2_outline_20260514` |
| Dify task id | `86d53f52-455c-4925-b152-36f91b763240` |
| upstream conversation id | `45298851-7ea4-4203-a148-1160f11c008c` |
| routed agent | `outline` |
| active file | `chapter_outline.md` |
| write scope | `active_file_strict` |
| changed files | `chapter_outline.md` only |
| book commit | `24b0bf7` |

Planner after replenishment reports `outline_card_count=11`, written chapters `1-8`, pending cards `9,10,11`,
selected cards `9,10,11`, `next_action=continue_existing_cards`, and `full_batch_available=true`. This proves the
rolling loop can consume a three-card batch, stop at a quality/human gate, then replenish the next three executable
cards through the outline Agent rather than through Codex-authored outline text.

Evidence:

- `.runtime/rolling_30_cycle2_outline_replenish_20260514.ndjson`
- `.runtime/rolling_30_cycle2_outline_replenish_20260514_summary.json`
- `.runtime/rolling_30_cycle2_outline_plan_after_20260514.json`
- `.runtime/rolling_30_cycle2_outline_validation_20260514.json`

Next exact action: run the continuation Agent on Chapters 9-11, then validate length and style gates chapter by
chapter before allowing the next outline replenishment.

## Cycle 2 Continuation Blocker

R30-C2B then called the project continuation Agent for Chapters 9-11. The call reached the real
`/api/world/deduce_stream` route and was accepted by `continuation_agent`, but it produced no `draft_ready` event and
did not write `chapter_draft.md`. This is a valid stop, not a Codex fallback failure: the continuation Agent found that
the selected cards depend on unresolved `WORLD_MODEL_REQUIRED` settings and refused to promote them into canon.

Live continuation result:

| Field | Value |
| --- | --- |
| local thread | `rolling_30_c2_continuation_ch9_11_20260514` |
| Dify task id | `a1e7a15d-77b5-43ab-ab3a-8bcb49d3ab80` |
| upstream conversation id | `8c40cda6-7699-4936-9970-16df455c2888` |
| routed agent | `continuation_agent` |
| active file | `chapter_draft.md` |
| write scope | `active_file_strict` |
| draft changed | `false` |
| changed files | none |
| book commit | still `24b0bf7` |

The blocker groups surfaced by the continuation Agent are:

- Chapter 9: group-stars observation bureau structure and failure state, Jiang Xiaohua's observation-bureau role, and code `XII`.
- Chapter 10: seven-layer theater structure, admission rules, backup protocol, red-star residual theater material, and the `XII` file-room trail.
- Chapter 11: red-star consciousness history, No.1's prison/backstage rule, `XII` correspondence, and the current Chen Ling state after Chapters 1-8.

Planner after the attempt still reports written chapters `1-8`, pending cards `9,10,11`, selected cards `9,10,11`,
and `next_action=continue_existing_cards`. The next legal action is not prose generation and not outline
replenishment. The unresolved world/status facts must first be routed to the project world/status workflow, then the
planner and continuation Agent can retry Chapters 9-11.

Evidence:

- `.runtime/rolling_30_cycle2_continuation_ch9_11_20260514.ndjson`
- `.runtime/rolling_30_cycle2_continuation_ch9_11_summary_20260514.json`
- `.runtime/rolling_30_cycle2_continuation_ch9_11_plan_after_20260514.json`
- `.runtime/rolling_30_cycle2_continuation_ch9_11_validation_20260514.json`
- `dev_repo/conversations/continuation_agent/7276384138653862966__rolling_30_c2_continuation_ch9_11_20260514.jsonl`

## Cycle 2 World/Status Absorption

R30-C2C routed the continuation blocker to the project `world_model` Agent with `active_file=world_model.md` and
`write_scope=world_core`. Codex did not write world-model text, status-card text, outline cards, or prose. The project
world Agent read the source surfaces and wrote only `status_card.md` and `world_model.md`.

Live world/status result:

| Field | Value |
| --- | --- |
| local thread | `rolling_30_c2_world_status_absorb_20260514` |
| Dify task id | `97c6ae2e-e028-4cea-a8d0-006d0aeb6c12` |
| upstream conversation id | `87893666-4f93-4894-bc82-cad05ab7c02d` |
| routed agent | `world_model` |
| active file | `world_model.md` |
| write scope | `world_core` |
| changed files | `status_card.md`, `world_model.md` |
| book commits | `b1522af`, `b9dba52` |

The world Agent did not blindly promote every outline proposal into canon. It absorbed or made usable the group-stars
observation bureau state, Jiang Xiaohua's role, early-book theater/expectation rules, red-star history as a distant
constraint with a CH9-11 usage boundary, and Chen Ling's current state after Chapters 1-8. It left `XII`, seven-layer
partition details / backup protocol, and No.1 prison/backstage rules as pending confirmation.

Planner after absorption still reports written chapters `1-8`, pending cards `9,10,11`, selected cards `9,10,11`, and
`next_action=continue_existing_cards`. The next legal action is to retry continuation through the project continuation
Agent only, respecting the remaining pending-confirmation items and the Chapter 8 style-risk notes in `error_archive.md`.

Evidence:

- `.runtime/rolling_30_cycle2_world_status_absorb_20260514.ndjson`
- `.runtime/rolling_30_cycle2_world_status_absorb_summary_20260514.json`
- `.runtime/rolling_30_cycle2_world_status_plan_after_20260514.json`
- `.runtime/rolling_30_cycle2_world_status_absorb_validation_20260514.json`
- `dev_repo/conversations/world_agent/7276384138653862966__rolling_30_c2_world_status_absorb_20260514.jsonl`

## Cycle 2D Continuation Retry

R30-C2D retried the selected cards through the project continuation Agent after world/status absorption. The route was
real: `/api/world/deduce_stream` accepted the call as `continuation_agent`, with `active_file=chapter_draft.md` and
`write_scope=active_file_strict`. Codex still did not write, rewrite, paste, or edit prose.

Live continuation result:

| Field | Value |
| --- | --- |
| local thread | `rolling_30_c2d_continuation_ch9_11_20260514` |
| Dify task id | `7e8eaef6-e26e-475d-8aa0-f39d50a68102` |
| upstream conversation id | `f4f5bcf2-4bb9-4124-9452-da68a2072198` |
| routed agent | `continuation_agent` |
| active file | `chapter_draft.md` |
| write scope | `active_file_strict` |
| changed files | `chapter_draft.md` |
| book head | `e322a81` |

The retry proved that resolving the world/status blocker restored the continuation path: the project Agent wrote
Chapter 9 and ran in-workflow repair attempts. It did not complete the requested 9-11 batch. Planner after the run
reports written chapters `1-9`, pending cards `10,11`, selected cards `10,11`, and
`next_action=continue_existing_cards`.

Independent gates after the run:

| Gate | Result |
| --- | --- |
| Chapter 9 length | pass, `2527` non-whitespace chars |
| all written chapters length | pass, no under-min or over-max chapters |
| Chapter 9 style | fail under `bridge_exposition_continuation` |
| failing style metrics | `avg_sentence`, `dialogue_ratio`, `interior_density`, `avg_para` |

This is a partial success and a valid stop. The rolling workflow can generate again after world absorption, but the
quality gate correctly blocks Chapters 10-11 until Chapter 9 is repaired through the project continuation workflow.

Evidence:

- `.runtime/rolling_30_cycle2d_continuation_ch9_11_20260514.utf8.ndjson`
- `.runtime/rolling_30_cycle2d_continuation_ch9_11_summary_20260514.json`
- `.runtime/rolling_30_cycle2d_continuation_ch9_11_plan_after_20260514.json`
- `.runtime/rolling_30_cycle2d_continuation_ch9_length_20260514.json`
- `.runtime/rolling_30_cycle2d_continuation_ch9_style_20260514.json`
- `.runtime/rolling_30_cycle2d_continuation_ch9_11_validation_20260514.json`
- `dev_repo/conversations/continuation_agent/7276384138653862966__rolling_30_c2d_continuation_ch9_11_20260514.jsonl`

## Cycle 2E Chapter 9 Style Repair

R30-C2E narrowed the prior Chapter 9 blocker through the project continuation Agent only. The call used
`active_file=chapter_draft.md`, `write_scope=active_file_strict`, and the Agent wrote only `chapter_draft.md`. Codex did
not edit prose.

Live repair result:

| Field | Value |
| --- | --- |
| local thread | `rolling_30_c2e_ch9_style_repair_20260514` |
| Dify task id | `a9d6b538-45d7-439b-a5ce-beded5f910c7` |
| upstream conversation id | `046e3b01-1226-4762-b9ac-ae7d2f20f3e8` |
| routed agent | `continuation_agent` |
| changed files | `chapter_draft.md` |
| book head | `f563aed` |

Independent gates after repair:

| Gate | Result |
| --- | --- |
| Chapter 9 length | pass, `2611` non-whitespace chars |
| all written chapters length | pass, no under-min or over-max chapters |
| Chapter 9 style | fail under `bridge_exposition_continuation` |
| remaining hard failure | `avg_para` |
| warnings / near-band concerns | `dialogue_ratio`, `interior_density` |

This is a useful convergence step: the previous C2D failure set (`avg_sentence`, `dialogue_ratio`, `interior_density`,
`avg_para`) has been narrowed to a paragraph-beat blocker. Chapters 10-11 remain locked until Chapter 9 passes style.

Evidence:

- `.runtime/rolling_30_cycle2e_ch9_style_repair_20260514.ndjson`
- `.runtime/rolling_30_cycle2e_ch9_style_repair_summary_20260514.json`
- `.runtime/rolling_30_cycle2e_ch9_style_repair_plan_after_20260514.json`
- `.runtime/rolling_30_cycle2e_ch9_style_repair_length_20260514.json`
- `.runtime/rolling_30_cycle2e_ch9_style_repair_style_20260514.json`
- `.runtime/rolling_30_cycle2e_ch9_style_repair_validation_20260514.json`
- `dev_repo/conversations/continuation_agent/7276384138653862966__rolling_30_c2e_ch9_style_repair_20260514.jsonl`

## Cycle 2F Chapter 9 Paragraph-Beat Repair

R30-C2F made the prior repair still narrower: only the Chapter 9 paragraph-beat blocker was targeted. The project
continuation Agent again wrote only `chapter_draft.md`; Codex did not edit prose.

Live repair result:

| Field | Value |
| --- | --- |
| local thread | `rolling_30_c2f_ch9_avg_para_repair_20260514` |
| Dify task id | `2f50b932-a183-4b8b-9f36-5b29cdaeda5a` |
| upstream conversation id | `f5518fff-ee8d-4d84-a9cb-8b428637f03c` |
| routed agent | `continuation_agent` |
| changed files | `chapter_draft.md` |
| book head | `a0adcfd` |

Independent gates after repair:

| Gate | Result |
| --- | --- |
| Chapter 9 length | pass, `2613` non-whitespace chars |
| all written chapters length | pass, no under-min or over-max chapters |
| Chapter 9 style | pass under `bridge_exposition_continuation` |
| hard failures | none |
| remaining warnings | `avg_para`, `interior_density` |

The Chapter 9 blocker is cleared. Planner still reports written chapters `1-9`, pending cards `10,11`, selected cards
`10,11`, and `next_action=continue_existing_cards`, so the next legal action is to continue Chapters 10-11 through the
project continuation Agent.

Evidence:

- `.runtime/rolling_30_cycle2f_ch9_avg_para_repair_20260514.ndjson`
- `.runtime/rolling_30_cycle2f_ch9_avg_para_repair_summary_20260514.json`
- `.runtime/rolling_30_cycle2f_ch9_avg_para_repair_plan_after_20260514.json`
- `.runtime/rolling_30_cycle2f_ch9_avg_para_repair_length_20260514.json`
- `.runtime/rolling_30_cycle2f_ch9_avg_para_repair_style_20260514.json`
- `.runtime/rolling_30_cycle2f_ch9_avg_para_repair_validation_20260514.json`
- `dev_repo/conversations/continuation_agent/7276384138653862966__rolling_30_c2f_ch9_avg_para_repair_20260514.jsonl`

## Cycle 2G Continuation To Chapter 10

R30-C2G asked the project continuation Agent to consume the remaining cards 10-11 after Chapter 9 passed. The Agent
again wrote through the real Dify route and changed only `chapter_draft.md`, but completed Chapter 10 only. Chapter 11
remains pending.

Live continuation result:

| Field | Value |
| --- | --- |
| local thread | `rolling_30_c2g_continuation_ch10_11_20260514` |
| Dify task id | `12507921-cb03-4d1b-9d92-9b7b323da4a3` |
| upstream conversation id | `362ab6ca-3151-411d-ad97-670e8c7033e9` |
| routed agent | `continuation_agent` |
| changed files | `chapter_draft.md` |
| book head | `5111500` |

Independent gates after the run:

| Gate | Result |
| --- | --- |
| Chapter 10 length | pass, `2239` non-whitespace chars |
| all written chapters length | pass, no under-min or over-max chapters |
| Chapter 10 style | fail under `bridge_exposition_continuation` |
| failing metrics | `avg_para`, `dialogue_ratio`, `environment_density`, `exposition_density` |

Planner now reports written chapters `1-10`, pending card `11`, selected card `11`, and
`next_action=continue_existing_cards`. The next legal action is to repair Chapter 10 through the project continuation
Agent before allowing Chapter 11.

Evidence:

- `.runtime/rolling_30_cycle2g_continuation_ch10_11_20260514.ndjson`
- `.runtime/rolling_30_cycle2g_continuation_ch10_11_summary_20260514.json`
- `.runtime/rolling_30_cycle2g_continuation_ch10_11_plan_after_20260514.json`
- `.runtime/rolling_30_cycle2g_continuation_ch10_length_20260514.json`
- `.runtime/rolling_30_cycle2g_continuation_ch10_style_20260514.json`
- `.runtime/rolling_30_cycle2g_continuation_ch10_11_validation_20260514.json`
- `dev_repo/conversations/continuation_agent/7276384138653862966__rolling_30_c2g_continuation_ch10_11_20260514.jsonl`

## Cycle 2H Chapter 10 Style Repair Attempt

R30-C2H sent the Chapter 10 blocker back through the project continuation Agent only. This was not a Codex rewrite:
the live route was `/api/world/deduce_stream`, the SSE `ack` reported `routed_agent=continuation_agent`,
`active_file=chapter_draft.md`, and `write_scope=active_file_strict`, and the book repo changed only
`chapter_draft.md`.

Live repair result:

| Field | Value |
| --- | --- |
| local thread | `rolling_30_c2h_ch10_style_repair_20260514` |
| Dify task id | `24002b5f-3a51-42ad-bfdd-829e9b369836` |
| upstream conversation id | `e814e433-faa3-46bd-800c-11285a55351a` |
| routed agent | `continuation_agent` |
| changed files | `chapter_draft.md` |
| book head | `2f087df` |

Book commits created by the project workflow:

- `827cbc4` - `[AI_Update] R30-C2H style repair: Chapter 10 - split paragraphs, reduced dialogue, trimmed exposition/environment`
- `51b686a` - `[AI_Update] R30-C2H length expansion: added concrete scene beats to Chapter 10`
- `cc7a259` - `[AI_Update] R30-C2H style repair round 1: reduce exposition/environment density, extend sentence breath`
- `dea777f` - `[AI_Update] R30-C2H style repair round 2: aggressive paragraph splits, reduce dialogue and exposition, strip atmosphere-only cues`
- `2f087df` - `[AI_Update] R30-C2H length recovery: added concrete action/body beats`

Independent gates after the repair:

| Gate | Result |
| --- | --- |
| Chapter 10 length | pass, `2254` non-whitespace chars |
| all written chapters length | pass, no under-min or over-max chapters |
| Chapter 10 style | fail under `bridge_exposition_continuation` |
| failing metrics | `avg_para`, `dialogue_ratio`, `environment_density`, `exposition_density` |

The repair moved some numbers in the right direction but did not clear the gate:

| Metric | Before C2H | After C2H | Result |
| --- | ---: | ---: | --- |
| average paragraph length | 65.9 | 56.4 | improved, still hard fail |
| dialogue ratio | 0.76 | 0.68 | improved, still hard fail |
| exposition density / 1000 chars | 5.4 | 4.0 | improved, still hard fail |
| environment density / 1000 chars | 21.0 | 23.1 | worsened, still hard fail |

Planner after repair still reports written chapters `1-10`, pending card `11`, selected card `11`, and
`next_action=continue_existing_cards`. Chapter 11 remains locked until Chapter 10 clears the quality gate or receives
a bound human unlock through the review bridge. The useful evidence is not that the prose is solved; it is that the
rolling loop refuses to hide a quality failure and preserves a narrow next action.

Evidence:

- `.runtime/rolling_30_cycle2h_ch10_style_repair_20260514.ndjson`
- `.runtime/rolling_30_cycle2h_ch10_style_repair_summary_20260514.json`
- `.runtime/rolling_30_cycle2h_ch10_style_repair_plan_after_20260514.json`
- `.runtime/rolling_30_cycle2h_ch10_style_repair_length_20260514.json`
- `.runtime/rolling_30_cycle2h_ch10_style_repair_style_20260514.json`
- `.runtime/rolling_30_cycle2h_ch10_style_repair_validation_20260514.json`
- `dev_repo/conversations/continuation_agent/7276384138653862966__rolling_30_c2h_ch10_style_repair_20260514.jsonl`

## Cycle 2I Bridge-Density Repair Protocol

R30-C2I patches the continuation Agent strategy layer, not the prose. The C2G/C2H evidence showed that Chapter 10 is
not failing from a single style dimension. It is a bridge/exposition chapter with four coupled failures:
`avg_para`, `dialogue_ratio`, `environment_density`, and `exposition_density`. The previous length-recovery protocol
still allowed spatial pressure and pressure-changing dialogue as generic "concrete scene beats", which is useful for
many chapters but too loose when the active failures are exactly environment and dialogue density.

The live and draft Dify continuation workflows now include `BRIDGE_DENSITY_REPAIR_PROTOCOL`. The new rule says that
when `bridge_exposition_continuation` fails on at least two of those four metrics, the Agent must treat the chapter as
`four_density_failure`: first reduce paragraph bulk, then Q&A-style speaker turns, then atmosphere-only environment
cues, then abstract rule explanation. Length recovery is limited to `scene_bound_micro_beats` and explicitly forbids
environment padding, Q&A padding, and rule-explanation padding.

Runtime patch evidence:

| Check | Result |
| --- | --- |
| dry-run before live patch | `changed=true`, `provider_changed=false`, `workflow_changed=true` |
| live patch | `changed=true`, `provider_changed=false`, `workflow_changed=true` |
| post-patch dry-run | `changed=false`, `provider_changed=false`, `workflow_changed=false` |
| provider endpoint ports | stayed `[8000]` |
| workflow topology | stayed `3` nodes and `2` edges |
| model | stayed `deepseek-v4-flash` |
| live/draft DB marker | both contain `BRIDGE_DENSITY_REPAIR_PROTOCOL`, `four_density_failure`, `no_environment_padding`, and `scene_bound_micro_beats` |

Evidence:

- `.runtime/r30_c2i_bridge_density_prompt_dry_run_20260514.json`
- `.runtime/r30_c2i_bridge_density_prompt_live_patch_20260514.json`
- `.runtime/r30_c2i_bridge_density_prompt_post_dry_run_20260514.json`
- `.runtime/r30_c2i_bridge_density_prompt_db_marker_20260514.txt`
- `.runtime/continuation_agent_provider_workflow_marker_20260514_234128.txt`
- `.runtime/continuation_agent_provider_workflow_marker_20260514_234140.txt`
- `scripts/patch_continuation_agent.py`
- `novel_git_server/tests/test_v68_continuation_style_gate_patch.py`
- `dev_repo/architecture/decisions/ADR-0008-continuation-production-layer.md`

The next valid evidence step is another project-workflow-only Chapter 10 repair attempt. Chapter 11 remains locked
until Chapter 10 passes length and style gates or receives a bound human unlock.
## Cycle 2J Chapter 10 Bridge-Density Repair Attempt

R30-C2J reran Chapter 10 through the real continuation Agent after the `BRIDGE_DENSITY_REPAIR_PROTOCOL` patch. This was still a project-workflow-only repair: Codex did not write, rewrite, paste, or edit prose. The SSE `ack` reported `routed_agent=continuation_agent`, `active_file=chapter_draft.md`, and `write_scope=active_file_strict`.

Live repair result:

| Field | Value |
| --- | --- |
| local thread | `rolling_30_c2j_ch10_bridge_density_repair_20260514` |
| Dify task id | `853c22b8-d4a3-4535-94ad-fa9ca7de4642` |
| upstream conversation id | `dfc8b913-8566-4f96-88ab-0f3fec948c0e` |
| routed agent | `continuation_agent` |
| changed files | `chapter_draft.md` |
| book head | `6e06c4b` |

Book commits created by the project workflow:

- `eafb504` - `[AI_Update] R30-C2J: Repair Chapter 10 - four_density_failure bridge_exposition_continuation`
- `951c529` - `[AI_Update] R30-C2J: Length recovery - add scene_bound_micro_beats to Chapter 10`
- `268c991` - `[AI_Update] R30-C2J: Second length recovery - add scene_bound_micro_beats (body reactions, silent decisions, object handling)`
- `76bbeb9` - `[AI_Update] R30-C2J: Third length recovery - add scene_bound_micro_beats`
- `5ea252f` - `[AI_Update] R30-C2J: Final length recovery - small micro-beats`
- `6e06c4b` - `[AI_Update] R30-C2J: Round 2 style repair - split long paragraphs, merge sentences, cut one atmosphere cue`

Independent gates after the repair:

| Gate | Result |
| --- | --- |
| Chapter 10 length | fail, `2173` non-whitespace chars, `27` under min |
| Chapter 10 style | fail under `bridge_exposition_continuation` |
| hard failures | `avg_para`, `environment_density` |
| warnings | `avg_sentence`, `dialogue_ratio`, `exposition_density`, `suspense_density` |

The repair is a useful but still blocked convergence step. Compared with C2H, hard style failures improved from `4` to `2`: `dialogue_ratio` and `exposition_density` dropped from hard failures to warnings. The cost was a length regression from `2254` to `2173`, so the chapter now fails both length and style gates. Planner after repair reports `next_action=await_quality_gate`, `blocked_next_action=continue_existing_cards`, written chapters `1-10`, and pending card `11`. Chapter 11 remains locked.

Evidence:

- `.runtime/rolling_30_cycle2j_ch10_bridge_density_repair_20260514.ndjson`
- `.runtime/rolling_30_cycle2j_ch10_bridge_density_repair_summary_20260514.json`
- `.runtime/rolling_30_cycle2j_ch10_bridge_density_repair_plan_after_20260514.json`
- `.runtime/rolling_30_cycle2j_ch10_bridge_density_repair_length_20260514.json`
- `.runtime/rolling_30_cycle2j_ch10_bridge_density_repair_style_20260514.json`
- `.runtime/rolling_30_cycle2j_ch10_bridge_density_repair_validation_20260514.json`
- `dev_repo/conversations/continuation_agent/7276384138653862966__rolling_30_c2j_ch10_bridge_density_repair_20260514.jsonl`

Next exact action: run a narrower project-workflow-only Chapter 10 repair that adds at least `27` non-whitespace chars while reducing `avg_para` and `environment_density`, and does not regress `dialogue_ratio` or `exposition_density`.

## Cycle 2K Chapter 10 Length + Style Repair Attempt

R30-C2K ran the next Chapter 10 repair through the real continuation Agent. Codex still did not write, rewrite, paste,
or edit prose. The SSE `ack` reported `routed_agent=continuation_agent`, `active_file=chapter_draft.md`, and
`write_scope=active_file_strict`; the book repo changed only `chapter_draft.md`.

Live repair result:

| Field | Value |
| --- | --- |
| local thread | `rolling_30_c2k_ch10_length_style_repair_20260514` |
| Dify task id | `f67c55cb-73dc-4940-a635-5b8fabe9efa7` |
| upstream conversation id | `c4a9d595-0759-4c09-a720-a89fce79f193` |
| routed agent | `continuation_agent` |
| changed files | `chapter_draft.md` |
| book head | `9d8f3da` |

Book commits created by the project workflow:

- `446504a` - `[AI_Update] R30-C2K: Repair Chapter 10 length+style gate - split long paragraphs, reduce Q&A/environment density, add micro-beats`
- `41b40a1` - `[AI_Update] R30-C2K: Add micro-beats for length recovery - body reactions and object handling only`
- `644709f` - `[AI_Update] R30-C2K style repair round 1: split long paragraphs, merge choppy sentences, delete atmosphere cues, convert exposition`
- `352a771` - `[AI_Update] R30-C2K: add 1 micro-beat to clear length gate`
- `9d8f3da` - `[AI_Update] R30-C2K style repair round 2: add paragraph breaks at decision beats, trim atmosphere, bind exposition to choice`

Independent gates after the repair:

| Gate | Result |
| --- | --- |
| Chapter 10 length | pass, `2218` non-whitespace chars |
| Chapter 10 style | fail under `bridge_exposition_continuation` |
| hard failures | `avg_para`, `environment_density` |
| warnings | `exposition_density`, `suspense_density` |

C2K recovered the length gate and improved `environment_density` from `23.9` to `22.1`, but it did not solve the
style blocker. The important regression is paragraph rhythm: `avg_para` moved from `57.2` to `65.2`, meaning the
repair added enough material for length but did not actually increase paragraph count enough. Planner after repair is
locked at `next_action=await_quality_gate`, `blocked_next_action=continue_existing_cards`, written chapters `1-10`,
and pending card `11`.

Evidence:

- `.runtime/rolling_30_cycle2k_ch10_length_style_repair_20260514.ndjson`
- `.runtime/rolling_30_cycle2k_ch10_length_style_repair_summary_20260514.json`
- `.runtime/rolling_30_cycle2k_ch10_length_style_repair_plan_after_20260514.json`
- `.runtime/rolling_30_cycle2k_ch10_length_style_repair_length_20260514.json`
- `.runtime/rolling_30_cycle2k_ch10_length_style_repair_style_20260514.json`
- `.runtime/rolling_30_cycle2k_ch10_length_style_repair_validation_20260514.json`
- `dev_repo/conversations/continuation_agent/7276384138653862966__rolling_30_c2k_ch10_length_style_repair_20260514.jsonl`

Next exact action: do not blind-repair again. Open a narrower paragraph/environment repair delta that makes
paragraph-count increase and environment-cue reduction measurable before the next project-workflow-only Chapter 10
repair.

## Cycle 2L Paragraph/Environment Repair Delta

R30-C2L patches the continuation Agent strategy layer, not the prose. C2K proved that another generic repair would be
too loose: the Agent recovered length and improved one density number, but `avg_para` worsened from `57.2` to `65.2`.
That means the instruction "split paragraphs" was not operational enough; it did not require a measurable paragraph
count increase and allowed later polishing to merge beats back into bulk paragraphs.

The live and draft Dify continuation workflows now include `PARAGRAPH_ENVIRONMENT_REPAIR_DELTA`. The new delta triggers
when the remaining hard failures are `avg_para` and `environment_density`, or when a prior repair recovered length while
making `avg_para` worse. It requires `paragraph_count_must_increase`, forbids `no_merge_back_into_bulk_paragraphs`,
adds an `environment_cue_budget`, and requires `environment_terms_must_decrease`. Length recovery under this delta must
use non-environmental micro-beats first, such as body reaction, object handling, silent decision, consequence
acknowledgement, or character positioning.

Runtime patch evidence:

| Check | Result |
| --- | --- |
| dry-run before live patch | `changed=true`, `provider_changed=false`, `workflow_changed=true` |
| live patch | `changed=true`, `provider_changed=false`, `workflow_changed=true` |
| post-patch dry-run | `changed=false`, `provider_changed=false`, `workflow_changed=false` |
| provider endpoint ports | stayed `[8000]` |
| workflow topology | stayed `3` nodes and `2` edges |
| model | stayed `deepseek-v4-flash` |
| live/draft DB marker | both contain `PARAGRAPH_ENVIRONMENT_REPAIR_DELTA`, `paragraph_count_must_increase`, `no_merge_back_into_bulk_paragraphs`, `environment_cue_budget`, and `environment_terms_must_decrease` |

Evidence:

- `.runtime/r30_c2l_paragraph_environment_prompt_dry_run_20260515.json`
- `.runtime/r30_c2l_paragraph_environment_prompt_live_patch_20260515.json`
- `.runtime/r30_c2l_paragraph_environment_prompt_post_dry_run_20260515.json`
- `.runtime/r30_c2l_paragraph_environment_prompt_db_marker_20260515.txt`
- `.runtime/continuation_agent_provider_workflow_marker_20260515_002451.txt`
- `.runtime/continuation_agent_provider_workflow_marker_20260515_002510.txt`
- `scripts/patch_continuation_agent.py`
- `novel_git_server/tests/test_v68_continuation_style_gate_patch.py`
- `dev_repo/architecture/decisions/ADR-0008-continuation-production-layer.md`

Next exact action: rerun Chapter 10 through the project continuation Agent under the paragraph/environment delta, then
rerun length/style gates before allowing Chapter 11.

## Style Metric Delta Architecture Amendment

R30-MDELTA-0 records the next repair-loop shape in architecture and ER truth. The repeated Chapter 10 blocker is no
longer treated as a one-off "make the prompt stricter" issue. The project now treats it as a generic evaluator-optimizer
gap: deterministic gates must produce a measurable style metric delta, and the continuation Agent must consume that
delta as a repair contract.

The new architecture record is `dev_repo/architecture/decisions/ADR-0009-style-metric-delta-repair-loop.md`.

The intended loop is:

1. deterministic gates measure length and style;
2. the rolling layer derives metric movement, protected metrics, proxy repair goals, and stop conditions;
3. the continuation Agent repairs only the current chapter through `chapter_draft.md`;
4. the gates run again and either unlock the next chapter or produce the next narrow delta.

This is still a no-prose boundary. Codex and the rolling orchestrator do not write novel prose, and `chapter_draft.md`
remains owned by the continuation route. Existing rolling evidence without `style_metric_delta` remains valid history,
but future repair loops should produce a fresh metric-delta artifact before claiming metric-driven repair.

## Cycle 2M Local Style Metric Delta

R30-MDELTA-1 implements the local evaluator side of the new loop. `build_style_repair_delta` now emits
`STYLE_METRIC_DELTA_PROTOCOL` in addition to the older before/after score summary. The protocol is generic: it maps
style metrics to proxy repair goals rather than checking a fixed chapter number.

The C2J -> C2K same-case delta now says:

| Field | Value |
| --- | --- |
| protected metric regressions | `avg_para`, `exposition_density` |
| paragraph proxy | `paragraph_count_must_increase`, `average_paragraph_chars_must_decrease`, `no_merge_split_beats` |
| paragraph movement | `38 -> 34`, delta `-4` |
| environment proxy | `environment_cue_clusters_must_decrease`, `delete_atmosphere_only_cues` |
| stop reasons | `protected_metric_regressed`, `length_or_size_recovery_regressed_protected_metric`, `style_gate_still_failed` |

Evidence:

- `.runtime/r30_mdelta1_c2j_c2k_style_metric_delta_20260515.json`
- `.runtime/r30_mdelta1_plan_with_delta_20260515.json`
- `novel_git_server/pipelines/rolling_chapter.py`
- `novel_git_server/tests/test_v69_rolling_chapter_planner.py`

This still does not write prose. The next valid step is to teach the live continuation Agent prompt to consume this
metric-delta contract, then rerun Chapter 10 through the project workflow only.

## Cycle 2M Continuation Prompt Upgrade

R30-MDELTA-2 patches the live and draft Dify continuation workflows so the continuation Agent can consume
`STYLE_METRIC_DELTA_PROTOCOL`. This is a prompt-strategy/runtime slice, not a prose slice: Codex did not call
continuation generation and did not edit `chapter_draft.md`.

The continuation prompt now treats `style_metric_delta` as the active current-chapter repair contract when it appears in
rolling evidence, review packets, or the author prompt. It must read `proxy_repair_goals`, obey
`protected_metrics` / `protected_metric_regressions`, and stop blind expansion when
`stop_conditions.block_blind_expansion` is true. The generic proxy markers include
`paragraph_count_must_increase`, `average_paragraph_chars_must_decrease`, `no_merge_split_beats`,
`environment_cue_clusters_must_decrease`, `delete_atmosphere_only_cues`, and
`length_or_size_recovery_regressed_protected_metric`.

Runtime patch evidence:

| Check | Result |
| --- | --- |
| dry-run before live patch | `changed=true`, `provider_changed=false`, `workflow_changed=true` |
| live patch | `changed=true`, `provider_changed=false`, `workflow_changed=true` |
| post-patch dry-run | `changed=false`, `provider_changed=false`, `workflow_changed=false` |
| provider endpoint ports | stayed `[8000]` |
| workflow topology | stayed `3` nodes and `2` edges |
| model | stayed `deepseek-v4-flash` |
| live/draft DB marker | both contain `STYLE_METRIC_DELTA_PROTOCOL`, `proxy_repair_goals`, `protected_metrics`, `protected_metric_regressions`, `block_blind_expansion`, `average_paragraph_chars_must_decrease`, `no_merge_split_beats`, `environment_cue_clusters_must_decrease`, `delete_atmosphere_only_cues`, and `length_or_size_recovery_regressed_protected_metric` |

Evidence:

- `.runtime/r30_mdelta2_style_metric_prompt_dry_run_20260515.json`
- `.runtime/r30_mdelta2_style_metric_prompt_live_patch_20260515.json`
- `.runtime/r30_mdelta2_style_metric_prompt_post_dry_run_20260515.json`
- `.runtime/r30_mdelta2_style_metric_prompt_db_marker_20260515.txt`
- `.runtime/continuation_agent_provider_workflow_marker_20260515_090219.txt`
- `.runtime/continuation_agent_provider_workflow_marker_20260515_090733.txt`
- `scripts/patch_continuation_agent.py`
- `novel_git_server/tests/test_v68_continuation_style_gate_patch.py`

Next exact action: rerun Chapter 10 through the project continuation Agent under the metric-delta protocol, then rerun
length/style gates before allowing Chapter 11.

## Cycle 2M Real Metric-Delta Repair

R30-MDELTA-3 is the first real repair run after the continuation Agent learned
`STYLE_METRIC_DELTA_PROTOCOL`. The important boundary held: Codex did not write prose. The live route was
`/api/world/deduce_stream` with `routed_agent=continuation_agent`, `active_file=chapter_draft.md`, and
`write_scope=active_file_strict`. The book repo advanced from `9d8f3da` to `fcd9a4f`, and
`git diff --name-only 9d8f3da..fcd9a4f` shows only `chapter_draft.md`.

Runtime evidence:

| Check | Result |
| --- | --- |
| Dify task | `c4679fe0-f76f-42dc-bc4b-f985f925a58f` |
| event counts | `ack=1`, `stage=7`, `reasoning=8812`, `draft_ready=1`, `done=1` |
| draft write | `draft_changed=true`, `write_confirmed=true` |
| changed files | `chapter_draft.md` only |
| book repo status | clean on `draft/sandbox` |

Independent gates after the repair:

| Gate | Result |
| --- | --- |
| Chapter 10 length | pass, `2206` non-whitespace chars |
| Chapter 10 style | fail under `bridge_exposition_continuation` |
| hard failures | `avg_para`, `environment_density` |
| warnings | `avg_sentence`, `exposition_density`, `suspense_density` |
| planner | `next_action=await_quality_gate`, `blocked_next_action=continue_existing_cards` |

The repair made small metric movement but did not clear the gate. From C2K to C2M, `avg_para` improved from `65.2` to
`63.0`, and `environment_density` improved from `22.1` to `21.8`; both remain hard failures. The paragraph proxy did
move in the right direction by one paragraph (`34 -> 35`), but not enough. The gate score worsened because
`avg_sentence` became a warning and `exposition_density` remained protected as a non-improving metric.

Evidence:

- `.runtime/rolling_30_cycle2m_ch10_style_metric_delta_repair_20260515.ndjson`
- `.runtime/rolling_30_cycle2m_ch10_style_metric_delta_repair_20260515_summary.json`
- `.runtime/rolling_30_cycle2m_ch10_style_metric_delta_repair_20260515_plan_after.json`
- `.runtime/rolling_30_cycle2m_ch10_style_metric_delta_repair_20260515_length.json`
- `.runtime/rolling_30_cycle2m_ch10_style_metric_delta_repair_20260515_style.json`
- `.runtime/rolling_30_cycle2m_ch10_style_metric_delta_repair_20260515_style_delta_from_c2k.json`
- `.runtime/rolling_30_cycle2m_ch10_style_metric_delta_repair_20260515_validation.json`

Legal stop: `blocker_class=style_gate_blocker`. Chapter 11 remains locked. Next exact action: open the next narrower
style/profile delta from the C2M evidence before another project-continuation-only Chapter 10 repair.

## Chapter Context Pack Architecture

R30-CCP-0 records the next repair-loop shape: before the continuation Agent rewrites a blocked chapter, the rolling
layer should distill a current-chapter execution brief from project truth sources. This adopts the useful community
pattern behind story bible / lorebook / scene brief workflows, but keeps it inside our no-prose boundary.

The new artifact is `CHAPTER_CONTEXT_PACK_PROTOCOL`. It may include the target chapter card, decision chain,
non-negotiable facts, forbidden promotions of unresolved `WORLD_MODEL_REQUIRED`, source references, and active
style/length gate feedback. It must not include generated prose, hidden canon, hidden outline state, or human approval.

Architecture record:

- `dev_repo/architecture/decisions/ADR-0010-chapter-context-pack.md`
- `dev_repo/architecture/ARCHITECTURE.md`
- `dev_repo/architecture/invariants.md`
- `dev_repo/architecture/data-model/ER.md`
- `dev_repo/architecture/data-model/entities.json`
- `dev_repo/architecture/data-model/relationships.json`

The intended flow is now:

1. rolling planner derives target chapter and gate state;
2. rolling planner builds a context pack from existing truth sources;
3. continuation Agent consumes the pack and writes only `chapter_draft.md`;
4. length/style gates rerun before Chapter 11 or any later chapter can proceed.

Next exact action: implement the local generic context-pack builder and produce a CH10 same-case pack from the current
blocked evidence.

## Chapter Context Pack Builder

R30-CCP-1 implements the local, generic builder for `CHAPTER_CONTEXT_PACK_PROTOCOL`.

The builder is deliberately not a writer. It reads the rolling planner state, executable chapter card, truth-source file
references, quality-gate summary, and style metric-delta evidence, then emits a derived JSON brief for the continuation
route. It does not read `chapter_draft.md` text and does not generate replacement prose.

Same-case CH10 artifact:

- `.runtime/r30_ccp1_ch10_context_pack_20260515.json`
- `.runtime/r30_ccp1_ch10_style_metric_delta_20260515.json`
- `.runtime/r30_ccp1_plan_with_context_pack_20260515.json`

The CH10 pack targets the blocked chapter rather than the pending CH11 card:

| Field | Value |
| --- | --- |
| protocol | `CHAPTER_CONTEXT_PACK_PROTOCOL` |
| chapter_number | `10` |
| next_action | `await_quality_gate` |
| blocked_next_action | `continue_existing_cards` |
| chapter_card.number | `10` |
| repair protocol | `STYLE_METRIC_DELTA_PROTOCOL` |

The pack carries current repair pressure for `avg_sentence`, `avg_para`, `environment_density`, `exposition_density`,
and `suspense_density`, plus source references to `chapter_outline.md`, `world_model.md`, `status_card.md`,
`domain_rules.md`, `summary.md`, `style_constraints_for_continuation.md`, `error_archive.md`, quality gate source, and
gate artifacts.

No-prose boundary result:

- `no_prose_boundary.pack_reads_chapter_draft_text=false`
- `no_prose_boundary.pack_contains_generated_prose=false`
- `continuation_agent_remains_only_chapter_draft_writer=true`
- `chapter_draft.md` appears only as the continuation route target, not as a source text copied into the pack.

Verification passed: `py_compile`, `test_v69_rolling_chapter_planner` with 16 tests, same-case CH10 JSON generation and
parse, and book repo clean on `draft/sandbox`.

## Chapter Context Pack Prompt Consumption

R30-CCP-2 patches the continuation Agent prompt so the local context pack can be consumed by the real Dify route.

The live and draft workflows now include `CHAPTER_CONTEXT_PACK_PROTOCOL`. The prompt treats `chapter_context_pack` as a
current-chapter execution brief before chapter selection or repair. It explicitly says the pack is derived evidence, not
generated prose, hidden canon, hidden outline, or human approval.

Key runtime behavior added:

- align `chapter_context_pack.chapter_number`, `targeting.blocked_next_action`, and `chapter_card.number`;
- if the pack points to a blocked current chapter, repair that chapter before writing the pending next card;
- use `decision_chain` for who wants what, obstacle, required state change, payoff, and ending hook;
- use `non_negotiable_facts` and `truth_source_refs` without promoting unresolved `WORLD_MODEL_REQUIRED` to
  `SOURCE_FACT`;
- consume `active_repair_goals.style_metric_delta` as the current repair contract;
- respect `pack_reads_chapter_draft_text=false`, `pack_contains_generated_prose=false`, and
  `continuation_agent_remains_only_chapter_draft_writer=true`.

Patch evidence:

| Check | Result |
| --- | --- |
| dry-run before patch | `changed=true`, `provider_changed=false`, `workflow_changed=true` |
| live patch | `changed=true`, `provider_changed=false`, `workflow_changed=true` |
| post-patch dry-run | `changed=false`, `provider_changed=false`, `workflow_changed=false` |
| endpoint ports | `[8000]` |
| workflow tool set | unchanged |
| maximum_iterations | `45` |

DB marker query proves live and draft workflows contain `CHAPTER_CONTEXT_PACK_PROTOCOL`, `chapter_context_pack`,
`decision_chain`, `non_negotiable_facts`, `truth_source_refs`, `pack_reads_chapter_draft_text`, and
`continuation_agent_remains_only_chapter_draft_writer`.

No book repo files changed in this slice. Next exact action: run the real Chapter 10 continuation repair with the CH10
context pack, then rerun length/style gates before Chapter 11 can proceed.

## Chapter Context Pack Real Repair

R30-CCP-3 ran the real Chapter 10 repair through the project continuation Agent with the CH10
`CHAPTER_CONTEXT_PACK_PROTOCOL` artifact.

The route behaved correctly:

| Check | Result |
| --- | --- |
| routed agent | `continuation_agent` |
| active file | `chapter_draft.md` |
| write scope | `active_file_strict` |
| Dify task | `affb6050-2792-4416-97e2-4c944d443555` |
| event counts | `ack=1`, `stage=7`, `reasoning=8712`, `draft_ready=1`, `done=1` |
| write confirmation | `draft_changed=true`, `write_confirmed=true` |
| changed files | `chapter_draft.md` only |
| book repo head | `fcd9a4f -> 5381aec` |

Independent gates after the repair:

| Gate | Result |
| --- | --- |
| Chapter 10 length | pass, `2228` non-whitespace chars |
| Chapter 10 style | fail under `bridge_exposition_continuation` |
| hard failures | `avg_para`, `environment_density`, `exposition_density` |
| warnings | `dialogue_ratio`, `suspense_density` |
| planner | `next_action=await_quality_gate`, `blocked_next_action=continue_existing_cards` |

The context pack did improve one axis: `environment_density` moved from `21.8` to `19.3`. But it also proved a sharper
failure mode. Paragraph rhythm regressed from `63.0` to `63.7`, and `exposition_density` moved from warning to hard
failure at `4.0`. The style delta verdict is therefore `regressed`, with protected metric regressions on `avg_para`,
`exposition_density`, and `suspense_density`.

This is a useful negative proof for the rolling demo: context packing can route the right chapter and preserve write
ownership, but it does not by itself constrain the continuation Agent from trading plot-context fidelity for explanatory
bulk. Chapter 11 remains locked.

Evidence:

- `.runtime/rolling_30_ccp3_ch10_context_pack_repair_20260515.ndjson`
- `.runtime/rolling_30_ccp3_ch10_context_pack_repair_20260515_summary.json`
- `.runtime/rolling_30_ccp3_ch10_context_pack_repair_20260515_validation.json`
- `.runtime/rolling_30_ccp3_ch10_context_pack_repair_20260515_plan_after.json`
- `.runtime/rolling_30_ccp3_ch10_context_pack_repair_20260515_length.json`
- `.runtime/rolling_30_ccp3_ch10_context_pack_repair_20260515_style.json`
- `.runtime/rolling_30_ccp3_ch10_context_pack_repair_20260515_style_delta_from_c2m.json`
- `.runtime/rolling_30_ccp3_ch10_context_pack_after_20260515.json`

Legal stop: `blocker_class=style_gate_regression_blocker`. Next exact action: open a narrower evidence-first delta for
continuation repair that forbids trading context-pack fidelity for exposition, then rerun Chapter 10 through
`continuation_agent` only and recheck length/style gates before Chapter 11.

## Chapter 6 Write Loop Guard

R30-CH6-DELTA-2 closes the failure mode exposed by a loop-structured regression book
`regression_loop_book_20260515_153036`: the continuation Agent kept making tiny repair commits to Chapter 6 while length
and style gates remained unresolved.

The fix is deliberately at the tool boundary. `chapter_draft.md` writes now have an AI write-loop budget: when recent
Git history already contains six repair-like `[AI_Update]` commits in the current repair window, the next markdown
section write fails with `AI_WRITE_LOOP_GUARD` before any file is changed. The continuation prompt also treats that
tool error as a hard stop rather than an invitation to retry with smaller padding.

Current same-case evidence:

| Check | Result |
| --- | --- |
| recent repair-like CH6 draft commits | `18` |
| guard threshold | `6` |
| next write projection | `would_block_next_write=true` |
| Chapter 6 length | fail, `2058` non-whitespace chars, `142` under min |
| Chapter 6 style | fail, hard failures `action_density`, `environment_density` |
| planner | `next_action=await_quality_gate`, `blocked_next_action=continue_existing_cards` |

The guard does not write or repair prose. It prevents the next blind repair loop and preserves the honest state:
Chapter 7/8 stay locked until Chapter 6 is either structurally repaired through the continuation Agent under a bounded
plan, routed through review evidence, or explicitly handled by a valid human decision.

Evidence:

- `.runtime/r30_ch6_delta2_guard_projection_20260515.json`
- `.runtime/r30_ch6_delta2_length_after_guard_20260515.json`
- `.runtime/r30_ch6_delta2_style_after_guard_20260515.json`
- `.runtime/r30_ch6_delta2_plan_blocked_20260515.json`
- `.runtime/r30_ch6_delta2_style_delta_20260515.json`
- `.runtime/r30_ch6_delta2_review_packet_20260515.json`
- `.runtime/r30_ch6_delta2_context_pack_20260515.json`
- `.runtime/r30_ch6_delta2_write_loop_guard_prompt_db_marker_20260515.txt`

Verification passed: backend write-loop guard test, continuation prompt test, `py_compile`, Dify dry-run/live/post-dry-run
with `provider_changed=false`, endpoint ports `[8000]`, unchanged model/tool set/topology, architecture JSON parse, and
book repo clean on `draft/sandbox`.

## Chapter 6 Review Bridge

R30-CH6-BRIDGE-1 routes the same blocked Chapter 6 case through the existing review bridge instead of attempting another
continuation repair. The review packet remains no-prose evidence, while `review_agent` is allowed to write only durable
findings to `error_archive.md`.

Live review result:

| Field | Value |
| --- | --- |
| book | `regression_loop_book_20260515_153036` |
| local thread | `r30_ch6_bridge1_20260515` |
| Dify task id | `a1b1640c-918d-4ee6-af73-9c00ffe9290b` |
| routed agent | `review_agent` |
| review target file | `error_archive.md` |
| changed files | `error_archive.md` only |
| book commit | `d7d4832` |
| scheduler after review | `await_quality_gate`, `blocked_next_action=continue_existing_cards` |

The review finding does not unlock the scheduler. It records that Chapter 6 still has excessive action/environment
density and needs breathing beats before another bounded continuation repair. After the review run, `quality_gate_unlocked`
remains `false`, `human_unlock_status=missing`, and pending Chapter 7/8 cards remain locked.

Evidence:

- `.runtime/r30_ch6_bridge1_review_agent_20260515.ndjson`
- `.runtime/r30_ch6_bridge1_call_20260515.json`
- `.runtime/r30_ch6_bridge1_plan_after_20260515.json`
- `.runtime/r30_ch6_bridge1_validation_20260515.json`
- book repo diff `HEAD~1..HEAD` shows only `error_archive.md`

## Style Advisory Gate

STYLE-ADVISORY-1 changes the rolling loop's failure semantics after the Chapter 6 review bridge exposed an over-tight
style gate. Deterministic style diagnostics still run and still record the same metrics, but style failures are now
author-facing and continuation-facing advisory evidence rather than a scheduler lock.

Same-case Chapter 6 evidence on `regression_loop_book_20260515_153036`:

| Check | Result |
| --- | --- |
| source style artifact | `.runtime/r30_ch6_delta2_style_after_guard_20260515.json` |
| style status | fail, hard metrics `action_density`, `environment_density` |
| gate role | `style_advisory` |
| locks scheduler | `false` |
| planner next action | `continue_existing_cards` |
| selected cards | `[7, 8]` |
| style advisory active | `true` |

This does not mean the prose is declared perfect. It means the rolling demo no longer treats local prose-taste metrics
as a hard stop. Plot continuity, world/status consistency, chapter-card fulfillment, length validation, Git safety, and
human review remain hard boundaries. The review Agent's hard scope is now story risk; style advice is preserved for the
author and for the continuation prompt.

Evidence:

- `.runtime/r30_style_advisory_ch6_plan_20260515.json`
- `.runtime/r30_style_advisory_ch6_review_packet_20260515.json`
- `.runtime/r30_style_advisory_ch6_context_pack_20260515.json`
- `novel_git_server/tests/test_v69_rolling_chapter_planner.py`
- `dev_repo/architecture/decisions/ADR-0014-style-advisory-rolling-gate.md`

## Continuation Style Advisory Prompt

STYLE-PROMPT-2 applies the same boundary to the live and draft continuation Agent prompts. The Agent still reads
`style_constraints_for_continuation.md`, `style_guide.md`, and recent source text, but it now treats them as imitation
references: useful for scene opening, information release, dialogue rhythm, paragraph breathing, and prose taste, not as
a scheduler pass/fail contract.

Prompt semantics after the patch:

| Check | Result |
| --- | --- |
| `generate_style_diagnostics` | still required after length validation |
| style result name | `style_advisory` |
| author revision owner | `human_author` |
| locks scheduler | `false` |
| next chapter requires style pass | `false` |
| length gate | still hard |
| plot/world/status/card gates | still hard |
| optional style rewrite | only when the author explicitly asks, and only through continuation Agent writing `chapter_draft.md` |

Dify patch evidence:

| Step | Result |
| --- | --- |
| dry-run before patch | `changed=true`, `provider_changed=false`, `workflow_changed=true` |
| live patch | `changed=true`, `provider_changed=false`, `workflow_changed=true` |
| post dry-run | `changed=false`, `provider_changed=false`, `workflow_changed=false` |
| endpoint ports | `[8000]` |
| model/tool/topology | unchanged |
| live/draft DB markers | advisory/reference markers present; legacy `STYLE_GATE_PROTOCOL` and `REPAIR_PLAN_PROTOCOL` absent |

Evidence:

- `.runtime/r30_style_prompt2_dry_run_20260515.json`
- `.runtime/r30_style_prompt2_live_patch_20260515.json`
- `.runtime/r30_style_prompt2_post_dry_run_20260515.json`
- `.runtime/r30_style_prompt2_db_marker_20260515.txt`
- `scripts/patch_continuation_agent.py`
- `novel_git_server/tests/test_v68_continuation_style_gate_patch.py`
- `dev_repo/architecture/ARCHITECTURE.md`
- `dev_repo/architecture/invariants.md`