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=high_risk_unsupported
rollback_focus=fail_closed_high_risk_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The current answer path carries a high-risk claim unsupported by sufficient evidence and validator backing.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
risk_band=high
support_state=insufficient
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=high_risk_without_support
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=fail_closed
forbidden_rewrite_scope=continue_as_validated
[/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=high_risk_unsupported
rollback_focus=unsupported_high_risk_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A sensitive request remains under-supported and must not continue as if validated.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
policy_mode=fail_closed
unsupported_claims=retract
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=unsafe_claim_without_receipts
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=retract_and_fail_closed
forbidden_rewrite_scope=speculative_completion
[/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=high_risk_unsupported
rollback_focus=validator_guarded_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The branch touches a high-risk decision surface without adequate evidence or receipts and must fail closed.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
risk_band=high
support_state=insufficient
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=high_risk_without_support
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=fail_closed
forbidden_rewrite_scope=continue_as_validated
[/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=high_risk_unsupported
rollback_focus=fail_closed_high_risk_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The current answer path carries a high-risk claim unsupported by sufficient evidence and validator backing.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
policy_mode=fail_closed
unsupported_claims=retract
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=unsafe_claim_without_receipts
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=retract_and_fail_closed
forbidden_rewrite_scope=speculative_completion
[/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=high_risk_unsupported
rollback_focus=unsupported_high_risk_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A sensitive request remains under-supported and must not continue as if validated.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
risk_band=high
support_state=insufficient
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=high_risk_without_support
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=fail_closed
forbidden_rewrite_scope=continue_as_validated
[/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=high_risk_unsupported
rollback_focus=validator_guarded_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The branch touches a high-risk decision surface without adequate evidence or receipts and must fail closed.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
policy_mode=fail_closed
unsupported_claims=retract
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=unsafe_claim_without_receipts
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=retract_and_fail_closed
forbidden_rewrite_scope=speculative_completion
[/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=high_risk_unsupported
rollback_focus=fail_closed_high_risk_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The current answer path carries a high-risk claim unsupported by sufficient evidence and validator backing.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
risk_band=high
support_state=insufficient
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=high_risk_without_support
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=fail_closed
forbidden_rewrite_scope=continue_as_validated
[/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=high_risk_unsupported
rollback_focus=unsupported_high_risk_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A sensitive request remains under-supported and must not continue as if validated.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
policy_mode=fail_closed
unsupported_claims=retract
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=unsafe_claim_without_receipts
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=retract_and_fail_closed
forbidden_rewrite_scope=speculative_completion
[/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=high_risk_unsupported
rollback_focus=validator_guarded_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The branch touches a high-risk decision surface without adequate evidence or receipts and must fail closed.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
risk_band=high
support_state=insufficient
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=high_risk_without_support
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=fail_closed
forbidden_rewrite_scope=continue_as_validated
[/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=high_risk_unsupported
rollback_focus=fail_closed_high_risk_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The current answer path carries a high-risk claim unsupported by sufficient evidence and validator backing.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
policy_mode=fail_closed
unsupported_claims=retract
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=unsafe_claim_without_receipts
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=retract_and_fail_closed
forbidden_rewrite_scope=speculative_completion
[/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=high_risk_unsupported
rollback_focus=unsupported_high_risk_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A sensitive request remains under-supported and must not continue as if validated.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
risk_band=high
support_state=insufficient
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=high_risk_without_support
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=fail_closed
forbidden_rewrite_scope=continue_as_validated
[/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=high_risk_unsupported
rollback_focus=validator_guarded_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The branch touches a high-risk decision surface without adequate evidence or receipts and must fail closed.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
policy_mode=fail_closed
unsupported_claims=retract
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=unsafe_claim_without_receipts
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=retract_and_fail_closed
forbidden_rewrite_scope=speculative_completion
[/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=high_risk_unsupported
rollback_focus=fail_closed_high_risk_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The current answer path carries a high-risk claim unsupported by sufficient evidence and validator backing.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
risk_band=high
support_state=insufficient
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=high_risk_without_support
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=fail_closed
forbidden_rewrite_scope=continue_as_validated
[/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=high_risk_unsupported
rollback_focus=unsupported_high_risk_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A sensitive request remains under-supported and must not continue as if validated.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
policy_mode=fail_closed
unsupported_claims=retract
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=unsafe_claim_without_receipts
dominant_cause_signal=high_risk_unsupported
required_rewrite_scope=retract_and_fail_closed
forbidden_rewrite_scope=speculative_completion
[/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=tool_selfcheck_repair
rollback_focus=tool_selfcheck_then_repair
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Code was produced, tool-based validation failed, and the runtime should revise by bounded self-check/repair before final submission.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
selfcheck_status=failed
repair_loop=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=tool_selfcheck_negative
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=repair_via_bounded_selfcheck_loop
forbidden_rewrite_scope=broad_rewrite_without_selfcheck
[/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=tool_selfcheck_repair
rollback_focus=selfcheck_repair_loop
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A generated patch failed bounded validation and should re-enter a self-check repair loop instead of a broad rewrite.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
tool_validation=negative
repair_scope=narrow
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=compiler_or_unit_gate_failed
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=narrow_selfcheck_repair_cycle
forbidden_rewrite_scope=skip_repair_loop
[/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=tool_selfcheck_repair
rollback_focus=bounded_selfcheck_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The compiler or unit-check path failed locally, so the system should run a narrow self-check repair cycle.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
selfcheck_status=failed
repair_loop=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=tool_selfcheck_negative
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=repair_via_bounded_selfcheck_loop
forbidden_rewrite_scope=broad_rewrite_without_selfcheck
[/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=tool_selfcheck_repair
rollback_focus=tool_selfcheck_then_repair
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Code was produced, tool-based validation failed, and the runtime should revise by bounded self-check/repair before final submission.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
tool_validation=negative
repair_scope=narrow
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=compiler_or_unit_gate_failed
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=narrow_selfcheck_repair_cycle
forbidden_rewrite_scope=skip_repair_loop
[/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=tool_selfcheck_repair
rollback_focus=selfcheck_repair_loop
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A generated patch failed bounded validation and should re-enter a self-check repair loop instead of a broad rewrite.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
selfcheck_status=failed
repair_loop=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=tool_selfcheck_negative
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=repair_via_bounded_selfcheck_loop
forbidden_rewrite_scope=broad_rewrite_without_selfcheck
[/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=tool_selfcheck_repair
rollback_focus=bounded_selfcheck_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The compiler or unit-check path failed locally, so the system should run a narrow self-check repair cycle.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
tool_validation=negative
repair_scope=narrow
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=compiler_or_unit_gate_failed
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=narrow_selfcheck_repair_cycle
forbidden_rewrite_scope=skip_repair_loop
[/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=tool_selfcheck_repair
rollback_focus=tool_selfcheck_then_repair
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Code was produced, tool-based validation failed, and the runtime should revise by bounded self-check/repair before final submission.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
selfcheck_status=failed
repair_loop=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=tool_selfcheck_negative
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=repair_via_bounded_selfcheck_loop
forbidden_rewrite_scope=broad_rewrite_without_selfcheck
[/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=tool_selfcheck_repair
rollback_focus=selfcheck_repair_loop
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A generated patch failed bounded validation and should re-enter a self-check repair loop instead of a broad rewrite.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
tool_validation=negative
repair_scope=narrow
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=compiler_or_unit_gate_failed
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=narrow_selfcheck_repair_cycle
forbidden_rewrite_scope=skip_repair_loop
[/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=tool_selfcheck_repair
rollback_focus=bounded_selfcheck_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The compiler or unit-check path failed locally, so the system should run a narrow self-check repair cycle.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
selfcheck_status=failed
repair_loop=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=tool_selfcheck_negative
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=repair_via_bounded_selfcheck_loop
forbidden_rewrite_scope=broad_rewrite_without_selfcheck
[/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=tool_selfcheck_repair
rollback_focus=tool_selfcheck_then_repair
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Code was produced, tool-based validation failed, and the runtime should revise by bounded self-check/repair before final submission.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
tool_validation=negative
repair_scope=narrow
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=compiler_or_unit_gate_failed
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=narrow_selfcheck_repair_cycle
forbidden_rewrite_scope=skip_repair_loop
[/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=tool_selfcheck_repair
rollback_focus=selfcheck_repair_loop
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A generated patch failed bounded validation and should re-enter a self-check repair loop instead of a broad rewrite.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
selfcheck_status=failed
repair_loop=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=tool_selfcheck_negative
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=repair_via_bounded_selfcheck_loop
forbidden_rewrite_scope=broad_rewrite_without_selfcheck
[/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=tool_selfcheck_repair
rollback_focus=bounded_selfcheck_patch
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The compiler or unit-check path failed locally, so the system should run a narrow self-check repair cycle.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
tool_validation=negative
repair_scope=narrow
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=compiler_or_unit_gate_failed
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=narrow_selfcheck_repair_cycle
forbidden_rewrite_scope=skip_repair_loop
[/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=tool_selfcheck_repair
rollback_focus=tool_selfcheck_then_repair
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Code was produced, tool-based validation failed, and the runtime should revise by bounded self-check/repair before final submission.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
selfcheck_status=failed
repair_loop=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=tool_selfcheck_negative
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=repair_via_bounded_selfcheck_loop
forbidden_rewrite_scope=broad_rewrite_without_selfcheck
[/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=tool_selfcheck_repair
rollback_focus=selfcheck_repair_loop
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A generated patch failed bounded validation and should re-enter a self-check repair loop instead of a broad rewrite.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
tool_validation=negative
repair_scope=narrow
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=compiler_or_unit_gate_failed
dominant_cause_signal=tool_selfcheck_failure
required_rewrite_scope=narrow_selfcheck_repair_cycle
forbidden_rewrite_scope=skip_repair_loop
[/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=reverse_engineering_drift
rollback_focus=reverse_engineering_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A reverse-engineering task drifted into speculative internals not justified by observed artifacts or executable evidence.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
analysis_mode=reverse_engineering
observation_policy=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=speculative_reverse_engineering
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=bounded_observation_first
forbidden_rewrite_scope=invent_hidden_internals
[/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=reverse_engineering_drift
rollback_focus=bounded_reverse_engineering
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Repository inference started inventing hidden internals and must be pulled back to observation-first analysis.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
speculation_state=too_high
grounding_requirement=observed_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=observed_artifacts_insufficient
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=evidence_grounded_reverse_revision
forbidden_rewrite_scope=unbounded_architecture_guessing
[/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=reverse_engineering_drift
rollback_focus=observation_first_reverse_engineering
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Static inspection is slipping into imagined architecture details that are not grounded in observed files or receipts.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
analysis_mode=reverse_engineering
observation_policy=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=speculative_reverse_engineering
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=bounded_observation_first
forbidden_rewrite_scope=invent_hidden_internals
[/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=reverse_engineering_drift
rollback_focus=reverse_engineering_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A reverse-engineering task drifted into speculative internals not justified by observed artifacts or executable evidence.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
speculation_state=too_high
grounding_requirement=observed_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=observed_artifacts_insufficient
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=evidence_grounded_reverse_revision
forbidden_rewrite_scope=unbounded_architecture_guessing
[/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=reverse_engineering_drift
rollback_focus=bounded_reverse_engineering
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Repository inference started inventing hidden internals and must be pulled back to observation-first analysis.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
analysis_mode=reverse_engineering
observation_policy=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=speculative_reverse_engineering
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=bounded_observation_first
forbidden_rewrite_scope=invent_hidden_internals
[/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=reverse_engineering_drift
rollback_focus=observation_first_reverse_engineering
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Static inspection is slipping into imagined architecture details that are not grounded in observed files or receipts.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
speculation_state=too_high
grounding_requirement=observed_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=observed_artifacts_insufficient
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=evidence_grounded_reverse_revision
forbidden_rewrite_scope=unbounded_architecture_guessing
[/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=reverse_engineering_drift
rollback_focus=reverse_engineering_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A reverse-engineering task drifted into speculative internals not justified by observed artifacts or executable evidence.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
analysis_mode=reverse_engineering
observation_policy=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=speculative_reverse_engineering
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=bounded_observation_first
forbidden_rewrite_scope=invent_hidden_internals
[/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=reverse_engineering_drift
rollback_focus=bounded_reverse_engineering
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Repository inference started inventing hidden internals and must be pulled back to observation-first analysis.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
speculation_state=too_high
grounding_requirement=observed_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=observed_artifacts_insufficient
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=evidence_grounded_reverse_revision
forbidden_rewrite_scope=unbounded_architecture_guessing
[/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=reverse_engineering_drift
rollback_focus=observation_first_reverse_engineering
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Static inspection is slipping into imagined architecture details that are not grounded in observed files or receipts.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
analysis_mode=reverse_engineering
observation_policy=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=speculative_reverse_engineering
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=bounded_observation_first
forbidden_rewrite_scope=invent_hidden_internals
[/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=reverse_engineering_drift
rollback_focus=reverse_engineering_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A reverse-engineering task drifted into speculative internals not justified by observed artifacts or executable evidence.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
speculation_state=too_high
grounding_requirement=observed_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=observed_artifacts_insufficient
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=evidence_grounded_reverse_revision
forbidden_rewrite_scope=unbounded_architecture_guessing
[/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=reverse_engineering_drift
rollback_focus=bounded_reverse_engineering
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Repository inference started inventing hidden internals and must be pulled back to observation-first analysis.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
analysis_mode=reverse_engineering
observation_policy=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=speculative_reverse_engineering
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=bounded_observation_first
forbidden_rewrite_scope=invent_hidden_internals
[/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=reverse_engineering_drift
rollback_focus=observation_first_reverse_engineering
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Static inspection is slipping into imagined architecture details that are not grounded in observed files or receipts.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
speculation_state=too_high
grounding_requirement=observed_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=observed_artifacts_insufficient
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=evidence_grounded_reverse_revision
forbidden_rewrite_scope=unbounded_architecture_guessing
[/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=reverse_engineering_drift
rollback_focus=reverse_engineering_fail_closed
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
A reverse-engineering task drifted into speculative internals not justified by observed artifacts or executable evidence.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
analysis_mode=reverse_engineering
observation_policy=bounded
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=speculative_reverse_engineering
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=bounded_observation_first
forbidden_rewrite_scope=invent_hidden_internals
[/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=reverse_engineering_drift
rollback_focus=bounded_reverse_engineering
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Repository inference started inventing hidden internals and must be pulled back to observation-first analysis.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
speculation_state=too_high
grounding_requirement=observed_only
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=observed_artifacts_insufficient
dominant_cause_signal=reverse_engineering_speculation
required_rewrite_scope=evidence_grounded_reverse_revision
forbidden_rewrite_scope=unbounded_architecture_guessing
[/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=validated_stable
rollback_focus=validated_stability_no_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Validator passed, receipts are aligned, and no contradictory evidence or patch regression was introduced.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
validator_gate=pass
rollback_need=none
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_and_receipts_clean
dominant_cause_signal=none
required_rewrite_scope=do_not_rollback
forbidden_rewrite_scope=gratuitous_revision
[/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=validated_stable
rollback_focus=stable_no_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
All local checks passed, worktree is stable, and rollback should stay inactive.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
receipt_alignment=clean
workspace_state=stable
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=stable_worktree_and_passed_checks
dominant_cause_signal=none
required_rewrite_scope=keep_current_revision
forbidden_rewrite_scope=needless_repair_loop
[/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=validated_stable
rollback_focus=keep_valid_revision
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The latest revision is receipt-consistent, validator-clean, and should remain untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
validator_gate=pass
rollback_need=none
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_and_receipts_clean
dominant_cause_signal=none
required_rewrite_scope=do_not_rollback
forbidden_rewrite_scope=gratuitous_revision
[/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=validated_stable
rollback_focus=validated_stability_no_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Validator passed, receipts are aligned, and no contradictory evidence or patch regression was introduced.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
receipt_alignment=clean
workspace_state=stable
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=stable_worktree_and_passed_checks
dominant_cause_signal=none
required_rewrite_scope=keep_current_revision
forbidden_rewrite_scope=needless_repair_loop
[/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=validated_stable
rollback_focus=stable_no_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
All local checks passed, worktree is stable, and rollback should stay inactive.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
validator_gate=pass
rollback_need=none
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_and_receipts_clean
dominant_cause_signal=none
required_rewrite_scope=do_not_rollback
forbidden_rewrite_scope=gratuitous_revision
[/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=validated_stable
rollback_focus=keep_valid_revision
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The latest revision is receipt-consistent, validator-clean, and should remain untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
receipt_alignment=clean
workspace_state=stable
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=stable_worktree_and_passed_checks
dominant_cause_signal=none
required_rewrite_scope=keep_current_revision
forbidden_rewrite_scope=needless_repair_loop
[/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=validated_stable
rollback_focus=validated_stability_no_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Validator passed, receipts are aligned, and no contradictory evidence or patch regression was introduced.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
validator_gate=pass
rollback_need=none
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_and_receipts_clean
dominant_cause_signal=none
required_rewrite_scope=do_not_rollback
forbidden_rewrite_scope=gratuitous_revision
[/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=validated_stable
rollback_focus=stable_no_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
All local checks passed, worktree is stable, and rollback should stay inactive.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
receipt_alignment=clean
workspace_state=stable
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=stable_worktree_and_passed_checks
dominant_cause_signal=none
required_rewrite_scope=keep_current_revision
forbidden_rewrite_scope=needless_repair_loop
[/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=validated_stable
rollback_focus=keep_valid_revision
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The latest revision is receipt-consistent, validator-clean, and should remain untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
validator_gate=pass
rollback_need=none
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_and_receipts_clean
dominant_cause_signal=none
required_rewrite_scope=do_not_rollback
forbidden_rewrite_scope=gratuitous_revision
[/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=validated_stable
rollback_focus=validated_stability_no_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Validator passed, receipts are aligned, and no contradictory evidence or patch regression was introduced.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
receipt_alignment=clean
workspace_state=stable
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=stable_worktree_and_passed_checks
dominant_cause_signal=none
required_rewrite_scope=keep_current_revision
forbidden_rewrite_scope=needless_repair_loop
[/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=validated_stable
rollback_focus=stable_no_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
All local checks passed, worktree is stable, and rollback should stay inactive.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
validator_gate=pass
rollback_need=none
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_and_receipts_clean
dominant_cause_signal=none
required_rewrite_scope=do_not_rollback
forbidden_rewrite_scope=gratuitous_revision
[/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=validated_stable
rollback_focus=keep_valid_revision
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
The latest revision is receipt-consistent, validator-clean, and should remain untouched.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=visible
patch_scope=minimal
workspace_delta=preserved
rollback_budget=conservative
receipt_alignment=clean
workspace_state=stable
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=stable_worktree_and_passed_checks
dominant_cause_signal=none
required_rewrite_scope=keep_current_revision
forbidden_rewrite_scope=needless_repair_loop
[/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=validated_stable
rollback_focus=validated_stability_no_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
Validator passed, receipts are aligned, and no contradictory evidence or patch regression was introduced.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=active
patch_scope=bounded
workspace_delta=tracked
rollback_budget=tight
validator_gate=pass
rollback_need=none
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=validator_and_receipts_clean
dominant_cause_signal=none
required_rewrite_scope=do_not_rollback
forbidden_rewrite_scope=gratuitous_revision
[/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=validated_stable
rollback_focus=stable_no_rollback
[/HARNESS_ROLLBACK_ENVELOPE]

[USER_QUERY]
All local checks passed, worktree is stable, and rollback should stay inactive.
[/USER_QUERY]

[ROLLBACK_CONTEXT]
validator_receipt_state=latest
patch_scope=local
workspace_delta=audited
rollback_budget=cost-aware
receipt_alignment=clean
workspace_state=stable
[/ROLLBACK_CONTEXT]

[ROLLBACK_DECISION_FACTORS]
observed_failure_channel=stable_worktree_and_passed_checks
dominant_cause_signal=none
required_rewrite_scope=keep_current_revision
forbidden_rewrite_scope=needless_repair_loop
[/ROLLBACK_DECISION_FACTORS]