@tekyzinc/gsd-t 5.11.11 → 5.11.13

package/CHANGELOG.md

@@ -2,6 +2,69 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.11.13] - 2026-08-09
+
+### Fixed — the reply shortener discarded 4 of every 6 rewrites
+
+A keyword check counted question marks, file paths and numbers, and threw the
+whole rewrite away if a count dropped. Almost every rejection was the same
+thing: the writer had asked *himself* a question ("Now the proof: does it
+fire?"), the rewrite correctly cut it as narration, and the check saw a question
+disappear. So a working shortener never once delivered.
+
+Counting punctuation cannot tell an ask from thinking out loud. A reader can.
+The same model now reads its own short version back against two questions — is
+this only what he needs, and is it as short as his rules demand — and **fixes**
+it. The reviewer returns text, never a verdict, so nothing is ever discarded. A
+failed review keeps the first pass's rewrite rather than losing it.
+
+Both passes now carry the relevance rule: keep only what changes what he
+decides, does next, or now knows.
+
+Measured on the reply that failed 4 of 6 before: **6 of 6 delivered, zero
+discarded, 236 words down to 75-158.** Two Sonnet calls, 12-45s.
+
+- `bin/gsd-t-concise-rewrite.cjs`: the check is gone; a review pass replaces it
+- `test/m107-concise-rewrite.test.js`: 6 tests, including that the check cannot come back
+
+## [5.11.12] - 2026-08-09
+
+### Fixed — a retired command stayed typeable forever
+
+Installing only ever copied, so a command retired in a past milestone never left
+the machine. Eleven were still typeable long after the code behind them was
+deleted — brainstorm, discuss and prompt (M38), the unattended trio and
+visualize (M61). A command that still answers is one a person will reasonably
+use; this surfaced when `/gsd-t-brainstorm` was treated as live and turned out
+to have no source at all.
+
+Install now deletes GSD-T commands the package no longer ships and NAMES each
+one. Only `gsd-t-*.md` is considered, so a command you wrote is never touched.
+An unreadable commands directory stops the install rather than reporting a clean
+pass over a check that never ran.
+
+README advertised five commands that do not exist while `help.md` correctly
+called them retired — the two disagreed, and the README is what a reader
+believes.
+
+### Changed — /last30days is the first stop for an outside fact
+
+Wired into the external-fact rule, the conversation-scope rule, and the
+architect's research step. It searches where people report what actually
+happened — Reddit, Hacker News, X, YouTube transcripts, GitHub — ranked by what
+they engaged with, which is what those stages are asking for and what no
+training data holds. About 40 seconds; web search remains the follow-up. Not
+installed means SAY so in one line and use web search — never silently research
+a thinner way.
+
+Install it with `/plugin marketplace add mvanhorn/last30days-skill` then
+`/plugin install last30days`.
+
+- `bin/gsd-t.js`: retired commands are removed and named
+- `README.md`: five dead command rows removed
+- `commands/gsd-t-architect.md`, `templates/CLAUDE-global.md`: the research wiring
+- `test/m112-retired-commands.test.js`: 5 tests, including that the README advertises nothing it does not ship
+
 ## [5.11.11] - 2026-08-09
 
 ### Fixed — the reply shortener was shortening itself

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.11.11** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.11.13** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
 
 **Eliminates context rot** — task-level fresh dispatch (one subagent per task, ~10-20% context each) means compaction never triggers.
 **Compaction-proof debug loops** — `gsd-t headless --debug-loop` runs test-fix-retest cycles as separate `claude -p` sessions. A JSONL debug ledger persists all hypothesis/fix/learning history across fresh sessions. Anti-repetition preamble injection prevents retrying failed hypotheses. Escalation tiers (sonnet → opus → human) and a hard iteration ceiling enforced externally.
@@ -17,7 +17,6 @@
 **Real-Time Agent Dashboard** — `gsd-t-stream-feed-server.js` serves a streaming UI at `127.0.0.1:7842` that renders all workers' stream-json output as a continuous feed with task/wave banners, duration + usage chips, token corner bar, localStorage filters, and replay via `WS /feed?from=N`. Dashboard auto-starts idempotently on each spawn (`scripts/gsd-t-dashboard-autostart.cjs`). Port is project-scoped via `projectScopedDefaultPort(projectDir)` so multi-project workflows do not clobber each other.
 **Rigorous User-Journey Coverage + Anti-Drift Test Quality** — `bin/journey-coverage.cjs` regex listener detector + `gsd-t check-coverage` CLI + `scripts/hooks/pre-commit-journey-coverage` commit gate blocks viewer-source commits when uncovered listeners exist. Journey specs in `e2e/journeys/` use functional assertions (zero `toBeVisible`-only tests) per the E2E Test Quality Standard in CLAUDE.md.
 **Universal Playwright Bootstrap + Deterministic UI Enforcement (M50)** — three executable enforcement layers: (1) `bin/playwright-bootstrap.cjs` + `bin/ui-detection.cjs` - idempotent installer detects package manager, installs `@playwright/test` + chromium, scaffolds `e2e/`; (2) Workflow runtime runs `playwright-bootstrap.cjs::installPlaywright()` before any E2E stage when `hasUI && !hasPlaywright`; install failure halts with `blocked-needs-human`; (3) `scripts/hooks/pre-commit-playwright-gate` (opt-in via `gsd-t doctor --install-hooks`) blocks viewer-source commits when staged files are newer than `.gsd-t/.last-playwright-pass`. The `gsd-t setup-playwright [path]` subcommand handles manual install.
-**Visualizer (`/gsd-t-visualize`)** — launches a real-time browser dashboard with dual-pane view: top pane streams the main session, bottom pane streams whichever spawn the user clicks. Left rail shows Live Spawns and Completed (last 100 spawns, status-badged, collapsible). Right rail shows Spawn Plan / Parallelism / Tool Cost. Powered by `gsd-t-stream-feed-server.js` + `gsd-t-dashboard.html`.
 **Surgical model selection** — models are assigned haiku/sonnet/opus per phase (**Fable removed 2026-07-24**; `opus` = **claude-opus-5**). **Single-source tier policy:** `bin/gsd-t-model-tier-policy.cjs` is the SINGLE source of truth; every high-stakes stage (solution-space probe, partition probe, competition judge, pre-mortem, Red Team, competition producers, debug both cycles) runs Opus 5. Opus 5 shipped at the same price as Opus 4.8 but >2× its coding score, so Fable's cost premium is no longer justified. The M82 judge-blindness invariant is relaxed to "fresh independent context" — producers and judge both run opus. Drift is mechanically enforced by the M71-family lint (`test/m85-workflow-tier-policy-lint.test.js`). **M86 model profiles:** `bin/gsd-t-model-profile.cjs` adds a per-project SECOND dimension — three named profiles (`standard` / `pro` / `premium`) that dial which stages run on Opus vs. Sonnet.
 **Token Telemetry** — `gsd-t-calibration-hook.js` records token usage per spawn to `.gsd-t/token-metrics.jsonl` (18-field rows). `gsd-t-token-aggregator.js` aggregates across tasks for the `/gsd-t-metrics` view. Use the native Claude Code `/context` command for live in-session context percentage.
 **Quality North Star** — projects define a `## Quality North Star` section in CLAUDE.md (1–3 sentences, e.g., "This is a published npm library. Every public API must be intuitive and backward-compatible."). `gsd-t-init` auto-detects preset (library/web-app/cli) from package.json signals; `gsd-t-setup` configures it for existing projects. Subagents read it as a quality lens; absent = silent skip (backward compatible).
@@ -135,7 +134,7 @@ gsd-t model-profile resolve --profile <p> [stage] [--json] # Resolve a profile i
 
 **Plan Hardening (M83).** The `plan` phase now runs two blocking gates before execute, so a plan can't ship a dead deliverable: a deterministic **acceptance-traceability gate** (`gsd-t traceability-gate` — every AC must bind to a code path + a killing test; the headline capability needs both impl and test) and an adversarial **pre-mortem** agent (opus, fresh-context, predicts edge-case/NFR/dead-deliverable failures and requires a test for each). The temporal dual of the Red Team — attack the design at plan, not just the code at verify. Origin: a build where the headline capability shipped as dead code and burned 4 verify cycles. See `.gsd-t/contracts/plan-hardening-contract.md`.
 
-**Competition Mode (M82 · automatic since M84).** On upstream, pre-contract phases (`/gsd-t-partition`, `/gsd-t-milestone`, `/gsd-t-discuss`, `/gsd-t-design-decompose`) the workflow **automatically decides** whether to compete: an Opus solution-space probe runs at phase start and, if it finds ≥2 genuinely different viable approaches, fans out 3 parallel candidate producers + a judge to pick the winner — the generative dual of the orthogonal validation triad. No flag needed (the probe is biased toward competing, since a better upstream artifact lowers total downstream cost). Partition's judge is an *objective* file-disjointness oracle; subjective phases use a blind + different-model + rubric judge. Override with `--no-competition` or `--competition N` only on explicit request. See `.gsd-t/contracts/competition-mode-contract.md`.
+**Competition Mode (M82 · automatic since M84).** On upstream, pre-contract phases (`/gsd-t-partition`, `/gsd-t-milestone`, `/gsd-t-design-decompose`) the workflow **automatically decides** whether to compete: an Opus solution-space probe runs at phase start and, if it finds ≥2 genuinely different viable approaches, fans out 3 parallel candidate producers + a judge to pick the winner — the generative dual of the orthogonal validation triad. No flag needed (the probe is biased toward competing, since a better upstream artifact lowers total downstream cost). Partition's judge is an *objective* file-disjointness oracle; subjective phases use a blind + different-model + rubric judge. Override with `--no-competition` or `--competition N` only on explicit request. See `.gsd-t/contracts/competition-mode-contract.md`.
 
 `gsd-t parallel` consumes the M44 task-graph (D1) and applies three pre-spawn gates (D4 depgraph validation → D5 file-disjointness → D6 economics) followed by mode-aware headroom/split math. Extends — does not replace — the M40 orchestrator. Contract: `.gsd-t/contracts/wave-join-contract.md` v1.1.0.
 
@@ -171,8 +170,6 @@ This will replace changed command files, back up your CLAUDE.md if customized, a
 |---------|---------|------|
 | `/gsd-t-help` | List all commands with descriptions | Manual |
 | `/gsd-t-help {cmd}` | Detailed help for specific command | Manual |
-| `/gsd-t-prompt` | Help formulate your idea before committing | Manual |
-| `/gsd-t-brainstorm` | Creative exploration and idea generation | Manual |
 | `/gsd-t-prd` | Generate a GSD-T-optimized Product Requirements Document | Manual |
 
 ### Project Initialization
@@ -218,7 +215,6 @@ This will replace changed command files, back up your CLAUDE.md if customized, a
 | `/gsd-t-status` | Cross-domain progress view with token breakdown by domain/task/phase | Manual |
 | `/gsd-t-resume` | Restore context, continue | Manual |
 | `/gsd-t-quick` | Fast task with GSD-T guarantees | Manual |
-| `/gsd-t-visualize` | Launch browser dashboard — SSE server + React Flow agent visualization | Manual |
 | `/gsd-t-debug` | Systematic debugging with state | Manual |
 | `/gsd-t-metrics` | View task telemetry, process ELO, signal distribution, domain health, and cross-project comparison (`--cross-project`) | Manual |
 | `/gsd-t-health` | Validate .gsd-t/ structure, optionally repair | Manual |
@@ -395,7 +391,7 @@ The session default model (`/model`) is unaffected — profiles govern workflow
 
 ## Unattended / Background Runs
 
-For zero-touch overnight or multi-hour runs, use the `/loop` skill with a GSD-T command, or the `/gsd-t-unattended` skill (via the Smart Router). State is written atomically to `.gsd-t/.unattended/state.json` between worker iterations.
+For zero-touch overnight or multi-hour runs, use the `/loop` skill with a GSD-T command. (The `/gsd-t-unattended` relay was retired in M61.)
 
 The supervisor halts automatically when: the milestone reaches COMPLETED status, the wall-clock cap expires, `--max-iterations` is reached, safety rails detect a stall or unrecoverable error, or the stop sentinel is touched.
 

package/bin/gsd-t-concise-rewrite.cjs

@@ -59,16 +59,24 @@ Rewrite the reply below following these rules exactly:
    answering a direct question about that. He asks when he wants it.
 4. NO JARGON. Plain words. If a technical term is genuinely needed, put the
    plain meaning first and the term in brackets after it.
-5. CUT ANYTHING NOT ASKED FOR.
+5. KEEP ONLY WHAT IS RELEVANT TO HIM. Ask of every sentence: does this change
+   what he decides, what he does next, or what he now knows? If not, cut it.
+   Work the writer did, steps taken, what was checked, what was ruled out — all
+   of that is the writer's business, not his, unless he asked.
 6. Prefer a short list or a small table over a paragraph.
 
 KEEP THESE. They are not optional, and dropping any one of them means the
 rewrite is rejected and thrown away:
 
 - The first line, if it is a dated status banner.
-- EVERY question being asked of the reader. If the reply ends by asking him
-  something, that question MUST appear in your rewrite, as its own line, at
-  the end. This is the single most common way a rewrite is rejected.
+- EVERY question being asked OF THE READER — one he is meant to answer. If the
+  reply ends by asking him something, that question MUST appear in your rewrite,
+  as its own line, at the end. This is the single most common way a rewrite is
+  rejected.
+  A question the writer asks HIMSELF is not one of these. "Is that the cause?",
+  "Now the proof: does the hook fire?", "So what is slow here?" are thinking out
+  loud — cut them like any other narration. The test is simple: would he type an
+  answer to it? If not, it is not a question.
 - Any warning, failure, or thing that went wrong.
 - File paths and links, exactly as written.
 - Code blocks, exactly as written.
@@ -99,46 +107,46 @@ function wordCount(s) {
 }
 
 /**
- * Facts that must survive the rewrite. If any disappears, the rewrite is
- * rejected and the original is returned — a rewrite that drops a warning or a
- * question is worse than a long reply.
+ * The second pass — the rewrite reviewed before it is delivered.
+ *
+ * A keyword check used to sit here: it counted question marks, file paths and
+ * numbers, and threw the whole rewrite away if a count dropped. It discarded
+ * 4 of every 6 rewrites, almost always because the writer had asked HIMSELF a
+ * question ("Now the proof: does it fire?") which the rewrite correctly cut as
+ * narration. Counting punctuation cannot tell an ask from thinking out loud.
+ *
+ * A reader can. So the same model that wrote the short version now reads it
+ * back against one question — is this what David needs, and is it as short as
+ * his rules demand — and fixes it. The reviewer returns text, never a verdict,
+ * so there is no path on which the work is discarded.
  */
-function extractInvariants(text) {
-  return {
-    questions: (text.match(/[^.!?\n]*\?/g) || []).map((q) => q.trim()).filter((q) => q.length > 10),
-    numbers: text.match(/\b\d[\d,._]*\b/g) || [],
-    paths: text.match(/[\w./-]+\.(?:js|cjs|mjs|ts|tsx|json|md|py|sh)\b/g) || [],
-    codeBlocks: (text.match(/```/g) || []).length / 2,
-  };
-}
+const REVIEW = `You are checking a shortened reply before it reaches David.
 
-function checkInvariants(original, rewritten) {
-  const a = extractInvariants(original);
-  const b = extractInvariants(rewritten);
-  const lost = [];
+He is a slow reader. Every extra line costs him real time.
 
-  if (a.questions.length > 0 && b.questions.length === 0) {
-    lost.push("a question to the reader was dropped");
-  }
-  const lostPaths = a.paths.filter((p) => !rewritten.includes(p));
-  if (lostPaths.length > 0 && lostPaths.length === a.paths.length && a.paths.length > 0) {
-    lost.push("every file path was dropped");
-  }
-  if (a.codeBlocks > 0 && b.codeBlocks < a.codeBlocks) {
-    lost.push("a code block was dropped");
-  }
-  // A number appearing in the rewrite that was never in the original means
-  // something was invented.
-  const invented = b.numbers.filter((n) => n.length > 2 && !a.numbers.includes(n));
-  if (invented.length > 0) {
-    lost.push(`a number appeared that was not in the original: ${invented[0]}`);
-  }
-  return lost;
-}
+Two questions, both about the SHORT version:
 
-/** Ask a fresh Claude to do the rewrite. */
-function rewrite(text, cfg) {
-  const prompt = `${RULES}\n\n--- REPLY TO REWRITE ---\n${text}`;
+1. Is this ONLY what he needs? Cut anything that does not change what he
+   decides, what he does next, or what he now knows. The work someone did,
+   steps taken, what was checked, what was ruled out — his business only if he
+   asked.
+
+2. Is it truly concise by his rules? Answer first, nothing before it. No
+   preamble, no backstory, no jargon standing in for a plain word. Lists and
+   small tables over paragraphs.
+
+Then check nothing was lost that he needs:
+- a question he is meant to ANSWER must still be there, as its own line at the
+  end. A question the writer asked himself is narration — it should be gone.
+- warnings, failures, and things that went wrong stay.
+- file paths, links, code blocks and specific numbers stay exactly as written.
+- no fact, number or name may change, and nothing may be added.
+
+Return the final reply and nothing else. If it is already right, return it
+unchanged. Never return commentary, never return an empty response.`;
+
+/** One call to a fresh Claude. Used by both passes. */
+function askClaude(prompt, cfg) {
   // `--setting-sources project` is what stops the shortener shortening itself.
   //
   // A child started with the personal settings inherits the very Stop hook that
@@ -181,6 +189,25 @@ function rewrite(text, cfg) {
   return { ok: true, text: out };
 }
 
+/** Pass 1 — shorten it. */
+function rewrite(text, cfg) {
+  return askClaude(`${RULES}\n\n--- REPLY TO REWRITE ---\n${text}`, cfg);
+}
+
+/**
+ * Pass 2 — read the short version back and fix what pass 1 got wrong.
+ *
+ * Returns text, never a verdict, so the work is never discarded. If the review
+ * itself fails, pass 1's rewrite stands: it was already an improvement, and
+ * losing it because a second opinion did not arrive would be the old bug in a
+ * new place.
+ */
+function review(original, shortened, cfg) {
+  const prompt = `${REVIEW}\n\n--- WHAT HE ORIGINALLY WROTE (for reference only) ---\n${original}\n\n--- THE SHORT VERSION TO CHECK AND RETURN ---\n${shortened}`;
+  const r = askClaude(prompt, cfg);
+  return r.ok ? r.text : shortened;
+}
+
 function parseArgs(argv) {
   const args = { project: process.cwd() };
   for (let i = 2; i < argv.length; i++) {
@@ -231,19 +258,14 @@ function main() {
     }, args.json);
   }
 
-  const lost = checkInvariants(text, r.text);
-  if (lost.length > 0) {
-    emit({
-      ok: false, exitCode: EXIT_FAILED, text,
-      error: `the rewrite lost something: ${lost.join("; ")}`,
-      note: "Rewrite rejected — this is the original, unchanged.",
-      words: before,
-    }, args.json);
-  }
+  // Second pass: the same model reads its own short version back, against the
+  // only two questions that matter — is this what David needs, and is it as
+  // short as his rules demand. It returns text, so nothing is ever discarded.
+  const finalText = review(text, r.text, cfg);
 
-  const after = wordCount(r.text);
+  const after = wordCount(finalText);
   emit({
-    ok: true, exitCode: EXIT_OK, text: r.text,
+    ok: true, exitCode: EXIT_OK, text: finalText,
     words: before, wordsAfter: after,
     saved: before - after,
   }, args.json);
@@ -251,4 +273,4 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { wordCount, extractInvariants, checkInvariants, readConfig, RULES };
+module.exports = { wordCount, readConfig, rewrite, review, askClaude, RULES, REVIEW };

package/bin/gsd-t.js

@@ -2092,9 +2092,45 @@ function installCommands(isUpdate) {
 
   if (skipped > 0) info(`${skipped} commands unchanged`);
   success(`${gsdtCommands.length} GSD-T commands + ${utilityCommands.length} utilities ${isUpdate ? "updated" : "installed"} → ~/.claude/commands/`);
+
+  removeRetiredCommands(commandFiles);
+
   return { gsdtCommands, utilityCommands };
 }
 
+/**
+ * Delete GSD-T commands the package no longer ships.
+ *
+ * Installing only ever copied, so a command retired in a past milestone stayed
+ * on disk forever: eleven were still typeable long after the code behind them
+ * was deleted — brainstorm, discuss and prompt retired in M38, the unattended
+ * trio and visualize in M61. A command that still answers is one a person will
+ * reasonably use, and it then fails in confusing ways.
+ *
+ * Only `gsd-t-*.md` files are considered, so a command the user wrote is never
+ * touched. Every removal is NAMED, and anything that cannot be read or deleted
+ * STOPS the install: a leftover command is exactly the failure being fixed, so
+ * reporting a clean install while one remains would restate the bug.
+ */
+function removeRetiredCommands(shipped) {
+  const shippedSet = new Set(shipped);
+  // No try/catch: an unreadable commands directory means the check cannot run,
+  // and an install that skipped it must not report success.
+  const present = fs.readdirSync(COMMANDS_DIR);
+
+  const retired = present.filter(
+    (f) => f.startsWith("gsd-t-") && f.endsWith(".md") && !shippedSet.has(f)
+  );
+  if (retired.length === 0) return;
+
+  for (const file of retired) {
+    fs.unlinkSync(path.join(COMMANDS_DIR, file));
+  }
+
+  info(`Removed ${retired.length} retired command(s) no longer shipped:`);
+  for (const f of retired) info(`    ${f.replace(/\.md$/, "")}`);
+}
+
 const GSDT_START = "<!-- GSD-T:START";
 const GSDT_END = "<!-- GSD-T:END";
 

package/commands/gsd-t-architect.md

@@ -184,6 +184,14 @@ platform behavior, known-good patterns, known failure modes, anything time-varyi
 assert from memory. Cite what you find (URL + date) per the auto-research rule; a time-varying
 external fact stated without a source is a guess.
 
+**Reach for `/last30days <topic>` FIRST, before a plain web search.** It searches where people
+actually report what happened — Reddit, Hacker News, X, YouTube transcripts, GitHub — and ranks by
+what they engaged with, so it surfaces the known failure modes and "we tried this and regretted it"
+threads a web search buries. That is exactly what this stage is asking for, and none of it is in
+the model's training data. It takes about 40 seconds; a plain web search remains the follow-up when
+the answer is a single settled fact it did not return. If the command is not installed, say so in
+one line and fall back to web search — do NOT silently research a thinner way.
+
 **When research contradicts a standing rule (e.g. the common solution uses a fallback, the project
 bans fallbacks): the user's rule wins, and you name the conflict in ONE line.** Not a debate:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.11.11",
+  "version": "5.11.13",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

package/templates/CLAUDE-global.md

@@ -429,7 +429,7 @@ For every load-bearing claim, tag it:
 - **`[GUESSED:stale]`** — external/time-varying fact that may have changed.
 
 A `[GUESSED:*]` claim is then CLASSIFIED — mechanical string-fact filter, three classes:
-- **`class: external`** → research agent (`model: "opus"`) writes a `## Verified Facts (auto-research)` block (URL + fetch date); ENFORCE marker `<!-- auto-research-claim: class=external key=<key> status=uncited -->` is written; verify FAILs if it stays `status=uncited` (R-FAIL-1).
+- **`class: external`** → research agent (`model: "opus"`) writes a `## Verified Facts (auto-research)` block (URL + fetch date); ENFORCE marker `<!-- auto-research-claim: class=external key=<key> status=uncited -->` is written; verify FAILs if it stays `status=uncited` (R-FAIL-1). **Try `/last30days <topic>` FIRST, then web search.** It searches where people report what actually happened — Reddit, Hacker News, X, YouTube transcripts, GitHub — ranked by what they engaged with, so it surfaces current behavior, gotchas and failure modes that a web search buries and that no model's training data holds. ~40 seconds. Cite what it returns the same way (URL + date). If it is not installed, SAY so in one line and use web search — never silently research a thinner way.
 - **`class: internal`** → grep/Read only; escalate to external if grep empty.
 - **`class: ambiguous`** → LLM judge (`model: "opus"`) decides; uncertain → research (never guess-internal).
 
@@ -449,6 +449,8 @@ Debug workflow calls `append-cycle` each iteration. When the SAME computed sympt
 (API behavior, library version, pricing, rate limits, current best-practice), verify-or-flag before
 asserting. If you lack a fresh source, say so explicitly: *"I believe X, but I do not have a current
 source — please verify."* Do NOT state an external/time-varying fact as known when it is a guess.
+**`/last30days <topic>` is the first place to look** — it reports what people have actually hit
+recently rather than what was written up, which is usually what the question is really asking.
 See memory pointer: `feedback_auto_research_external_gaps`.
 
 ### Architect's Oversight Doctrine (M101 — governed, enforced)