fix(loop): detect stale loop plans

Reject stale cached loop dependency closures before opening new rounds, and expose fresh/stale plan status in loop show/list.

Author: lucifer1004

.claude/skills/gov/SKILL.md

@@ -94,12 +94,12 @@ The active work item is durable outcome context. Read it with `govctl work show
 
 ### Loop usage
 
-Use a loop only when a task has multiple independently meaningful work items. A loop coordinates durable work; it is not permission to split one cleanup/refactor into mechanical work-item fragments.
+Use a loop for non-trivial governed execution that needs local execution memory. This includes single-Work-Item work now that transient journal-style execution trace belongs in loop state and round artifacts. Multi-Work-Item loops add dependency and batch coordination; they are not permission to split one cleanup/refactor into mechanical work-item fragments.
 
 1. Create or activate only the work items that represent durable outcomes a future reader should see.
 2. Add `depends_on` edges for hard execution ordering.
 3. Run `govctl check` so dependency cycles or missing work item IDs are caught before the loop starts.
-4. Start one loop for the batch root set with `govctl loop start <ROOT-WI-ID> [<ROOT-WI-ID>...]`; let govctl generate the `LOOP-YYYY-MM-DD-NNN` ID.
+4. Start one loop for the root set with `govctl loop start <ROOT-WI-ID> [<ROOT-WI-ID>...]`; let govctl generate the `LOOP-YYYY-MM-DD-NNN` ID.
 5. Run `govctl loop run <LOOP-ID>` to open a local round for ready work.
 6. Perform implementation, verification, and any explicit `govctl work move` commands yourself.
 7. Fill the opened `.govctl/loops/<LOOP-ID>/rounds/round-NNN.toml` summary evidence.
@@ -117,7 +117,7 @@ If the scope changes during execution, keep the same loop identity:
 
 `work` is the editable loop work-item field. `wi` is accepted as a short alias, but examples should prefer `work`.
 
-Do not create scattered single-item loops for work that is part of one coherent batch.
+Do not create multiple scattered loops for work that belongs in one coherent execution session.
 
 Do not create separate work items for low-level implementation slices such as helper moves, test fixture sharing, module normalization, comment cleanup, snapshot reshaping, or other changes whose only durable record should be the commit diff or one higher-level work item.
 
@@ -145,7 +145,7 @@ govctl work list pending
 
 - Matching active item: use it
 - Matching queued item: `govctl work move <WI-ID> active`
-- No match and the task has one durable outcome: `govctl work new --active "<concise-title>"`
+- No match and the task has one durable outcome: `govctl work new --active "<concise-title>"`, then start a loop if the work is non-trivial
 - No match and the task has multiple independently reviewable durable outcomes: create that small batch first, wire only hard `depends_on` edges, then start one generated-ID loop for the batch.
 - No match and the apparent split is only mechanical implementation steps: create at most one coarse work item, or route trivial cleanup to `/quick`.
 

.claude/skills/wi-writer/SKILL.md

@@ -126,7 +126,8 @@ Create multiple work items only when each item is independently meaningful to fu
 - For trivial cleanup or docs-only edits, no work item may be the right answer; follow the invoking workflow instead of inventing tracking.
 - For one coherent cleanup/refactor, prefer one coarse work item over many narrow slices.
 - Use `depends_on` only for hard execution ordering; keep `refs` for informational links.
-- Use one batch loop only when there are multiple durable work items; do not use loops to justify creating mechanical work-item fragments.
+- Use a loop for non-trivial governed execution that needs local execution memory, including single-work-item execution after journal-style trace moved out of Work Item fields.
+- Use one multi-work-item loop only when there are multiple durable work items; do not use loops to justify creating mechanical work-item fragments.
 - Let govctl generate the loop ID with `govctl loop start <ROOT-WI-ID> [<ROOT-WI-ID>...]`; use the returned `LOOP-YYYY-MM-DD-NNN` ID for later loop commands.
 - Use `govctl loop list open` to discover existing non-terminal loops before resuming interrupted batch work.
 

CHANGELOG.md

@@ -10,15 +10,21 @@ Release entries are curated summaries for readers. Work item traceability remain
 
 ## [Unreleased]
 
+### Added
+
+- loop list and show expose stale loop plans without mutating local state (WI-2026-06-09-001)
+
 ### Changed
 
 - Writer skills include matching authority tests and examples so authors avoid boundary drift before review (WI-2026-06-07-005)
 - Reviewer agents include explicit boundary probes and boundary finding output for RFC, ADR, and Work Item reviews (WI-2026-06-07-005)
+- init-skills installs full skill directory bundles, including bundled references and assets (WI-2026-06-08-002)
 
 ### Fixed
 
 - cargo-binstall Windows override resolves to govctl-v{ version }-{ target }.zip (WI-2026-06-08-001)
 - cargo-binstall Unix pkg-url resolves to govctl-v{ version }-{ target }.tar.gz (WI-2026-06-08-001)
+- loop run rejects stale stored dependency closures before opening new work (WI-2026-06-09-001)
 
 ## [0.9.3] - 2026-06-07
 

docs/guide/recommended-workflows.md

@@ -120,8 +120,8 @@ Moving to `done` runs verification guards when verification is enabled.
 
 ## When To Use Loops
 
-Use a loop when execution is bigger than one simple Work Item or when you need
-resumable local round evidence.
+Use a loop when non-trivial execution needs resumable local round evidence,
+including single-Work-Item work.
 
 Good loop use cases:
 
@@ -160,6 +160,10 @@ govctl loop remove LOOP-YYYY-MM-DD-NNN work WI-YYYY-MM-DD-002
 govctl loop replan LOOP-YYYY-MM-DD-NNN
 ```
 
+If `loop show` or `loop list` reports a stale plan, the current Work Item
+dependency closure differs from the stored loop plan. Run `govctl loop replan
+LOOP-YYYY-MM-DD-NNN` before opening another round.
+
 Loop state is local execution memory under `.govctl/loops/`. Work Items remain
 the durable task record.
 

gov/work/2026-06-09-detect-stale-loop-plans.toml

@@ -0,0 +1,33 @@
+#:schema ../schema/work.schema.json
+
+[govctl]
+id = "WI-2026-06-09-001"
+title = "Detect stale loop plans"
+status = "done"
+created = "2026-06-09"
+started = "2026-06-09"
+completed = "2026-06-09"
+refs = ["RFC-0006"]
+
+[content]
+description = "Detect when persisted loop execution plans no longer match the current Work Item dependency closure, and guide users to replan without binding loops to VCS revisions."
+
+[[content.acceptance_criteria]]
+text = "loop run rejects stale stored dependency closures before opening new work"
+status = "done"
+category = "fixed"
+
+[[content.acceptance_criteria]]
+text = "loop list and show expose stale loop plans without mutating local state"
+status = "done"
+category = "added"
+
+[[content.acceptance_criteria]]
+text = "regression tests cover stale dependency closure detection and replan repair"
+status = "done"
+category = "chore"
+
+[[content.acceptance_criteria]]
+text = "govctl check passes"
+status = "done"
+category = "chore"

src/cmd/loop_cmd/execution/mod.rs

@@ -1,6 +1,7 @@
 use super::output::print_loop;
 use super::state::{
-    ensure_loop_not_terminal, ensure_unique_work_item_ids, loop_dependencies, loop_item_state,
+    ensure_loop_not_terminal, ensure_loop_plan_fresh, ensure_unique_work_item_ids,
+    loop_dependencies, loop_item_state,
 };
 use crate::cmd::work_lookup::load_work_item_by_id;
 use crate::config::Config;
@@ -129,6 +130,9 @@ fn open_round(
     max_rounds: u32,
     op: WriteOp,
 ) -> DiagnosticResult<Diagnostics> {
+    // Implements [[RFC-0006:C-ROUND-EXECUTION]] by rejecting stale cached plans
+    // before selecting new round work from current Work Item dependencies.
+    ensure_loop_plan_fresh(config, state)?;
     reflect_terminal_work_statuses(config, state)?;
     propagate_blocked_outcomes(state)?;
 

src/cmd/loop_cmd/mod.rs

@@ -16,10 +16,10 @@ use crate::loop_state::{
     LoopLifecycleState, LoopState, load_loop_state, validate_loop_id, write_loop_state_with_op,
 };
 use crate::write::WriteOp;
-use output::{LoopListEntry, print_loop, print_loop_list};
+use output::{LoopListEntry, print_loop, print_loop_list, print_loop_with_plan};
 use state::{
     canonical_loop_ids, ensure_loop_not_terminal, ensure_work_values, find_reusable_loop,
-    generated_loop_id,
+    generated_loop_id, loop_plan_status, loop_plan_status_from_work_items,
 };
 
 pub fn start(
@@ -54,7 +54,8 @@ pub fn start(
 
 pub fn show(config: &Config, loop_id: &str) -> DiagnosticResult<Diagnostics> {
     let state = load_loop_state(config, loop_id)?;
-    print_loop("Loop", &state)?;
+    let plan_status = loop_plan_status(config, &state);
+    print_loop_with_plan("Loop", &state, plan_status.as_str())?;
     Ok(vec![])
 }
 
@@ -74,9 +75,17 @@ pub fn list(
     if let Some(limit) = limit {
         states.truncate(limit);
     }
+    let all_work_items = crate::parse::load_work_items(config).ok();
     let entries = states
         .iter()
-        .map(LoopListEntry::from_state)
+        .map(|state| {
+            let plan_status = all_work_items
+                .as_deref()
+                .map_or(state::LoopPlanStatus::Stale, |work_items| {
+                    loop_plan_status_from_work_items(state, work_items)
+                });
+            LoopListEntry::from_state(state, plan_status.as_str())
+        })
         .collect::<Vec<_>>();
     print_loop_list(&entries, output);
     Ok(vec![])

src/cmd/loop_cmd/output.rs

@@ -11,17 +11,19 @@ use serde::Serialize;
 pub(super) struct LoopListEntry {
     id: String,
     state: String,
+    plan: String,
     work: Vec<String>,
     items: usize,
     rounds: u32,
     next_action: String,
 }
 
 impl LoopListEntry {
-    pub(super) fn from_state(state: &LoopState) -> Self {
+    pub(super) fn from_state(state: &LoopState, plan: &str) -> Self {
         Self {
             id: state.loop_meta.id.clone(),
             state: state.loop_meta.state.as_str().to_string(),
+            plan: plan.to_string(),
             work: state.loop_meta.work.clone(),
             items: state.loop_meta.resolved.len(),
             rounds: state.items.values().map(|item| item.round_count).sum(),
@@ -42,9 +44,10 @@ pub(super) fn print_loop_list(entries: &[LoopListEntry], output: OutputFormat) {
         OutputFormat::Plain => {
             for entry in entries {
                 println!(
-                    "{}\t{}\t{}\t{}\t{}\t{}",
+                    "{}\t{}\t{}\t{}\t{}\t{}\t{}",
                     entry.id,
                     entry.state,
+                    entry.plan,
                     entry.work_display(),
                     entry.items,
                     entry.rounds,
@@ -53,12 +56,14 @@ pub(super) fn print_loop_list(entries: &[LoopListEntry], output: OutputFormat) {
             }
         }
         OutputFormat::Table => {
-            let mut table =
-                table_with_bold_headers(&["ID", "State", "Work", "Items", "Rounds", "Action"]);
+            let mut table = table_with_bold_headers(&[
+                "ID", "State", "Plan", "Work", "Items", "Rounds", "Action",
+            ]);
             for entry in entries {
                 table.add_row(vec![
                     Cell::new(&entry.id),
                     Cell::new(&entry.state),
+                    Cell::new(&entry.plan),
                     Cell::new(entry.work_display()),
                     Cell::new(entry.items.to_string()),
                     Cell::new(entry.rounds.to_string()),
@@ -71,12 +76,27 @@ pub(super) fn print_loop_list(entries: &[LoopListEntry], output: OutputFormat) {
 }
 
 pub(super) fn print_loop(verb: &str, state: &LoopState) -> DiagnosticResult<()> {
+    print_loop_inner(verb, state, None)
+}
+
+pub(super) fn print_loop_with_plan(
+    verb: &str,
+    state: &LoopState,
+    plan: &str,
+) -> DiagnosticResult<()> {
+    print_loop_inner(verb, state, Some(plan))
+}
+
+fn print_loop_inner(verb: &str, state: &LoopState, plan: Option<&str>) -> DiagnosticResult<()> {
     if verb == "Loop" {
         println!("Loop {}", state.loop_meta.id);
     } else {
         println!("{} loop {}", verb, state.loop_meta.id);
     }
     println!("State: {}", state.loop_meta.state.as_str());
+    if let Some(plan) = plan {
+        println!("Plan status: {plan}");
+    }
     println!("Current round: {}", state.loop_meta.current_round);
     println!("Next action: {}", state.loop_meta.next_action.as_str());
     println!("Work: {}", state.loop_meta.work.join(", "));

src/cmd/loop_cmd/state.rs

@@ -1,9 +1,11 @@
 use crate::config::Config;
 use crate::diagnostic::{Diagnostic, DiagnosticCode, DiagnosticResult};
+use crate::loop_planner::replan_loop_state;
 use crate::loop_state::{
     LoopItemState, LoopLifecycleState, LoopState, load_loop_state, loop_state_path,
     loop_state_root, validate_loop_id,
 };
+use crate::model::WorkItemEntry;
 use std::collections::BTreeSet;
 
 pub(super) fn find_reusable_loop(
@@ -188,6 +190,86 @@ pub(super) fn ensure_loop_not_terminal(state: &LoopState, action: &str) -> Diagn
     Ok(())
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum LoopPlanStatus {
+    Fresh,
+    Stale,
+}
+
+impl LoopPlanStatus {
+    pub(super) fn as_str(self) -> &'static str {
+        match self {
+            Self::Fresh => "fresh",
+            Self::Stale => "stale",
+        }
+    }
+}
+
+pub(super) fn loop_plan_status(config: &Config, state: &LoopState) -> LoopPlanStatus {
+    if current_plan_matches_state(config, state).unwrap_or(false) {
+        LoopPlanStatus::Fresh
+    } else {
+        LoopPlanStatus::Stale
+    }
+}
+
+pub(super) fn loop_plan_status_from_work_items(
+    state: &LoopState,
+    all_work_items: &[WorkItemEntry],
+) -> LoopPlanStatus {
+    if current_plan_matches_work_items(state, all_work_items).unwrap_or(false) {
+        LoopPlanStatus::Fresh
+    } else {
+        LoopPlanStatus::Stale
+    }
+}
+
+pub(super) fn ensure_loop_plan_fresh(config: &Config, state: &LoopState) -> DiagnosticResult<()> {
+    match current_plan_matches_state(config, state) {
+        Ok(true) => Ok(()),
+        Ok(false) => Err(stale_loop_plan_diagnostic(
+            state,
+            "stored dependency closure no longer matches current Work Item files",
+        )),
+        Err(err) => Err(stale_loop_plan_diagnostic(
+            state,
+            format!(
+                "current Work Item dependency closure cannot be resolved ({})",
+                err.message
+            ),
+        )),
+    }
+}
+
+// Implements [[RFC-0006:C-DEPENDENCY-SEMANTICS]] and
+// [[RFC-0006:C-LOOP-SCOPE-MUTATION]] by treating stored scope as a cached plan.
+fn current_plan_matches_state(config: &Config, state: &LoopState) -> DiagnosticResult<bool> {
+    let all_work_items = crate::parse::load_work_items(config)?;
+    current_plan_matches_work_items(state, &all_work_items)
+}
+
+fn current_plan_matches_work_items(
+    state: &LoopState,
+    all_work_items: &[WorkItemEntry],
+) -> DiagnosticResult<bool> {
+    let plan = replan_loop_state(state, &state.loop_meta.work, all_work_items)?;
+    Ok(plan.state.loop_meta.resolved == state.loop_meta.resolved
+        && plan.state.dependencies == state.dependencies)
+}
+
+fn stale_loop_plan_diagnostic(state: &LoopState, reason: impl AsRef<str>) -> Diagnostic {
+    Diagnostic::new(
+        DiagnosticCode::E1201LoopStateInvalid,
+        format!(
+            "Loop '{}' is stale: {}. Run `govctl loop replan {}` before opening another round.",
+            state.loop_meta.id,
+            reason.as_ref(),
+            state.loop_meta.id
+        ),
+        state.loop_meta.id.clone(),
+    )
+}
+
 pub(super) fn generated_loop_id(config: &Config) -> DiagnosticResult<String> {
     let date = chrono::Local::now().format("%Y-%m-%d").to_string();
     generated_loop_id_for_date(config, &date)