Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=minimal_diff_conflict_preserve
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
New evidence contradicts an active claim and the validator requires the conflict edge to remain explicit.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
evidence_conflict=explicit
conflict_edge=preserve
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=retrieved_receipt_conflict
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=local_conflict_preserving_revision
forbidden_rewrite_scope=silent_conflict_erasure
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=local_contradiction_preserve
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A retrieved source directly negates the current claim, but unrelated validated work must stay untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
claim_status=locally_demote
conflict_visibility=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=conflicting_ground_truth_edges
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=preserve_conflict_then_revise_locally
forbidden_rewrite_scope=broad_regeneration
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=receipt_conflict_local_revision
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Two trusted receipts disagree on the active conclusion and the runtime must revise locally without erasing the contradiction trace.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
evidence_conflict=explicit
conflict_edge=preserve
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=retrieved_receipt_conflict
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=local_conflict_preserving_revision
forbidden_rewrite_scope=silent_conflict_erasure
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=minimal_diff_conflict_preserve
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
New evidence contradicts an active claim and the validator requires the conflict edge to remain explicit.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
claim_status=locally_demote
conflict_visibility=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=conflicting_ground_truth_edges
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=preserve_conflict_then_revise_locally
forbidden_rewrite_scope=broad_regeneration
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=local_contradiction_preserve
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A retrieved source directly negates the current claim, but unrelated validated work must stay untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
evidence_conflict=explicit
conflict_edge=preserve
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=retrieved_receipt_conflict
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=local_conflict_preserving_revision
forbidden_rewrite_scope=silent_conflict_erasure
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=receipt_conflict_local_revision
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Two trusted receipts disagree on the active conclusion and the runtime must revise locally without erasing the contradiction trace.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
claim_status=locally_demote
conflict_visibility=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=conflicting_ground_truth_edges
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=preserve_conflict_then_revise_locally
forbidden_rewrite_scope=broad_regeneration
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=minimal_diff_conflict_preserve
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
New evidence contradicts an active claim and the validator requires the conflict edge to remain explicit.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
evidence_conflict=explicit
conflict_edge=preserve
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=retrieved_receipt_conflict
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=local_conflict_preserving_revision
forbidden_rewrite_scope=silent_conflict_erasure
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=local_contradiction_preserve
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A retrieved source directly negates the current claim, but unrelated validated work must stay untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
claim_status=locally_demote
conflict_visibility=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=conflicting_ground_truth_edges
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=preserve_conflict_then_revise_locally
forbidden_rewrite_scope=broad_regeneration
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=receipt_conflict_local_revision
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Two trusted receipts disagree on the active conclusion and the runtime must revise locally without erasing the contradiction trace.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
evidence_conflict=explicit
conflict_edge=preserve
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=retrieved_receipt_conflict
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=local_conflict_preserving_revision
forbidden_rewrite_scope=silent_conflict_erasure
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=minimal_diff_conflict_preserve
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
New evidence contradicts an active claim and the validator requires the conflict edge to remain explicit.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
claim_status=locally_demote
conflict_visibility=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=conflicting_ground_truth_edges
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=preserve_conflict_then_revise_locally
forbidden_rewrite_scope=broad_regeneration
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=local_contradiction_preserve
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A retrieved source directly negates the current claim, but unrelated validated work must stay untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
evidence_conflict=explicit
conflict_edge=preserve
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=retrieved_receipt_conflict
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=local_conflict_preserving_revision
forbidden_rewrite_scope=silent_conflict_erasure
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=receipt_conflict_local_revision
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Two trusted receipts disagree on the active conclusion and the runtime must revise locally without erasing the contradiction trace.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
claim_status=locally_demote
conflict_visibility=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=conflicting_ground_truth_edges
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=preserve_conflict_then_revise_locally
forbidden_rewrite_scope=broad_regeneration
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=minimal_diff_conflict_preserve
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
New evidence contradicts an active claim and the validator requires the conflict edge to remain explicit.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
evidence_conflict=explicit
conflict_edge=preserve
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=retrieved_receipt_conflict
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=local_conflict_preserving_revision
forbidden_rewrite_scope=silent_conflict_erasure
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=contradiction
rollback_focus=local_contradiction_preserve
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A retrieved source directly negates the current claim, but unrelated validated work must stay untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
claim_status=locally_demote
conflict_visibility=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=conflicting_ground_truth_edges
dominant_cause_signal=evidence_contradiction
required_rewrite_scope=preserve_conflict_then_revise_locally
forbidden_rewrite_scope=broad_regeneration
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=execution_negation_local_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Sandbox execution falsified an assumption in the active plan, but unrelated validated work should remain intact.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
execution_trace=failed
repair_scope=failed_branch_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=sandbox_execution_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=local_patch_only
forbidden_rewrite_scope=full_repo_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=execution_failure_local_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A bounded test failed after code execution, and only the invalidated branch should be revised.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
sandbox_status=nonzero
repair_path=local_patch
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=bounded_test_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=failed_branch_local_repair
forbidden_rewrite_scope=rewrite_validated_regions
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=sandbox_failure_minimal_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The generated patch crashes under the verification harness; keep the healthy regions and repair only the failed path.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
execution_trace=failed
repair_scope=failed_branch_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=sandbox_execution_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=local_patch_only
forbidden_rewrite_scope=full_repo_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=execution_negation_local_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Sandbox execution falsified an assumption in the active plan, but unrelated validated work should remain intact.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
sandbox_status=nonzero
repair_path=local_patch
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=bounded_test_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=failed_branch_local_repair
forbidden_rewrite_scope=rewrite_validated_regions
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=execution_failure_local_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A bounded test failed after code execution, and only the invalidated branch should be revised.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
execution_trace=failed
repair_scope=failed_branch_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=sandbox_execution_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=local_patch_only
forbidden_rewrite_scope=full_repo_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=sandbox_failure_minimal_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The generated patch crashes under the verification harness; keep the healthy regions and repair only the failed path.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
sandbox_status=nonzero
repair_path=local_patch
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=bounded_test_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=failed_branch_local_repair
forbidden_rewrite_scope=rewrite_validated_regions
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=execution_negation_local_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Sandbox execution falsified an assumption in the active plan, but unrelated validated work should remain intact.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
execution_trace=failed
repair_scope=failed_branch_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=sandbox_execution_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=local_patch_only
forbidden_rewrite_scope=full_repo_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=execution_failure_local_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A bounded test failed after code execution, and only the invalidated branch should be revised.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
sandbox_status=nonzero
repair_path=local_patch
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=bounded_test_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=failed_branch_local_repair
forbidden_rewrite_scope=rewrite_validated_regions
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=sandbox_failure_minimal_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The generated patch crashes under the verification harness; keep the healthy regions and repair only the failed path.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
execution_trace=failed
repair_scope=failed_branch_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=sandbox_execution_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=local_patch_only
forbidden_rewrite_scope=full_repo_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=execution_negation_local_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Sandbox execution falsified an assumption in the active plan, but unrelated validated work should remain intact.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
sandbox_status=nonzero
repair_path=local_patch
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=bounded_test_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=failed_branch_local_repair
forbidden_rewrite_scope=rewrite_validated_regions
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=execution_failure_local_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A bounded test failed after code execution, and only the invalidated branch should be revised.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
execution_trace=failed
repair_scope=failed_branch_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=sandbox_execution_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=local_patch_only
forbidden_rewrite_scope=full_repo_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=sandbox_failure_minimal_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The generated patch crashes under the verification harness; keep the healthy regions and repair only the failed path.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
sandbox_status=nonzero
repair_path=local_patch
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=bounded_test_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=failed_branch_local_repair
forbidden_rewrite_scope=rewrite_validated_regions
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=execution_negation_local_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Sandbox execution falsified an assumption in the active plan, but unrelated validated work should remain intact.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
execution_trace=failed
repair_scope=failed_branch_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=sandbox_execution_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=local_patch_only
forbidden_rewrite_scope=full_repo_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=execution_failure
rollback_focus=execution_failure_local_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A bounded test failed after code execution, and only the invalidated branch should be revised.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
sandbox_status=nonzero
repair_path=local_patch
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=bounded_test_failure
dominant_cause_signal=execution_negation
required_rewrite_scope=failed_branch_local_repair
forbidden_rewrite_scope=rewrite_validated_regions
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_led_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Validator rejected the latest outcome due to unmet acceptance criteria and missing receipt alignment.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
validator_gate=reject
receipt_alignment=broken
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_receipt_rejection
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_scoped_revision
forbidden_rewrite_scope=receipt_agnostic_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_revision_scoped
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A receipt-aware validator blocked submission and requires local revision instead of broad rewriting.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
acceptance_criteria=failed
validator_scope=authoritative
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=acceptance_gate_reject
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_bound_local_revision
forbidden_rewrite_scope=bypass_validator_scope
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_scope_rewrite
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The revision violates validator constraints although it still looks plausible; rollback must follow validator scope.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
validator_gate=reject
receipt_alignment=broken
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_receipt_rejection
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_scoped_revision
forbidden_rewrite_scope=receipt_agnostic_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_led_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Validator rejected the latest outcome due to unmet acceptance criteria and missing receipt alignment.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
acceptance_criteria=failed
validator_scope=authoritative
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=acceptance_gate_reject
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_bound_local_revision
forbidden_rewrite_scope=bypass_validator_scope
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_revision_scoped
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A receipt-aware validator blocked submission and requires local revision instead of broad rewriting.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
validator_gate=reject
receipt_alignment=broken
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_receipt_rejection
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_scoped_revision
forbidden_rewrite_scope=receipt_agnostic_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_scope_rewrite
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The revision violates validator constraints although it still looks plausible; rollback must follow validator scope.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
acceptance_criteria=failed
validator_scope=authoritative
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=acceptance_gate_reject
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_bound_local_revision
forbidden_rewrite_scope=bypass_validator_scope
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_led_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Validator rejected the latest outcome due to unmet acceptance criteria and missing receipt alignment.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
validator_gate=reject
receipt_alignment=broken
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_receipt_rejection
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_scoped_revision
forbidden_rewrite_scope=receipt_agnostic_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_revision_scoped
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A receipt-aware validator blocked submission and requires local revision instead of broad rewriting.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
acceptance_criteria=failed
validator_scope=authoritative
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=acceptance_gate_reject
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_bound_local_revision
forbidden_rewrite_scope=bypass_validator_scope
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_scope_rewrite
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The revision violates validator constraints although it still looks plausible; rollback must follow validator scope.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
validator_gate=reject
receipt_alignment=broken
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_receipt_rejection
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_scoped_revision
forbidden_rewrite_scope=receipt_agnostic_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_led_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Validator rejected the latest outcome due to unmet acceptance criteria and missing receipt alignment.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
acceptance_criteria=failed
validator_scope=authoritative
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=acceptance_gate_reject
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_bound_local_revision
forbidden_rewrite_scope=bypass_validator_scope
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_revision_scoped
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A receipt-aware validator blocked submission and requires local revision instead of broad rewriting.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
validator_gate=reject
receipt_alignment=broken
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_receipt_rejection
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_scoped_revision
forbidden_rewrite_scope=receipt_agnostic_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_scope_rewrite
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The revision violates validator constraints although it still looks plausible; rollback must follow validator scope.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
acceptance_criteria=failed
validator_scope=authoritative
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=acceptance_gate_reject
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_bound_local_revision
forbidden_rewrite_scope=bypass_validator_scope
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_led_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Validator rejected the latest outcome due to unmet acceptance criteria and missing receipt alignment.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
validator_gate=reject
receipt_alignment=broken
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_receipt_rejection
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_scoped_revision
forbidden_rewrite_scope=receipt_agnostic_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=validator_rejection
rollback_focus=validator_revision_scoped
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A receipt-aware validator blocked submission and requires local revision instead of broad rewriting.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
acceptance_criteria=failed
validator_scope=authoritative
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=acceptance_gate_reject
dominant_cause_signal=validator_rejection
required_rewrite_scope=validator_bound_local_revision
forbidden_rewrite_scope=bypass_validator_scope
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=patch_regression_minimality
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A new patch introduced a local regression; repair should touch the smallest possible region and preserve previous accepted segments.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
regression_scope=localized
minimal_diff=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=patch_regression_observed
dominant_cause_signal=patch_regression
required_rewrite_scope=minimum_diff_patch
forbidden_rewrite_scope=wide_area_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=patch_regression_smallest_diff
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The latest diff broke one validated path and should be corrected with the smallest rollback-compatible patch.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
patch_lineage=mostly_valid
rollback_scope=single_region
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=recent_diff_regressed
dominant_cause_signal=patch_regression
required_rewrite_scope=single_region_patch_repair
forbidden_rewrite_scope=discard_valid_neighbors
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=single_region_regression
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
One recently edited function regressed while neighboring validated logic should remain untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
regression_scope=localized
minimal_diff=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=patch_regression_observed
dominant_cause_signal=patch_regression
required_rewrite_scope=minimum_diff_patch
forbidden_rewrite_scope=wide_area_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=patch_regression_minimality
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A new patch introduced a local regression; repair should touch the smallest possible region and preserve previous accepted segments.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
patch_lineage=mostly_valid
rollback_scope=single_region
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=recent_diff_regressed
dominant_cause_signal=patch_regression
required_rewrite_scope=single_region_patch_repair
forbidden_rewrite_scope=discard_valid_neighbors
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=patch_regression_smallest_diff
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The latest diff broke one validated path and should be corrected with the smallest rollback-compatible patch.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
regression_scope=localized
minimal_diff=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=patch_regression_observed
dominant_cause_signal=patch_regression
required_rewrite_scope=minimum_diff_patch
forbidden_rewrite_scope=wide_area_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=single_region_regression
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
One recently edited function regressed while neighboring validated logic should remain untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
patch_lineage=mostly_valid
rollback_scope=single_region
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=recent_diff_regressed
dominant_cause_signal=patch_regression
required_rewrite_scope=single_region_patch_repair
forbidden_rewrite_scope=discard_valid_neighbors
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=patch_regression_minimality
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A new patch introduced a local regression; repair should touch the smallest possible region and preserve previous accepted segments.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
regression_scope=localized
minimal_diff=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=patch_regression_observed
dominant_cause_signal=patch_regression
required_rewrite_scope=minimum_diff_patch
forbidden_rewrite_scope=wide_area_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=patch_regression_smallest_diff
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The latest diff broke one validated path and should be corrected with the smallest rollback-compatible patch.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
patch_lineage=mostly_valid
rollback_scope=single_region
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=recent_diff_regressed
dominant_cause_signal=patch_regression
required_rewrite_scope=single_region_patch_repair
forbidden_rewrite_scope=discard_valid_neighbors
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=single_region_regression
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
One recently edited function regressed while neighboring validated logic should remain untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
regression_scope=localized
minimal_diff=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=patch_regression_observed
dominant_cause_signal=patch_regression
required_rewrite_scope=minimum_diff_patch
forbidden_rewrite_scope=wide_area_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=patch_regression_minimality
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A new patch introduced a local regression; repair should touch the smallest possible region and preserve previous accepted segments.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
patch_lineage=mostly_valid
rollback_scope=single_region
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=recent_diff_regressed
dominant_cause_signal=patch_regression
required_rewrite_scope=single_region_patch_repair
forbidden_rewrite_scope=discard_valid_neighbors
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=patch_regression_smallest_diff
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The latest diff broke one validated path and should be corrected with the smallest rollback-compatible patch.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
regression_scope=localized
minimal_diff=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=patch_regression_observed
dominant_cause_signal=patch_regression
required_rewrite_scope=minimum_diff_patch
forbidden_rewrite_scope=wide_area_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=single_region_regression
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
One recently edited function regressed while neighboring validated logic should remain untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
patch_lineage=mostly_valid
rollback_scope=single_region
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=recent_diff_regressed
dominant_cause_signal=patch_regression
required_rewrite_scope=single_region_patch_repair
forbidden_rewrite_scope=discard_valid_neighbors
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=patch_regression_minimality
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A new patch introduced a local regression; repair should touch the smallest possible region and preserve previous accepted segments.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
regression_scope=localized
minimal_diff=required
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=patch_regression_observed
dominant_cause_signal=patch_regression
required_rewrite_scope=minimum_diff_patch
forbidden_rewrite_scope=wide_area_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=patch_regression
rollback_focus=patch_regression_smallest_diff
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The latest diff broke one validated path and should be corrected with the smallest rollback-compatible patch.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
patch_lineage=mostly_valid
rollback_scope=single_region
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=recent_diff_regressed
dominant_cause_signal=patch_regression
required_rewrite_scope=single_region_patch_repair
forbidden_rewrite_scope=discard_valid_neighbors
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=worktree_conflict_alignment
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Workspace state diverged and the worktree is now in conflict with the expected patch lineage.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
worktree_state=conflicted
overwrite_policy=forbidden
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=live_worktree_conflict
dominant_cause_signal=worktree_conflict
required_rewrite_scope=do_not_overwrite_worktree_state
forbidden_rewrite_scope=overwrite_workspace_state
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=workspace_snapshot_conflict
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The patch lineage no longer matches the live workspace snapshot, so overwrite should be avoided.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
workspace_snapshot=lineage_mismatch
rollback_scope=preserve_worktree
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=snapshot_lineage_mismatch
dominant_cause_signal=worktree_conflict
required_rewrite_scope=preserve_worktree_then_reconcile
forbidden_rewrite_scope=destructive_checkout_style_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=preserve_worktree_state
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The current rollback candidate would trample an unmerged worktree delta and must preserve the live workspace context.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
worktree_state=conflicted
overwrite_policy=forbidden
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=live_worktree_conflict
dominant_cause_signal=worktree_conflict
required_rewrite_scope=do_not_overwrite_worktree_state
forbidden_rewrite_scope=overwrite_workspace_state
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=worktree_conflict_alignment
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Workspace state diverged and the worktree is now in conflict with the expected patch lineage.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
workspace_snapshot=lineage_mismatch
rollback_scope=preserve_worktree
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=snapshot_lineage_mismatch
dominant_cause_signal=worktree_conflict
required_rewrite_scope=preserve_worktree_then_reconcile
forbidden_rewrite_scope=destructive_checkout_style_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=workspace_snapshot_conflict
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The patch lineage no longer matches the live workspace snapshot, so overwrite should be avoided.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
worktree_state=conflicted
overwrite_policy=forbidden
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=live_worktree_conflict
dominant_cause_signal=worktree_conflict
required_rewrite_scope=do_not_overwrite_worktree_state
forbidden_rewrite_scope=overwrite_workspace_state
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=preserve_worktree_state
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The current rollback candidate would trample an unmerged worktree delta and must preserve the live workspace context.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
workspace_snapshot=lineage_mismatch
rollback_scope=preserve_worktree
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=snapshot_lineage_mismatch
dominant_cause_signal=worktree_conflict
required_rewrite_scope=preserve_worktree_then_reconcile
forbidden_rewrite_scope=destructive_checkout_style_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=worktree_conflict_alignment
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Workspace state diverged and the worktree is now in conflict with the expected patch lineage.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
worktree_state=conflicted
overwrite_policy=forbidden
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=live_worktree_conflict
dominant_cause_signal=worktree_conflict
required_rewrite_scope=do_not_overwrite_worktree_state
forbidden_rewrite_scope=overwrite_workspace_state
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=workspace_snapshot_conflict
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The patch lineage no longer matches the live workspace snapshot, so overwrite should be avoided.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
workspace_snapshot=lineage_mismatch
rollback_scope=preserve_worktree
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=snapshot_lineage_mismatch
dominant_cause_signal=worktree_conflict
required_rewrite_scope=preserve_worktree_then_reconcile
forbidden_rewrite_scope=destructive_checkout_style_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=preserve_worktree_state
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The current rollback candidate would trample an unmerged worktree delta and must preserve the live workspace context.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
worktree_state=conflicted
overwrite_policy=forbidden
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=live_worktree_conflict
dominant_cause_signal=worktree_conflict
required_rewrite_scope=do_not_overwrite_worktree_state
forbidden_rewrite_scope=overwrite_workspace_state
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=worktree_conflict_alignment
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Workspace state diverged and the worktree is now in conflict with the expected patch lineage.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
workspace_snapshot=lineage_mismatch
rollback_scope=preserve_worktree
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=snapshot_lineage_mismatch
dominant_cause_signal=worktree_conflict
required_rewrite_scope=preserve_worktree_then_reconcile
forbidden_rewrite_scope=destructive_checkout_style_rewrite
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=workspace_snapshot_conflict
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The patch lineage no longer matches the live workspace snapshot, so overwrite should be avoided.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
worktree_state=conflicted
overwrite_policy=forbidden
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=live_worktree_conflict
dominant_cause_signal=worktree_conflict
required_rewrite_scope=do_not_overwrite_worktree_state
forbidden_rewrite_scope=overwrite_workspace_state
[/ROLLBACK_DECISION_FACTORS]


Prompt:
[HARNESS_ROLLBACK_ENVELOPE]
product_line=veriloop_coder
planner_enabled=true
validator_enabled=true
runtime_protocol=true
session_continuity=true
worktree_discipline=true
patch_alignment=true
sandbox_validation=true
tool_selfcheck_loop=true
reverse_engineering_mode=bounded
rule=Prefer minimal-diff rollback over broad regeneration.
rule=Preserve explicit conflicts rather than silently washing them out.
rule=Validator feedback, failure routes, patch state, workspace deltas, and rollback receipts are first-class rollback inputs.
rule=If code was executed and failed validator checks, prefer bounded self-check repair before broad rewrite.
rule=If reverse engineering is requested, preserve observed structure and receipts instead of inventing hidden internals.
rollback_mode=worktree_conflict
rollback_focus=preserve_worktree_state
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The current rollback candidate would trample an unmerged worktree delta and must preserve the live workspace context.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
workspace_snapshot=lineage_mismatch
rollback_scope=preserve_worktree
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=snapshot_lineage_mismatch
dominant_cause_signal=worktree_conflict
required_rewrite_scope=preserve_worktree_then_reconcile
forbidden_rewrite_scope=destructive_checkout_style_rewrite
[/ROLLBACK_DECISION_FACTORS]