instar 1.3.1149 → 1.3.1151

package/dist/data/standards-guard-index.json

@@ -2,7 +2,7 @@
   "schemaVersion": 1,
   "generatedFrom": "source-tree",
   "registrySha256": "81b53363a440e832672618965540b3e507ae0d93adcc67ec2b93daf7933b3ab4",
-  "packageVersion": "1.3.1149",
+  "packageVersion": "1.3.1151",
   "guards": [
     {
       "ref": "docs/audits/phase-b/f10-triage.md",

package/dist/data/standards-guard-index.meta.json

@@ -1,5 +1,5 @@
 {
-  "sha256": "1ed8f5bd6959a002ef362c9be5f88a382b0956d4992b16879350851ce3711ac9",
+  "sha256": "2781a4e62937b5faedcefb2635981134a4f27ba058786b5d16b5017f41b017e9",
   "registrySha256": "81b53363a440e832672618965540b3e507ae0d93adcc67ec2b93daf7933b3ab4",
-  "packageVersion": "1.3.1149"
+  "packageVersion": "1.3.1151"
 }

package/dist/data/standards-registry.meta.json

@@ -2,5 +2,5 @@
   "sha256": "81b53363a440e832672618965540b3e507ae0d93adcc67ec2b93daf7933b3ab4",
   "articleCount": 88,
   "generatedFrom": "docs/STANDARDS-REGISTRY.md",
-  "packageVersion": "1.3.1149"
+  "packageVersion": "1.3.1151"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "1.3.1149",
+  "version": "1.3.1151",
   "description": "Coherence infrastructure for self-evolving AI agents — on the Claude Code or Codex subscription you already have.",
   "type": "module",
   "main": "dist/index.js",

package/scripts/lint-no-unfunneled-topic-creation.js

@@ -64,6 +64,86 @@ const PATTERNS = [
   /method\s*:\s*['"`]createForumTopic['"`]/,
 ];
 
+// ── Name resolution (added 2026-08-15) ────────────────────────────────────
+// The three patterns above each require `createForumTopic` as a string
+// LITERAL adjacent to the seam. Measured against the shipped lint, all three
+// of these reach the Bot API and NONE were caught:
+//
+//   const M = 'createForumTopic'; apiCall(M, {...});
+//   apiCall('createForum' + 'Topic', {...});
+//   const M = 'createForumTopic'; ({ method: M, ... });
+//
+// None of that is evasive — lifting a repeated string into a named constant
+// is ordinary tidying. Someone could step around the notification-flood
+// ceiling while making code NICER, and this lint would say `clean`. So the
+// method name is RESOLVED before the existing rules are applied; the rules
+// themselves are unchanged, they simply see through one level of naming.
+//
+// Deliberately NOT a parser. Everything below is bounded, per-file, and
+// fails toward NOT flagging, because this lint blocks commits and a check
+// that flags correct code gets switched off — which would cost more than the
+// hole it closes.
+
+const METHOD = 'createForumTopic';
+
+/**
+ * Fold ADJACENT string literals only: `'a' + 'b'` -> `'ab'`.
+ * Never invents text and never folds across an identifier, so
+ * `'createForum' + suffix` stays unresolved rather than guessed at.
+ */
+export function foldAdjacentLiterals(text) {
+  let out = text;
+  for (let i = 0; i < 5; i++) {
+    const next = out.replace(
+      /(['"`])([^'"`\n]*)\1\s*\+\s*(['"`])([^'"`\n]*)\3/g,
+      (_m, q, a, _q2, b) => `${q}${a}${b}${q}`,
+    );
+    if (next === out) break;
+    out = next;
+  }
+  return out;
+}
+
+/**
+ * Identifiers bound to a string literal (after folding) in THIS file.
+ * An identifier bound more than once to DIFFERENT values is UNRESOLVABLE and
+ * is dropped, so an ambiguous name can never be substituted into a match.
+ */
+export function collectStringConsts(lines) {
+  const seen = new Map();
+  const conflicting = new Set();
+  const DECL = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([^;]+)/;
+  for (const line of lines) {
+    const m = DECL.exec(line);
+    if (!m) continue;
+    const name = m[1];
+    const folded = foldAdjacentLiterals(m[2].trim());
+    const lit = /^(['"`])([^'"`\n]*)\1\s*$/.exec(folded);
+    if (!lit) continue;
+    const value = lit[2];
+    if (seen.has(name) && seen.get(name) !== value) conflicting.add(name);
+    else seen.set(name, value);
+  }
+  for (const name of conflicting) seen.delete(name);
+  return seen;
+}
+
+/**
+ * Produce a view of one line with the method name resolved, for matching only.
+ * Substitution happens ONLY in the two seam positions the rules look at —
+ * never globally — so an unrelated identifier sharing a value is untouched.
+ */
+export function resolveLine(line, consts) {
+  let out = foldAdjacentLiterals(line);
+  out = out.replace(/(apiCall\(\s*)([A-Za-z_$][\w$]*)/g, (m, head, name) =>
+    consts.get(name) === METHOD ? `${head}'${METHOD}'` : m,
+  );
+  out = out.replace(/(method\s*:\s*)([A-Za-z_$][\w$]*)/g, (m, head, name) =>
+    consts.get(name) === METHOD ? `${head}'${METHOD}'` : m,
+  );
+  return out;
+}
+
 function listFiles() {
   const staged = process.argv.includes('--staged');
   if (staged) {
@@ -94,36 +174,54 @@ function listFiles() {
   return files;
 }
 
-let violations = 0;
-for (const rel of listFiles()) {
-  const normalized = rel.split(path.sep).join('/');
-  if (ALLOWLIST.has(normalized)) continue;
-  if (!EXTENSIONS.has(path.extname(normalized))) continue;
-  const full = path.join(ROOT, normalized);
-  let content;
-  try {
-    content = fs.readFileSync(full, 'utf-8');
-  } catch {
-    continue;
-  }
+export function scanFile(normalized, content) {
   const lines = content.split('\n');
+  const consts = collectStringConsts(lines);
+  const hits = [];
   for (let i = 0; i < lines.length; i++) {
+    const resolved = resolveLine(lines[i], consts);
     for (const pattern of PATTERNS) {
-      if (pattern.test(lines[i])) {
-        console.error(
-          `${normalized}:${i + 1} — raw createForumTopic invocation outside the budgeted funnel. ` +
-          `Route through TelegramAdapter.createForumTopic / findOrCreateForumTopic (declare an origin/label), ` +
-          `or add an allowlist entry here with a bounded-volume justification.`,
-        );
-        violations++;
-      }
+      if (pattern.test(resolved)) hits.push({ file: normalized, line: i + 1 });
     }
   }
+  return hits;
 }
 
-if (violations > 0) {
-  console.error(`\nlint-no-unfunneled-topic-creation: ${violations} violation(s). ` +
-    `See docs/STANDARDS-REGISTRY.md "Bounded Notification Surface".`);
-  process.exit(1);
+function runLint() {
+  let violations = 0;
+  for (const rel of listFiles()) {
+    const normalized = rel.split(path.sep).join('/');
+    if (ALLOWLIST.has(normalized)) continue;
+    if (!EXTENSIONS.has(path.extname(normalized))) continue;
+    const full = path.join(ROOT, normalized);
+    let content;
+    try {
+      content = fs.readFileSync(full, 'utf-8');
+    } catch {
+      continue;
+    }
+    for (const hit of scanFile(normalized, content)) {
+      console.error(
+        `${hit.file}:${hit.line} — raw createForumTopic invocation outside the budgeted funnel. ` +
+        `Route through TelegramAdapter.createForumTopic / findOrCreateForumTopic (declare an origin/label), ` +
+        `or add an allowlist entry here with a bounded-volume justification.`,
+      );
+      violations++;
+    }
+  }
+
+  if (violations > 0) {
+    console.error(`\nlint-no-unfunneled-topic-creation: ${violations} violation(s). ` +
+      `See docs/STANDARDS-REGISTRY.md "Bounded Notification Surface".`);
+    process.exit(1);
+  }
+  console.log('lint-no-unfunneled-topic-creation: clean');
 }
-console.log('lint-no-unfunneled-topic-creation: clean');
+
+// DIRECT-INVOCATION GUARD. Without this, importing this module to unit-test the
+// resolution helpers runs the whole repo scan — and calls process.exit(1) the
+// moment the repo has a real violation, killing the test runner. Three other
+// lints hit exactly that this window; the guard is the same fix.
+const invokedDirectly =
+  process.argv[1] && path.resolve(process.argv[1]) === path.resolve(__filename);
+if (invokedDirectly) runLint();

package/scripts/lint-no-unreachable-messaging-gate.js

@@ -42,14 +42,160 @@ export const UNREACHABLE_OFF_GATE =
 
 const SUPPRESS = /lint-allow-messaging-gate\s*:/;
 
+function stripCommentsPreserveLines(text) {
+  let out = '';
+  let inBlock = false;
+  let quote = null;
+
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    const next = text[i + 1];
+
+    if (inBlock) {
+      if (ch === '*' && next === '/') {
+        out += '  ';
+        i += 1;
+        inBlock = false;
+      } else {
+        out += ch === '\n' ? '\n' : ' ';
+      }
+      continue;
+    }
+
+    if (quote) {
+      out += ch;
+      if (ch === '\\' && i + 1 < text.length) {
+        out += text[i + 1];
+        i += 1;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+
+    if (ch === '/' && next === '/') {
+      out += '  ';
+      i += 1;
+      while (i + 1 < text.length && text[i + 1] !== '\n') {
+        out += ' ';
+        i += 1;
+      }
+      continue;
+    }
+
+    if (ch === '/' && next === '*') {
+      out += '  ';
+      i += 1;
+      inBlock = true;
+      continue;
+    }
+
+    if (ch === "'" || ch === '"' || ch === '`') quote = ch;
+    out += ch;
+  }
+
+  return out;
+}
+
+function skipWs(s, i) {
+  while (i < s.length && /\s/.test(s[i])) i += 1;
+  return i;
+}
+
+function parseStringLiteral(s, start) {
+  const quote = s[start];
+  if (quote !== "'" && quote !== '"' && quote !== '`') return null;
+
+  let value = '';
+  for (let i = start + 1; i < s.length; i += 1) {
+    const ch = s[i];
+    if (ch === '\\' && i + 1 < s.length) {
+      value += s[i + 1];
+      i += 1;
+      continue;
+    }
+    if (quote === '`' && ch === '$' && s[i + 1] === '{') return null;
+    if (ch === quote) return { value, end: i + 1 };
+    value += ch;
+  }
+  return null;
+}
+
+function parseLiteralConcat(s, start) {
+  let i = skipWs(s, start);
+  let parsed = parseStringLiteral(s, i);
+  if (!parsed) return null;
+
+  let value = parsed.value;
+  i = skipWs(s, parsed.end);
+  while (s[i] === '+') {
+    i = skipWs(s, i + 1);
+    parsed = parseStringLiteral(s, i);
+    if (!parsed) return null;
+    value += parsed.value;
+    i = skipWs(s, parsed.end);
+  }
+
+  return { value, end: i };
+}
+
+function getCallArgStartAt(s, start) {
+  if (!s.startsWith('.get', start)) return null;
+  if (/[$_\p{ID_Continue}]/u.test(s[start + 4] ?? '')) return null;
+
+  let i = skipWs(s, start + 4);
+  if (s[i] === '<') {
+    const close = s.indexOf('>', i + 1);
+    if (close === -1) return null;
+    i = skipWs(s, close + 1);
+  }
+  if (s[i] !== '(') return null;
+  return i + 1;
+}
+
+function lineHasUnreachableOffGate(line) {
+  let quote = null;
+  for (let i = 0; i < line.length; i += 1) {
+    const ch = line[i];
+    if (quote) {
+      if (ch === '\\' && i + 1 < line.length) {
+        i += 1;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+
+    if (ch === "'" || ch === '"' || ch === '`') {
+      quote = ch;
+      continue;
+    }
+
+    const firstArgStart = getCallArgStartAt(line, i);
+    if (firstArgStart === null) continue;
+
+    const firstArg = parseLiteralConcat(line, firstArgStart);
+    if (!firstArg || !firstArg.value.startsWith('messaging.')) continue;
+
+    let j = skipWs(line, firstArg.end);
+    if (line[j] !== ',') continue;
+    j = skipWs(line, j + 1);
+    if (line.startsWith('false', j) && !/[$_\p{ID_Continue}]/u.test(line[j + 5] ?? '')) {
+      return true;
+    }
+  }
+  return false;
+}
+
 /** Scan raw source text; return 1-indexed line numbers of un-suppressed offenders. */
 export function scanText(text) {
-  const lines = text.split('\n');
+  const lines = stripCommentsPreserveLines(text).split('\n');
+  const originalLines = text.split('\n');
   const hits = [];
   lines.forEach((line, i) => {
-    if (!UNREACHABLE_OFF_GATE.test(line)) return;
-    if (SUPPRESS.test(line)) return;
-    if (i > 0 && SUPPRESS.test(lines[i - 1])) return;
+    if (!lineHasUnreachableOffGate(line)) return;
+    if (SUPPRESS.test(originalLines[i])) return;
+    if (i > 0 && SUPPRESS.test(originalLines[i - 1])) return;
     hits.push(i + 1);
   });
   return hits;

package/src/data/builtin-manifest.json

@@ -1,8 +1,8 @@
 {
   "$schema": "./builtin-manifest.schema.json",
   "schemaVersion": 1,
-  "generatedAt": "2026-08-15T00:08:31.593Z",
-  "instarVersion": "1.3.1149",
+  "generatedAt": "2026-08-15T00:48:31.405Z",
+  "instarVersion": "1.3.1151",
   "entryCount": 202,
   "entries": {
     "hook:session-start": {

package/src/data/standards-guard-index.json

@@ -2,7 +2,7 @@
   "schemaVersion": 1,
   "generatedFrom": "source-tree",
   "registrySha256": "81b53363a440e832672618965540b3e507ae0d93adcc67ec2b93daf7933b3ab4",
-  "packageVersion": "1.3.1149",
+  "packageVersion": "1.3.1151",
   "guards": [
     {
       "ref": "docs/audits/phase-b/f10-triage.md",

package/src/data/standards-guard-index.meta.json

@@ -1,5 +1,5 @@
 {
-  "sha256": "1ed8f5bd6959a002ef362c9be5f88a382b0956d4992b16879350851ce3711ac9",
+  "sha256": "2781a4e62937b5faedcefb2635981134a4f27ba058786b5d16b5017f41b017e9",
   "registrySha256": "81b53363a440e832672618965540b3e507ae0d93adcc67ec2b93daf7933b3ab4",
-  "packageVersion": "1.3.1149"
+  "packageVersion": "1.3.1151"
 }

package/src/data/standards-registry.meta.json

@@ -2,5 +2,5 @@
   "sha256": "81b53363a440e832672618965540b3e507ae0d93adcc67ec2b93daf7933b3ab4",
   "articleCount": 88,
   "generatedFrom": "docs/STANDARDS-REGISTRY.md",
-  "packageVersion": "1.3.1149"
+  "packageVersion": "1.3.1151"
 }

package/upgrades/1.3.1150.md

@@ -0,0 +1,21 @@
+# Upgrade Guide — vNEXT
+
+<!-- assembled-by: assemble-next-md -->
+<!-- bump: patch -->
+
+## What Changed
+
+- Strengthened the unreachable messaging gate lint so it detects default-off `messaging.*` LiveConfig keys built from literal string concatenation.
+
+## What to Tell Your User
+
+None — internal change (no user-facing surface).
+
+## Summary of New Capabilities
+
+None — internal change (no user-facing surface).
+
+## Evidence
+
+- `npx vitest run tests/unit/lint-no-unreachable-messaging-gate.test.ts`
+- `node scripts/lint-no-unreachable-messaging-gate.js`

package/upgrades/1.3.1151.md

@@ -0,0 +1,62 @@
+# Upgrade Guide — vNEXT
+
+<!-- assembled-by: assemble-next-md -->
+<!-- bump: patch -->
+
+## What Changed
+
+`scripts/lint-no-unfunneled-topic-creation.js` now resolves the Telegram method name before applying
+its rules.
+
+That lint enforces the **Bounded Notification Surface** standard — the last-resort budget on
+automatically-created forum topics, added after the third topic-spam incident. Its three patterns each
+required `createForumTopic` as a string LITERAL adjacent to the seam, so all three of these reached the
+Bot API uncounted while the build reported `clean`:
+
+```js
+const M = 'createForumTopic'; apiCall(M, { name: 'x' });
+apiCall('createForum' + 'Topic', { name: 'x' });
+const M = 'createForumTopic'; ({ method: M, name: 'x' });
+```
+
+Measured against the shipped lint with a positive control (the bare literal) firing in the same run:
+control caught, all three EVADE.
+
+None of that is evasive — lifting a repeated string into a named constant is ordinary tidying. Someone
+could step around a notification-flood ceiling while making code *nicer*, and nothing would say a word.
+
+Added: `foldAdjacentLiterals` (folds `'a' + 'b'` only, never across an identifier),
+`collectStringConsts` (per-file identifier → literal; an identifier bound twice to different values is
+dropped as unresolvable), `resolveLine` (substitutes ONLY at the two seam positions), and `scanFile`
+(extracted so matching is testable). `PATTERNS`, `ALLOWLIST` and the violation message are unchanged.
+
+Also added: a **direct-invocation guard**. Importing this module previously ran the whole repo scan and
+called `process.exit(1)` on the first real violation, killing the importing process — which is why its
+internals had never been unit-tested. Three other lints hit the same hazard this week.
+
+## What to Tell Your User
+
+Nothing changes for you. A build-time check that stops features from creating unlimited Telegram topics
+could be walked past by giving a string a name first — an ordinary bit of tidying, not a trick. It now
+sees through that. Nothing you use behaves differently; a category of notification flood just got harder
+to ship by accident.
+
+## Summary of New Capabilities
+
+None. No new command, endpoint, setting, or runtime behaviour. A CI guard that was defeatable by a local
+constant is no longer defeatable by one.
+
+## Evidence
+
+- `tests/unit/topic-creation-lint-resolution.test.ts` — 18/18 green.
+- **Negative control: 5 of 18 fail** against the shipped matching behaviour; the other 13 pass both ways
+  and are the controls. Source restored byte-exact afterwards (sha match, zero markers left).
+- Six anti-over-block controls, because this lint blocks commits: a const bound elsewhere, an identifier
+  that never reaches a seam, an identifier with conflicting bindings, a concatenation involving an
+  identifier, a longer look-alike method name, and seam-local (not global) substitution.
+- Real tree: `exit 0` before AND after — no new flags on existing code.
+- Full `npm run lint` chain green (57 steps); lint-chain membership verified explicitly rather than
+  inferred from a `package.json` reference.
+- **Declared open in the source:** cross-module names, runtime-built names, and anything needing
+  dataflow. Also named: the lint does not strip comments, which is pre-existing and neither fixed nor
+  worsened here.

package/upgrades/side-effects/lint-split-key-messaging-gate.md

@@ -0,0 +1,117 @@
+# Side-Effects Review - Split-Key Messaging Gate Lint
+
+**Version / slug:** `lint-split-key-messaging-gate`
+**Date:** `2026-08-14`
+**Author:** `Instar-codey`
+**Second-pass reviewer:** `Locke`
+
+## Summary of the change
+
+This change strengthens `scripts/lint-no-unreachable-messaging-gate.js` so the existing unreachable default-off `messaging.*` LiveConfig lint also recognizes first-argument string literals joined with `+`, for example `liveConfig.get('messaging.' + 'actionClaim.enabled', false)`. The focused unit test file `tests/unit/lint-no-unreachable-messaging-gate.test.ts` now covers the reproduced split-key miss and the required controls. The release fragment is `upgrades/next/lint-split-key-messaging-gate.md`. Build location was a fresh worktree at `.worktrees/codey-lint-split-key-messaging-gate` on `JKHeadley/instar`, version `1.3.1146`, branched from current `origin/main`.
+
+## Decision-point inventory
+
+- `scripts/lint-no-unreachable-messaging-gate.js` - modify - build-time decision that flags source lines where `LiveConfig.get` uses a `messaging.*` key with literal `false` default.
+- Release note internal-only classification - pass-through - this is a script/test/docs-only change with no shipped `src/` runtime surface.
+
+---
+
+## 1. Over-block
+
+The main legitimate input risk is a dynamic backtick template such as `` liveConfig.get(`messaging.${featureKey}`, false) `` being treated as a constant key. The implementation rejects template expressions during literal parsing, and the unit suite includes that negative control. Second-pass review also found that the first implementation could flag a `.get(...)` example embedded inside another string literal; the scanner now only recognizes `.get` tokens outside ordinary string literal text, and a regression test covers `const example = "liveConfig.get('messaging.' + 'actionClaim.enabled', false)"`. A literal-concat non-messaging key such as `liveConfig.get('monitoring.' + 'burnDetection.enabled', false)` is explicitly covered and remains accepted. A default-true split key remains accepted because the lint is specifically about default-off gates staying unreachable.
+
+---
+
+## 2. Under-block
+
+The lint still misses non-literal construction such as `liveConfig.get('messaging.' + featureKey, false)` or helper-returned keys. That is intentional for this change: widening into dataflow or general expression evaluation would raise false-positive risk and would be a different guard. The known reproduced bypass is literal-plus-literal construction, and that class is now covered.
+
+---
+
+## 3. Level-of-abstraction fit
+
+This is the right layer for the fix. The problem is a static source spelling that hides an unreachable configuration key. A build lint can catch the enumerable literal shape cheaply before release. A runtime gate would be later, noisier, and would still allow dead code to ship. The implementation uses a narrow scanner rather than general JavaScript evaluation, which fits the lint's existing design.
+
+---
+
+## 4. Signal vs authority compliance
+
+**Required reference:** [docs/signal-vs-authority.md](../../docs/signal-vs-authority.md)
+
+- [ ] No - this change produces a signal consumed by an existing smart gate.
+- [ ] No - this change has no block/allow surface.
+- [ ] Yes - but the logic is a smart gate with full conversational context (LLM-backed with recent history or equivalent).
+- [x] Yes, but over a hard enumerable source invariant rather than a competing-signals judgment point.
+
+This lint has blocking authority in the build, but it is not deciding from brittle runtime context. It enforces a concrete invariant: a literal `messaging.*` config key with literal `false` default is unreachable through the expected top-level config surface. The new part only folds literal string pieces before applying that same invariant.
+
+---
+
+## 4b. Judgment-point check (Judgment Within Floors standard)
+
+No new static heuristic at a competing-signals decision point. The domain is enumerable source text: literal string values, `+` separators, and the literal `false` default. There are no live signals such as ownership, urgency, recency, or user intent to arbitrate.
+
+---
+
+## 5. Interactions
+
+- **Shadowing:** This replaces the prior single-regex detection path inside the same lint. It does not run before another checker or suppress another result.
+- **Double-fire:** One line produces one hit through `scanText`; the scanner returns line numbers as before.
+- **Races:** No shared runtime state. The script reads the source tree and exits.
+- **Feedback loops:** No feedback loop. The output feeds developer/build action only.
+
+---
+
+## 6. External surfaces
+
+No user-facing runtime surface changes. Other agents and users only see the effect when developing Instar: split-literal unreachable messaging gates fail the lint. No external service calls, no persistent state changes, no generated URLs, no timing dependency, and no operator-facing action surface.
+
+---
+
+## 6b. Operator-surface quality (Operator-Surface Quality standard)
+
+No operator surface - not applicable.
+
+---
+
+## 7. Multi-machine posture (Cross-Machine Coherence)
+
+Machine-local by design: this is a source-tree lint that runs in the checkout performing the build. It holds no durable agent state, emits no user-facing notices, and generates no URLs. Multi-machine coherence is handled by committing the script/tests/release notes to git so every machine receives the same lint behavior after update.
+
+---
+
+## 8. Rollback cost
+
+Pure code/test/docs change. Rollback is a hot-fix revert of the lint parser and its tests plus the release fragment. No data migration, no agent state repair, and no user-visible runtime regression during rollback.
+
+---
+
+## Conclusion
+
+The review narrowed the implementation to literal-only first-argument folding, added a negative test for template expressions, and resolved second-pass's string-example false-positive concern by scanning for `.get` only outside string literal text. The change is clear to ship with the known caveat that dynamic key construction remains out of scope for this lint.
+
+---
+
+## Second-pass review (if required)
+
+**Reviewer:** `Locke`
+**Independent read of the artifact:** `concern, resolved`
+
+Initial concern: the first implementation scanned for `.get` across preserved string contents, so a non-executed example string such as `const example = "liveConfig.get('messaging.' + 'actionClaim.enabled', false)"` could be reported. Resolution: `lineHasUnreachableOffGate` now locates `.get` only while outside string literal text, and `tests/unit/lint-no-unreachable-messaging-gate.test.ts` includes the example-string negative control. Dynamic concatenation and template expressions remained out of scope as intended.
+
+---
+
+## Evidence pointers
+
+- Shipped-lint reproduction before the fix: split key returned `hits: []`, counted as `failureCount: 1`.
+- After fix direct probe: split key returns `hits: [1]`.
+- Focused suite: `npx vitest run tests/unit/lint-no-unreachable-messaging-gate.test.ts` passed `15/15` after the second-pass fix.
+- Real tree: `node scripts/lint-no-unreachable-messaging-gate.js` exited clean with no existing flags.
+- Full lint: `npm run lint` exited clean.
+- Full push suite: `npm run test:push` ran 44,154 tests; 44,121 passed, 27 skipped, 3 todo, and 3 failed. Two failures were live Gemini e2e tests requiring absent `GEMINI_API_KEY`; the third feedback-drain ordering failure reran green in isolation.
+
+---
+
+## Class-Closure Declaration (display-only mirror)
+
+No agent-authored-artifact defect - not applicable. This fixes a source-code lint detection gap and adds direct regression tests for the reproduced shape.

package/upgrades/side-effects/topic-creation-lint-resolution.md

@@ -0,0 +1,135 @@
+# Side-Effects Review — topic-creation guard resolves the method name
+
+**Version / slug:** `topic-creation-lint-resolution`
+**Date:** `2026-08-15`
+**Author:** `echo`
+**Second-pass reviewer:** `not required — Tier 1 (CI-only lint script; no runtime path). The rule is unchanged; the check now resolves one level of naming before applying the rules it already had.`
+
+## Summary of the change
+
+`scripts/lint-no-unfunneled-topic-creation.js` enforces the **Bounded Notification Surface** standard —
+the last-resort budget on automatically-created forum topics, added after the THIRD topic-spam incident
+(2026-06-05). All three of its patterns required `createForumTopic` as a string LITERAL adjacent to the
+seam, so a resolved name walked past a safety floor.
+
+Measured against the shipped lint, with a positive control (the bare literal) firing in the same run:
+
+| form | shipped |
+|---|---|
+| `apiCall("createForumTopic", …)` — POSITIVE CONTROL | exit 1 (caught) |
+| `const M = "createForumTopic"; apiCall(M, …)` | **exit 0 — EVADES** |
+| `apiCall("createForum" + "Topic", …)` | **exit 0 — EVADES** |
+| `const M = "createForumTopic"; { method: M }` | **exit 0 — EVADES** |
+
+The method name is now RESOLVED before the existing patterns are applied. The patterns are byte-identical;
+only what they can see changed.
+
+## Decision-point inventory
+
+- `foldAdjacentLiterals(text)` — ADD — folds `'a' + 'b'` only; never folds across an identifier.
+- `collectStringConsts(lines)` — ADD — per-file identifier → string-literal map; an identifier bound twice
+  to DIFFERENT values is dropped as unresolvable.
+- `resolveLine(line, consts)` — ADD — substitutes ONLY at the two seam positions (`apiCall(` and `method:`).
+- `scanFile(normalized, content)` — ADD — extracted so the matching behaviour is testable without the CLI.
+- Direct-invocation guard — ADD — the scan runs only when the script is invoked directly.
+- `PATTERNS`, `ALLOWLIST`, `SCAN_DIRS`, `EXTENSIONS`, the violation message and exit codes — UNCHANGED.
+- No runtime block/allow decision added or modified. CI-time only.
+
+## 1. Over-block
+
+The failure that matters. This lint blocks commits, and a check that flags correct code gets switched
+off — which would cost more than the hole it closes. Six controls, each with a test, all passing under
+BOTH the old and new behaviour:
+
+- **A const bound to a different method** (`"sendMessage"`) is not flagged.
+- **An identifier that never reaches a seam** is not flagged — holding the value is not calling with it.
+- **An identifier bound twice to different values** is unresolvable and never substituted. Ambiguity
+  fails toward NOT flagging, because a guess that fails someone's build is the expensive direction.
+- **A concatenation involving an identifier** (`"createForum" + suffix`) is left unresolved. Folding it
+  would mean inventing text the source does not contain.
+- **A longer name starting with the method** (`createForumTopicIconStickers`) is not flagged — the
+  existing quote-delimited patterns already bound this, and resolution preserves it.
+- **Substitution is seam-local, not global** — an unrelated `logger.debug(M)` is untouched.
+
+Resolution is per-file by construction: one file's names cannot affect another's.
+
+**Verified against the real tree: exit 0 before AND after.** No new flags on existing code.
+
+## 2. Under-block
+
+Stated in the source rather than implied:
+
+- **Cross-module names** — a method name imported from another file is not followed.
+- **Runtime-built names** — from a variable, a function call, or a template literal.
+- **Anything needing dataflow** to resolve.
+
+Guessing at those would over-match.
+
+**One residual I want named rather than absorbed:** the lint does not strip comments, so a comment
+containing the literal form is flagged. That is PRE-EXISTING behaviour (it is why this script is on its
+own allowlist), and this change neither fixes nor worsens it — resolution runs on the same lines the
+patterns already ran on. I am not changing it here because loosening a flood guard to be tidier is the
+wrong direction, and doing it unrequested is the unrequested-tightening mistake in reverse.
+
+## 3. Level-of-abstraction fit
+
+Same layer as the existing check — line-oriented regex over raw source, no AST, no type information, no
+new dependency. The resolution map is the minimum needed to answer "what method name is at this seam?"
+without climbing to a parser.
+
+## 4. Signal vs authority compliance
+
+Unchanged. A CI guard, not a runtime authority. It pushes callers toward the budgeted funnel; the
+allowlist still exempts the funnel itself, the lifeline's fixed-cardinality system topic, and the
+setup-wizard doc string.
+
+## 5. Interactions
+
+- `npm run lint` chain — membership verified explicitly (the script is in the `lint` chain CI runs, not
+  merely referenced by a standalone entry); full chain exit 0 across 57 steps.
+- The direct-invocation guard changes import behaviour from "runs the repo scan and may exit(1)" to
+  "exports only". Nothing imported this module before, so no caller changes.
+- No source module, route, config key, or state file touched.
+
+## 6. External surfaces
+
+None. Developer tooling, not an agent capability; the Agent Awareness Standard does not apply.
+
+## 7. Multi-machine posture (Cross-Machine Coherence)
+
+**Machine-local BY DESIGN, and it is the correct posture — not an unexamined assumption.** This is a
+CI-time source scan with no runtime surface: it reads files in one checkout and exits. It holds no
+durable state, emits no user-facing notice, generates no URL, and makes no runtime decision, so there
+is nothing to replicate, nothing to merge on read, and nothing that could strand on a topic transfer.
+
+Every machine that runs the lint runs it over its own checkout of the same tracked source and reaches
+the same verdict — determinism comes from the source tree, not from coordination. Resolution is
+explicitly per-file, so it cannot even depend on the rest of the checkout, let alone another machine.
+
+Worth stating because the audit that added this question found ~20 features shipped machine-blind: the
+thing that makes THIS one genuinely local is that its input is version-controlled and its output is an
+exit code, not that I could not think of a cross-machine concern.
+
+## 8. Rollback cost
+
+`git revert` of one script plus the added test file. No migration, no state, no deployed artifact.
+
+## Conclusion
+
+Ship. Three evasions closed on a safety floor, six anti-over-block controls added, real tree verified
+clean in both directions, and the import hazard that blocked testing it removed.
+
+## Evidence pointers
+
+- `tests/unit/topic-creation-lint-resolution.test.ts` — **18/18 green**.
+- **Negative control: 5 of 18 fail** against the shipped matching behaviour (local const, concatenation,
+  `method:` const, let/var bindings, const-declared-after-use). The other 13 pass both ways — which is
+  what makes them controls. Source restored byte-exact after the mutation (sha match, 0 markers left).
+- Reproduced by hand FIRST with a positive control firing in the same run; the control is what makes the
+  three EVADES verdicts mean anything.
+- Real-tree verdict: `node scripts/lint-no-unfunneled-topic-creation.js` → exit 0, before and after.
+- Full `npm run lint` chain green, 57 steps.
+- Tier **1** declared: risk floor 1 (no safety-invariant path match — verified with two directional
+  controls, `SessionReaper.ts` → floor 2 with its reason named, `devClaimCheck.ts` → floor 1). The size
+  heuristic suggests 2 on added LOC alone; stated openly rather than left silent, since the tier I chose
+  is the one that lets the change through.