feat(framework+cli): fw-4.23.0 / cli-3.20.0 — followups recount + born-resolved closure idioms (closes #222) (#223)

N=2 feedback from the first external adoption (lnxdrive):

- New `straymark followups recount` (#222 Finding 1): recompute the
  CLI-owned counters after a manual-triage session — the §13-compliant
  fix for counters stranded when drift --apply/promote are no-ops.
- drift --apply now recomputes counters even with zero extractions.
- Closure-marker vocabulary gains the born-resolved idiom family
  (#222 Finding 2): closure verb + "in this PR"/"in this commit",
  e.g. "updated atomically in this PR" → suspected-closed.
- Canonical closure-marker idioms documented in
  FOLLOW-UPS-BACKLOG-PATTERN.md (EN/ES/zh-CN); AGENT-RULES §13,
  /straymark-followups skill (4 surfaces), STRAYMARK.md §16 and
  QUICK-REFERENCE gain the recount step.
- 6 new tests (2 unit families, 4 integration); 619 passing total.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: montfort

CHANGELOG.md

@@ -7,6 +7,34 @@ and this project uses [independent versioning](README.md#versioning) for Framewo
 
 ---
 
+## Framework 4.23.0 / CLI 3.20.0 — N=2 feedback: `followups recount` + born-resolved closure idioms
+
+First fixes driven by **external adopter feedback**: the lnxdrive adoption run ([#222](https://github.com/StrangeDaysTech/straymark/issues/222), the first N=2 data point gating the v1 schema's hard stabilization per principle #12 / ADR-2026-06-03-001) surfaced two gaps in the follow-ups lane — both ergonomic/vocabulary, neither schema-level.
+
+### Added (CLI)
+
+- **`straymark followups recount`** (#222 Finding 1) — recompute the CLI-owned `total_*` counters from actual entry statuses and rewrite the frontmatter, without scanning AILOGs or touching entries. Closes the loop between the sanctioned manual-triage workflow (Triage/Consumption = manual status edits) and the CLI-owned counter invariant: until now the only recomputing commands (`drift --apply`, `promote`) were no-ops after a pure-triage session, stranding the file with knowingly stale counters and no §13-compliant fix. Idempotent; upgrades v0 → v1 in place like every other write command.
+- **Born-resolved closure idioms** (#222 Finding 2) — the anti-noise vocabulary now recognizes a closure verb (`updated` / `corrected` / `remediated` / `resolved` / `fixed` / `closed`) followed by `in this PR` / `in this commit` (e.g. the lnxdrive phrasing `Charter row updated atomically in this PR`), extracting those bullets as `suspected-closed` instead of reintroducing the TBD noise that #214 Signal 1 removed.
+
+### Changed (CLI)
+
+- **`followups drift --apply` recomputes counters even with zero extractions** (#222 Finding 1) — a pre-commit `drift --apply` now also reconciles counters left stale by a manual-triage session, making the `status` warning's remediation claim actually true.
+- `followups status` stale-counter warning now points at `straymark followups recount`.
+
+### Added (Framework)
+
+- **Canonical closure-marker idioms** documented in `FOLLOW-UPS-BACKLOG-PATTERN.md` (EN/ES/zh-CN) — the fixed vocabulary the anti-noise refinement recognizes, so AILOG authors converge on recognizable phrasings at write time instead of discovering unrecognized idioms at extraction.
+
+### Changed (Framework)
+
+- **`AGENT-RULES.md §13` post-Charter-close directive** (EN/ES/zh-CN) gains the recount step: after flipping statuses by hand, run `straymark followups recount` so the CLI-owned counters ride the same commit as the triage. The `/straymark-followups` skill (4 surfaces), `STRAYMARK.md §16` lifecycle table, and `QUICK-REFERENCE.md` command line follow suit.
+
+### Adopter guidance
+
+Run `straymark update` (CLI → `cli-3.20.0`, framework → `fw-4.23.0`). If your registry carries stale counters from a manual triage (the lnxdrive case): `straymark followups recount` fixes it in one command.
+
+---
+
 ## Framework 4.22.0 — `/straymark-followups` skill ships the §13 directives as an invocable wrapper
 
 Closes the last gap in the follow-ups first-class lane (fw-4.21.0 / cli-3.19.0): the `AGENT-RULES.md §13` directives — session-start "what's pending?" answered from the canonical registry, pre-commit `followups drift --apply` riding the same commit as the AILOG, post-Charter-close triage and operator-gated `promote` — now ship as an invocable skill across all four agent surfaces, mirroring the `straymark-charter-new` lane. Driven by [#220](https://github.com/StrangeDaysTech/straymark/issues/220) (deferred from the cli-3.19.0 PR because skills ride framework releases and fw-4.21.0 was already tagged). The skill is a **thin wrapper**: parsing, schema validation, counter recomputation, and the FU → TDE elevation all stay in the CLI (`straymark followups list/status/drift/promote`, cli-3.19.0+); the skill only drives the discipline.

README.md

@@ -277,8 +277,8 @@ StrayMark uses independent version tags for each component:
 
 | Component | Tag prefix | Example | Includes |
 | --- | --- | --- | --- |
-| Framework | `fw-` | `fw-4.22.0` | Templates (12 types), governance, directives, Charter template + schema |
-| CLI | `cli-` | `cli-3.19.1` | The `straymark` binary |
+| Framework | `fw-` | `fw-4.23.0` | Templates (12 types), governance, directives, Charter template + schema |
+| CLI | `cli-` | `cli-3.20.0` | The `straymark` binary |
 
 Check installed versions with `straymark status` or `straymark about`.
 
@@ -311,7 +311,7 @@ See [CLI Reference](https://github.com/StrangeDaysTech/straymark/blob/main/docs/
 ```bash
 # Download the latest framework release ZIP from GitHub
 # Go to https://github.com/StrangeDaysTech/straymark/releases
-# and download the latest fw-* release (e.g., fw-4.22.0)
+# and download the latest fw-* release (e.g., fw-4.23.0)
 
 # Extract and copy to your project
 unzip straymark-fw-*.zip -d your-project/

cli/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "straymark-cli"
-version = "3.19.1"
+version = "3.20.0"
 edition = "2021"
 description = "CLI for StrayMark — the cognitive discipline your AI-assisted projects need"
 license = "MIT"

cli/Cargo.toml

@@ -114,6 +114,28 @@ pub fn run(path: &str, apply: bool, scan_all: bool, range: Option<&str>) -> Resu
             "{} registry in sync — no AILOGs with unextracted follow-up content.",
             "OK".green().bold()
         );
+        // --apply always reconciles the CLI-owned counters, even with zero
+        // extractions (#222 Finding 1): after a sanctioned manual-triage
+        // session the statuses changed but nothing is left to extract, and
+        // without this write the frontmatter stays knowingly stale.
+        if apply {
+            let counters = followups::compute_counters(&registry);
+            let fm =
+                followups::fm_apply_counters_and_v1(&registry.frontmatter_raw, &counters);
+            if fm != registry.frontmatter_raw {
+                let was_v0 = registry.is_v0();
+                std::fs::write(&registry_path, followups::assemble(&fm, &registry.body))?;
+                println!(
+                    "  Counters recomputed: {} open / {} suspected-closed / {} promoted (total {}).",
+                    counters.open, counters.suspected_closed, counters.promoted, counters.total
+                );
+                if was_v0 {
+                    utils::info(
+                        "Registry upgraded to schema v1 (non-destructive — counters are now CLI-owned).",
+                    );
+                }
+            }
+        }
         return Ok(());
     }
 

cli/src/commands/followups/drift.rs

@@ -3,11 +3,13 @@
 //!
 //! Subcommands mirror the `charter` namespace: `list` / `status` enumerate
 //! and inspect, `drift` keeps the registry in sync with AILOGs (native
-//! replacement for the deprecated adopter-side bash script), `promote`
-//! automates the FU → TDE elevation. See `FOLLOW-UPS-BACKLOG-PATTERN.md`
-//! and `STRAYMARK.md §16`.
+//! replacement for the deprecated adopter-side bash script), `recount`
+//! reconciles the CLI-owned counters after a manual-triage session,
+//! `promote` automates the FU → TDE elevation. See
+//! `FOLLOW-UPS-BACKLOG-PATTERN.md` and `STRAYMARK.md §16`.
 
 pub mod drift;
 pub mod list;
 pub mod promote;
+pub mod recount;
 pub mod status;

cli/src/commands/followups/mod.rs

@@ -0,0 +1,70 @@
+//! `straymark followups recount` — recompute the CLI-owned frontmatter
+//! counters from actual entry statuses, without scanning AILOGs.
+//!
+//! Closes the manual-triage loop found in the first external adoption
+//! (issue #222 Finding 1): the v1 lifecycle sanctions Triage and Consumption
+//! as manual status edits, but until cli-3.20.0 the only commands that
+//! recomputed the CLI-owned `total_*` counters were `drift --apply` and
+//! `promote` — both no-ops after a pure-triage session, stranding the
+//! frontmatter with knowingly stale counters and no §13-compliant fix.
+//!
+//! `recount` is the dedicated, idempotent verb: parse the registry, recompute
+//! the counters from entry statuses (the same `compute_counters` the pulse
+//! uses), rewrite the frontmatter (upgrading v0 → v1 in place, like every
+//! other write command), and report. No AILOG scan, no extraction, no entry
+//! mutation — counters only.
+
+use anyhow::{anyhow, bail, Result};
+use colored::Colorize;
+
+use crate::followups;
+use crate::utils;
+
+pub fn run(path: &str) -> Result<()> {
+    let resolved = utils::resolve_project_root(path)
+        .ok_or_else(|| anyhow!("StrayMark not installed. Run 'straymark init' first."))?;
+    let project_root = &resolved.path;
+
+    let registry_path = followups::registry_path(project_root);
+    if !registry_path.exists() {
+        bail!(
+            "No follow-ups registry at {}.\n  hint: run `straymark followups drift --scan-all --apply` to create and seed it (see STRAYMARK.md §16).",
+            registry_path.display()
+        );
+    }
+
+    let registry = followups::parse_registry(&registry_path)?;
+    for w in &registry.warnings {
+        utils::warn(w);
+    }
+
+    let counters = followups::compute_counters(&registry);
+    let fm = followups::fm_apply_counters_and_v1(&registry.frontmatter_raw, &counters);
+
+    if fm == registry.frontmatter_raw {
+        println!(
+            "{} counters already in sync: {} open / {} suspected-closed / {} promoted (total {}).",
+            "OK".green().bold(),
+            counters.open,
+            counters.suspected_closed,
+            counters.promoted,
+            counters.total
+        );
+        return Ok(());
+    }
+
+    let was_v0 = registry.is_v0();
+    std::fs::write(
+        &registry_path,
+        followups::assemble(&fm, &registry.body),
+    )?;
+
+    utils::success(&format!(
+        "Counters recomputed: {} open / {} suspected-closed / {} promoted (total {}).",
+        counters.open, counters.suspected_closed, counters.promoted, counters.total
+    ));
+    if was_v0 {
+        utils::info("Registry upgraded to schema v1 (non-destructive — counters are now CLI-owned).");
+    }
+    Ok(())
+}

cli/src/commands/followups/recount.rs

@@ -181,12 +181,12 @@ fn print_pulse(registry: &Registry) {
         println!();
     }
 
-    // Flag stale frontmatter counters (informational — the next write fixes them).
+    // Flag stale frontmatter counters (informational — `recount` fixes them).
     let declared_open = fm.total_open;
     if let Some(declared) = declared_open {
         if declared != counters.open {
             println!(
-                "  {} frontmatter says total_open: {} but the real count is {} — the next `followups drift --apply` or `promote` recomputes it.",
+                "  {} frontmatter says total_open: {} but the real count is {} — run `straymark followups recount` to reconcile (any write command also recomputes).",
                 "!".yellow().bold(),
                 declared,
                 counters.open

cli/src/commands/followups/status.rs

@@ -748,11 +748,25 @@ fn extract_section(content: &str, pred: impl Fn(&str) -> bool) -> Option<String>
     }
 }
 
+/// Closure verbs recognized by the born-resolved idiom family
+/// "<verb> … in this PR / in this commit" (#222 Finding 2).
+const CLOSURE_VERBS: [&str; 6] = [
+    "updated",
+    "corrected",
+    "remediated",
+    "resolved",
+    "fixed",
+    "closed",
+];
+
 /// True when the text carries an explicit in-Charter closure marker:
 /// "closed in-Charter" / "closed in Charter" / "resolved in-Charter" /
-/// "fixed in batch N" (case-insensitive), or a backtick-wrapped commit hash
-/// (7-40 hex chars). The signal that drives `suspected-closed` extraction
-/// (#214 Signal 1 — 20-75% of auto-appended entries per batch were already
+/// "fixed in batch N", a born-resolved idiom — a closure verb (`updated` /
+/// `corrected` / `remediated` / `resolved` / `fixed` / `closed`) followed by
+/// "in this PR" or "in this commit" (#222 Finding 2, first external adopter)
+/// — all case-insensitive, or a backtick-wrapped commit hash (7-40 hex
+/// chars). The signal that drives `suspected-closed` extraction (#214
+/// Signal 1 — 20-75% of auto-appended entries per batch were already
 /// resolved in-Charter across both documented occurrences).
 pub fn has_closure_marker(text: &str) -> bool {
     let lower = text.to_lowercase();
@@ -770,6 +784,17 @@ pub fn has_closure_marker(text: &str) -> bool {
             return true;
         }
     }
+    // Born-resolved idiom: a closure verb anywhere before "in this PR" /
+    // "in this commit" (e.g. "Charter row updated atomically in this PR").
+    // rfind takes the last context occurrence, maximizing the verb window.
+    for ctx in ["in this pr", "in this commit"] {
+        if let Some(ctx_idx) = lower.rfind(ctx) {
+            let before = &lower[..ctx_idx];
+            if CLOSURE_VERBS.iter().any(|v| before.contains(v)) {
+                return true;
+            }
+        }
+    }
     // Backtick-wrapped hex run of 7-40 chars (commit hash reference).
     let mut chars = text.char_indices().peekable();
     while let Some((i, c)) = chars.next() {
@@ -1174,6 +1199,23 @@ Done.
         assert!(!has_closure_marker("run `cargo test` first"));
     }
 
+    #[test]
+    fn closure_markers_born_resolved_idiom_family() {
+        // #222 Finding 2 — the exact lnxdrive phrasing that landed as `open`.
+        assert!(has_closure_marker(
+            "Charter `## Files to modify` row updated atomically in this PR."
+        ));
+        assert!(has_closure_marker("remediated in this PR"));
+        assert!(has_closure_marker("the regression was Corrected in this commit"));
+        assert!(has_closure_marker("scope drift recognized and fixed in this PR"));
+        // Verb required — context phrase alone is not a closure.
+        assert!(!has_closure_marker("discussed in this PR"));
+        assert!(!has_closure_marker("tracked in this PR for visibility"));
+        // Context phrase required — future-tense / follow-up phrasing is not.
+        assert!(!has_closure_marker("will be updated in a follow-up PR"));
+        assert!(!has_closure_marker("should be corrected in the next commit"));
+    }
+
     #[test]
     fn ailog_id_from_path_takes_five_tokens() {
         assert_eq!(

cli/src/followups.rs

@@ -339,6 +339,16 @@ enum FollowupsCommands {
         #[arg(long = "path", default_value = ".")]
         path: String,
     },
+    /// Recompute the CLI-owned frontmatter counters from actual entry
+    /// statuses, without scanning AILOGs. The §13-compliant way to reconcile
+    /// counters after a manual-triage session (statuses flipped by hand,
+    /// nothing left to extract or promote). Idempotent; upgrades v0
+    /// registries to v1 in place like every other write command.
+    Recount {
+        /// Project directory (default: current directory)
+        #[arg(long = "path", default_value = ".")]
+        path: String,
+    },
     /// Promote an entry to a TDE document (creates the TDE with
     /// promoted_from_followup traceability, marks the entry `promoted`,
     /// recomputes counters). Non-interactive; prioritization stays human.
@@ -834,6 +844,7 @@ fn main() {
                 range,
                 path,
             } => commands::followups::drift::run(&path, apply, scan_all, range.as_deref()),
+            FollowupsCommands::Recount { path } => commands::followups::recount::run(&path),
             FollowupsCommands::Promote { fu_id, title, path } => {
                 commands::followups::promote::run(&path, &fu_id, title.as_deref())
             }