@litfamily/lithermes 1.0.32 → 1.0.33

package/assets/lithermes-plugin/skills/lit-adhd/references/brief-contract.md

@@ -53,12 +53,16 @@ surfaces; a session id with no recorded value reads `unknown`.
    grant settles it. The brief never starts, approves, or denies anything itself.
 5. **One next step in a box.** Exactly the `next` record: what it does, then the slash command
    (`/start-work plans/<f>.md`) when `next.command` names one, otherwise "continue in chat".
-   When `next` is `none`, the first item under `## Next` in this worktree's own HANDOFF.md
-   (`handoffs[].next`, `local: true`) comes first (`HANDOFF.md Next: <item>`); without one the
-   box shows the suggestion — a waiting session to answer, an open plan item, another active
-   session to check, another ended one to pick up — and the headline names it; it is shown,
-   never recorded. Another worktree's handoff never supplies the step. Never a second
-   candidate, never a `go` to type: Hermes has no typed `go` command.
+   When `next` is `wait-lanes`, other lanes are at work (`lanes.count`): the box says to wait
+   for them or to answer the one waiting on the user, names no command, and the last line is
+   `Do not type \`go\` until they finish.` (`지금은 \`go\`는 입력하지 마세요.`).
+   When `next` is `none`, the box shows the suggestion, in this order — a waiting session to
+   answer, lanes at work to wait for (same last line), an open plan item, the first open item
+   under `## Next` in this worktree's newest HANDOFF file (`HANDOFF.md Next: <item>`; items
+   marked ✅, ✓, `[x]`, ~~struck~~, DONE or SHIPPED are skipped), another active session to
+   check, another ended one to pick up — and the headline names it; it is shown, never
+   recorded. Another worktree's handoff never supplies the step. Never a second candidate,
+   never a `go` to type: Hermes has no typed `go` command.
 
 ## Surface notes (C, D)
 
@@ -69,7 +73,8 @@ surfaces; a session id with no recorded value reads `unknown`.
 
 ## Closing lines
 
-- Name every `unknown` source once on the last line (`unknown: herdr, git`).
+- Name every `unknown` source once on the last line (`unknown: herdr, git`); while lanes work,
+  the no-`go` line follows it as the very last line.
 - Say "older sessions were not read" when `budget.exhausted` is true.
 - Say "N plans were not read (read budget used up)" when `roadmap.plansSkipped` is above zero.
   Plans are read before session transcripts, so this happens only when the plans themselves

package/assets/lithermes-plugin/skills/lit-adhd/scripts/lib/collect.mjs

@@ -11,7 +11,7 @@ import { basename, dirname, join, resolve } from 'node:path';
 
 import { parsePlanTaskRows } from './plan-task-rows.mjs';
 import { aggregateProgress, clipToWidth, displayWidth, progressOf } from './gauge.mjs';
-import { chooseNextStep, suggestNext, writeNextStep } from './next-step.mjs';
+import { chooseNextStep, suggestNext, waitText, writeNextStep } from './next-step.mjs';
 import { makeRedactor } from './redact.mjs';
 import { findHermesSessions, hermesSessionRecord, hermesStorePath, makeBudget, normalizeRoot, readHermesMessages } from './hermes-sessions.mjs';
 
@@ -164,33 +164,42 @@ const goalsOf = (root, budget, redact) => {
   });
 };
 
-// The first item under a `## Next` (or `## Next steps`) heading, its list marker removed.
+// A Next item already marked finished: a tick, a checked box, a struck line, or DONE/SHIPPED
+// written in capitals (lowercase "done" in ordinary prose stays open).
+const finishedItem = (raw, line) =>
+  /[✅✓]/u.test(line) || /^(?:[-*+]|\d+[.)])\s+\[[xX]\]/u.test(raw) || /^~~.*~~$/u.test(line) || /\b(?:DONE|SHIPPED)\b/u.test(line);
+
+// The first open item under a `## Next` (or `## Next steps`) heading, its list marker removed.
 const nextItemOf = (text) => {
   let inside = false;
   for (const raw of text.split('\n')) {
-    const line = raw.trim();
-    if (/^#{1,6}\s/u.test(line)) {
+    const trimmed = raw.trim();
+    if (/^#{1,6}\s/u.test(trimmed)) {
       if (inside) return null;
-      inside = /^#{1,6}\s+next(?:\s+steps?)?$/iu.test(line);
-    } else if (inside && line) {
-      return line.replace(/^(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?/u, '');
+      inside = /^#{1,6}\s+next(?:\s+steps?)?$/iu.test(trimmed);
+    } else if (inside && trimmed) {
+      const item = trimmed.replace(/^(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?/u, '');
+      if (!finishedItem(trimmed, item)) return item;
     }
   }
   return null;
 };
 
-// Only this worktree's own handoff offers a `next`; another worktree's never does.
+// Only this worktree's own handoff offers a `next`, and only from its newest file: an old root
+// HANDOFF.md never outranks a newer one (the dedicated `.handoff/HANDOFF.md` wins a tie).
+// Another worktree's handoff never offers one.
 const handoffsOf = (root, budget, redact, local) => {
   const files = (entries(root) ?? [])
     .filter((entry) => entry.isFile() && /^HANDOFF.*\.md$/u.test(entry.name))
     .map((entry) => join(root, entry.name));
   const dotted = join(root, '.handoff', 'HANDOFF.md');
   if (existsSync(dotted)) files.push(dotted);
-  return files.map((path) => {
-    const text = readSmallFile(path, budget) ?? '';
-    const headings = text.split('\n').slice(0, 40).filter((line) => /^#{1,3} /u.test(line)).map((line) => clipToWidth(redact(line), 100));
-    const next = local ? nextItemOf(text) : null;
-    return { worktree: redact(root), file: basename(path), headings, local, next: next ? clipToWidth(redact(next), 120) : null };
+  const read = files.map((path) => ({ path, text: readSmallFile(path, budget) ?? '', mtimeMs: mtimeOf(path) ?? 0 }));
+  const newest = read.reduce((best, item) => (best === null || item.mtimeMs > best.mtimeMs || (item.mtimeMs === best.mtimeMs && item.path === dotted) ? item : best), null);
+  return read.map((item) => {
+    const headings = item.text.split('\n').slice(0, 40).filter((line) => /^#{1,3} /u.test(line)).map((line) => clipToWidth(redact(line), 100));
+    const next = local && item === newest ? nextItemOf(item.text) : null;
+    return { worktree: redact(root), file: basename(item.path), headings, local, next: next ? clipToWidth(redact(next), 120) : null };
   });
 };
 
@@ -233,7 +242,7 @@ const stacksOf = (root, budget, redact) => {
 // Hermes start-work state: newest `runs/*/state.json` with `command: start-work` (a run has no
 // status field, so an unfinished plan reads active and a finished plan reads done), plus
 // bounded-work `work/*/state.json` records, which carry a real status and a pending boundary.
-const startWorkOf = (root, budget, redact, sessionId) => {
+const startWorkOf = (root, budget, redact) => {
   const items = [];
   const runs = entries(join(root, '.hermes', 'lithermes', 'runs')) ?? [];
   let newestRun = null;
@@ -254,8 +263,9 @@ const startWorkOf = (root, budget, redact, sessionId) => {
       plan: plan ? redact(plan) : 'unknown',
       status: rows.length && !open.length ? 'done' : 'active',
       atMs: Date.parse(String(newestRun.created_at ?? '')),
-      sessionId: sessionId ?? null,
-      id8: sessionId ? String(sessionId).slice(0, 8) : 'unknown',
+      // A start-work run records no session, so it is never assumed to be this session's.
+      sessionId: null,
+      id8: 'unknown',
       progress: rows.length
         ? progressOf(rows.length - open.length, rows.length, open.map((row) => clipToWidth(redact(row.text), NAME_MAX)))
         : progressOf(null, null),
@@ -295,16 +305,53 @@ const startWorkOf = (root, budget, redact, sessionId) => {
   return items.length ? items : null;
 };
 
-const herdrOf = (env, exec, redact) => {
+const insideAny = (dir, roots) =>
+  typeof dir === 'string' && dir !== '' && roots.some((root) => dir === root || dir.startsWith(`${root}/`));
+
+// `herdr agent list` prints one JSON document. An agent is a lane when it is working or blocked
+// in this herdr workspace or inside one of this repo's worktrees; this pane is never a lane.
+// Anything unreadable leaves herdr `unknown` with no lanes.
+const herdrOf = (env, exec, redact, roots) => {
   if (env.HERDR_ENV !== '1') return { status: 'unknown', agents: [] };
   try {
     const out = exec('herdr', ['agent', 'list'], { timeout: HERDR_TIMEOUT_MS });
-    return { status: 'ok', agents: out.split('\n').filter((line) => line.trim()).slice(0, 20).map((line) => clipToWidth(redact(line.trim()), 120)) };
+    const listed = JSON.parse(out)?.result?.agents;
+    if (!Array.isArray(listed)) return { status: 'unknown', agents: [] };
+    const agents = listed.slice(0, 40).filter((agent) => agent && typeof agent === 'object').map((agent) => {
+      const status = typeof agent.agent_status === 'string' ? agent.agent_status : 'unknown';
+      const pane = typeof agent.pane_id === 'string' ? agent.pane_id : 'unknown';
+      const here = (env.HERDR_WORKSPACE_ID && agent.workspace_id === env.HERDR_WORKSPACE_ID)
+        || insideAny(agent.cwd, roots) || insideAny(agent.foreground_cwd, roots);
+      const session = typeof agent.agent_session?.value === 'string' ? agent.agent_session.value : null;
+      return {
+        agent: clipToWidth(redact(String(agent.agent ?? 'unknown')), 40),
+        status,
+        pane: clipToWidth(redact(pane), 40),
+        lane: ['working', 'blocked'].includes(status) && Boolean(here) && !(env.HERDR_PANE_ID && pane === env.HERDR_PANE_ID),
+        sessionId: session,
+      };
+    });
+    return { status: 'ok', agents };
   } catch {
     return { status: 'unknown', agents: [] };
   }
 };
 
+// Lanes: other live sessions of this repo (active or waiting on the user) plus herdr lane agents;
+// an agent whose session is already counted, or is this session, counts once or not at all.
+const lanesOf = (sessions, herdr, sessionId) => {
+  const others = sessions.filter((session) => session.sessionId !== sessionId && ['active', 'waiting-on-user'].includes(session.status));
+  const counted = new Set(others.map((session) => session.sessionId));
+  const agents = herdr.agents.filter((agent) => agent.lane && !(agent.sessionId && (counted.has(agent.sessionId) || agent.sessionId === sessionId)));
+  const waiting = others.find((session) => session.status === 'waiting-on-user');
+  return {
+    count: others.length + agents.length,
+    sessions: others.map((session) => session.id8),
+    agents: agents.map((agent) => agent.pane),
+    waiting: waiting ? waiting.id8 : null,
+  };
+};
+
 const known = (list) => (list === null ? 'unknown' : 'ok');
 // A run records its plan as an absolute path; inside its own worktree it reads `plans/<f>.md`.
 const planInWorktree = (worktree, plan) => (plan.startsWith(`${worktree}/`) ? plan.slice(worktree.length + 1) : plan);
@@ -350,7 +397,7 @@ export const collectAdhd = ({
   });
   const handoffs = roots.flatMap((root) => handoffsOf(root, budget, redact, resolve(root) === start));
   const workflows = collectEach((root) => stacksOf(root, budget, redact));
-  const startWork = collectEach((root) => startWorkOf(root, budget, redact, sessionId));
+  const startWork = collectEach((root) => startWorkOf(root, budget, redact));
 
   const found = findHermesSessions(hermesStorePath(env), roots, { exec });
   const sessions = [];
@@ -364,7 +411,7 @@ export const collectAdhd = ({
   }
 
   const commits = collectEach((root) => commitsOf(root, sinceMs, now, exec, redact));
-  const herdr = herdrOf(env, exec, redact);
+  const herdr = herdrOf(env, exec, redact, roots.map((root) => resolve(root)));
 
   // A session waits on the user when it asked something, or holds a paused boundary.
   for (const session of sessions) {
@@ -382,6 +429,7 @@ export const collectAdhd = ({
       .map(({ hash, subject }) => ({ hash, subject }));
   }
   sessions.sort((a, b) => statusRank[a.status] - statusRank[b.status] || (b.lastMs ?? 0) - (a.lastMs ?? 0));
+  const lanes = lanesOf(sessions, herdr, sessionId);
 
   // Open plans changed inside the window are listed, this worktree's first, then the most recently
   // changed, up to a short cap; a stale plan is left out here and elsewhere. The roadmap gauge
@@ -433,7 +481,8 @@ export const collectAdhd = ({
     startWork: startWork ?? [],
     handoffs,
     commits: (commits ?? []).slice(0, 20).map(({ atMs: _atMs, ...commit }) => commit),
-    herdr,
+    herdr: { status: herdr.status, agents: herdr.agents.map(({ sessionId: _sessionId, ...agent }) => agent) },
+    lanes,
   };
   const next = chooseNextStep(data, sessionId);
   data.next = next;
@@ -561,7 +610,7 @@ const openerLines = (data, nextText) => {
       : active
         ? clipToWidth(goalOf(active), 80)
         : running[0]
-          ? `start-work ${planInWorktree(running[0].worktree, running[0].plan)} ${running[0].progress.gauge} (another session)`
+          ? `start-work ${planInWorktree(running[0].worktree, running[0].plan)} ${running[0].progress.gauge}${running[0].id8 === 'unknown' ? '' : ' (another session)'}`
           : 'nothing running';
   return [`Done so far: ${done}`, `Doing now: ${doing}`, `Next: ${nextText}`];
 };
@@ -570,19 +619,23 @@ const openerLines = (data, nextText) => {
 export const renderAdhd = (data, width = 100, sessionId = null) => {
   const out = [];
   const push = (text) => out.push(line(text, width));
-  const recorded = data.next.kind !== 'none';
-  // With no step on record, this worktree's HANDOFF.md `## Next` item comes before any suggestion.
-  const handoffNext = (data.handoffs ?? []).find((handoff) => handoff.local && handoff.next)?.next;
+  const waiting = data.next.kind === 'wait-lanes';
+  const recorded = data.next.kind !== 'none' && !waiting;
+  // With no runnable step on record, the suggestion ranks live signals (a session waiting on the
+  // user, lanes at work) and open plan items ahead of this worktree's HANDOFF.md `## Next` item.
   const step = recorded
     ? data.next
-    : handoffNext
-      ? { kind: 'suggest', label: 'handoff next', say: `HANDOFF.md Next: ${handoffNext}`, command: null }
+    : waiting
+      ? { kind: 'suggest', label: 'wait for lanes', say: waitText(data.next.target.lanes, data.next.target.waiting), command: null }
       : suggestNext(data, sessionId);
   const stepName = recorded ? data.next.kind.replace(/-/gu, ' ') : step.label;
   const stepSay = recorded && data.next.say ? ` (say "${data.next.say}")` : '';
   const stepRun = step.command ? ` (run ${step.command})` : recorded ? '' : ' (continue in chat)';
   const target = recorded ? data.next.target?.plan ?? data.next.target?.workId ?? '' : '';
   const nextText = recorded ? `${stepName}${target ? `: ${target}` : ''}${stepSay}${stepRun}` : `${step.say}${stepRun}`;
+  // While other lanes work, `go` has nothing to start. An own run is held back
+  // before it is recorded, so this line covers that case too.
+  const holdGo = (data.lanes?.count ?? 0) > 0 && !recorded;
   for (const opener of openerLines(data, nextText)) push(opener);
   push(`lit-adhd: ${data.summary.sessions} session(s) · ${data.summary.waitingOnUser} waiting on you · next: ${stepName}${stepSay}${stepRun}`);
   const live = data.sessions.filter((session) => session.status !== 'ended');
@@ -618,6 +671,7 @@ export const renderAdhd = (data, width = 100, sessionId = null) => {
   if (unknownSources.length) push(`unknown: ${unknownSources.join(', ')}`);
   const skipped = data.roadmap.plansSkipped ?? 0;
   if (skipped) push(`${skipped} ${skipped === 1 ? 'plan was' : 'plans were'} not read (read budget used up)`);
+  if (holdGo) push('Do not type `go` until they finish.');
   return `${out.join('\n')}\n`;
 };
 

package/assets/lithermes-plugin/skills/lit-adhd/scripts/lib/next-step.mjs

@@ -4,10 +4,14 @@
 // user answers in words, and an active run simply continues in chat. The record `go` reads back
 // lives under the workspace's `.hermes/lithermes/adhd/` directory alongside the stack file.
 //
-//   1. a bounded-work run paused at a boundary -> approve-boundary (shown, never started)
-//   2. this session's own active run or bounded work  -> continue-work (continue in chat)
-//   3. a single open plan with no work running        -> start-plan (`/start-work plans/<f>.md`)
+//   1. a bounded-work run paused at a boundary -> approve-boundary (shown, never started),
+//      even while other lanes are at work: that choice is the user's
+//   2. this session's own active run or bounded work  -> continue-work (continue in chat),
+//      or wait-lanes while other lanes are at work
+//   3. a single open plan with no work running        -> start-plan (`/start-work plans/<f>.md`),
+//      or wait-lanes while other lanes are at work (no command, and no `go` until they finish)
 //   4. otherwise                                     -> none
+// A paused discipline frame is not a resume. Hermes has no pausable stack to continue.
 import { closeSync, constants, lstatSync, mkdirSync, openSync, renameSync, writeSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 
@@ -22,22 +26,40 @@ export const chooseNextStep = (data, sessionId) => {
   if (paused) {
     return { kind: 'approve-boundary', target: { workId: paused.workId, plan: paused.plan, ...paused.pendingBoundary }, say: null, automatic: false };
   }
+  const lanes = data.lanes?.count ?? 0;
   const active = sessionId
     ? (data.startWork ?? []).find((work) => work.status === 'active' && work.sessionId === sessionId)
     : null;
+  // The lane hold used to sit only on the start-plan branch, so this session's own
+  // run was still offered while the lanes it started were at work.
+  if (active && lanes > 0) {
+    return { kind: 'wait-lanes', target: { lanes, waiting: data.lanes?.waiting ?? null }, say: null };
+  }
   if (active) return { kind: 'continue-work', target: { workId: active.workId, plan: active.plan }, say: null };
   const running = (data.startWork ?? []).some((work) => ['active', 'paused'].includes(work.status));
   const open = data.roadmap.plans.filter((plan) => plan.local && plan.progress.total !== null && plan.progress.done < plan.progress.total);
   if (!running && open.length === 1) {
+    // Other lanes at work hold the plan back: the step is to wait (or answer the one waiting).
+    const lanes = data.lanes?.count ?? 0;
+    if (lanes > 0) {
+      return { kind: 'wait-lanes', target: { lanes, waiting: data.lanes.waiting ?? null, plan: open[0].plan }, say: null };
+    }
     return { kind: 'start-plan', target: { plan: open[0].plan }, say: null, command: `/start-work ${open[0].plan}` };
   }
   return { kind: 'none', target: null };
 };
 
+const lanesText = (count) => `${count} lane${count === 1 ? '' : 's'}`;
+
+/** The box text for a lanes wait: answer the lane waiting on the user, else wait for the rest. */
+export const waitText = (lanes, waiting) =>
+  waiting ? `answer ${waiting} in chat (${lanesText(lanes)} at work)` : `wait for ${lanesText(lanes)} to finish`;
+
 // Shown, never recorded: when no step can run, the brief still recommends one from what
-// it read — a session that waits on the user, the next item of an open plan, the most
-// recent other active session, the most recent other ended one. Hermes has no typed `go`,
-// so every suggestion continues in chat except a plan item, which names its command.
+// it read — a session that waits on the user, other lanes at work, the next item of an open
+// plan, this worktree's newest HANDOFF Next item, the most recent other active session, the
+// most recent other ended one. Live signals come first, so an old HANDOFF line never outranks
+// them. Every suggestion continues in chat except a plan item, which names its command.
 export const suggestNext = (data, sessionId) => {
   const sessions = data.sessions ?? [];
   const waiting = sessions.filter((session) => session.status === 'waiting-on-user');
@@ -47,11 +69,17 @@ export const suggestNext = (data, sessionId) => {
     const clipped = question ? clipToWidth(bare1(question), 90) : null;
     return { kind: 'suggest', label: `answer ${first.id8}`, say: `Answer ${first.id8} in chat${clipped ? `: "${clipped}"` : ''}`, command: null };
   }
+  const lanes = data.lanes?.count ?? 0;
+  if (lanes > 0) {
+    return { kind: 'suggest', label: 'wait for lanes', say: waitText(lanes, null), command: null };
+  }
   const open = (data.roadmap?.plans ?? []).filter((plan) => plan.current);
   const plan = open.find((item) => item.local) ?? open[0];
   if (plan) {
     return { kind: 'suggest', label: `start ${plan.plan}`, say: `Next in ${plan.plan}: ${clipToWidth(bare1(plan.current), 60)}`, command: `/start-work ${plan.plan}` };
   }
+  const handoffNext = (data.handoffs ?? []).find((handoff) => handoff.local && handoff.next)?.next;
+  if (handoffNext) return { kind: 'suggest', label: 'handoff next', say: `HANDOFF.md Next: ${handoffNext}`, command: null };
   const others = sessions.filter((session) => session.sessionId !== sessionId);
   const active = others.find((session) => session.status === 'active');
   if (active) {

package/assets/lithermes-plugin/skills/lit-burnoff/SKILL.md

@@ -176,7 +176,7 @@ The agent looks for these nine categories. The first three are stylistic, the ne
 5. **Boundary violations** — wrong-layer imports (UI importing DB driver), leaky responsibilities (handler doing business logic that belongs in a service), hidden coupling (module A reads module B's private state), side effects in pure-named functions.
    - KEEP: pragmatic short-circuits already established as a pattern in this codebase. Flag for human judgment if unsure.
 
-6. **Dead code** — unused imports, unused private functions/methods, unreachable branches, stale feature flags, debug leftovers (`console.log`, `print(...)`, `dbg!`), removed-but-still-referenced code.
+6. **Dead code** — unused imports, unused private functions/methods, unreachable branches, stale feature flags, debug leftovers (`console.log`, `print(...)`, `dbg!()), removed-but-still-referenced code.
    - KEEP: code referenced via reflection, dynamic dispatch, or string lookup. Code intentionally kept as a feature flag rollback path (verify with the user).
 
 ### Hidden cost

package/assets/lithermes-plugin/skills/lit-code/SKILL.md

@@ -188,7 +188,7 @@ These are not style preferences. They are the six axioms every recipe in `refere
 
 4. **Exhaustive variant matching, always.** Discriminated unions and enums are matched exhaustively. Python: `match` + `case unreachable: assert_never(unreachable)`. Rust: `match` (the compiler enforces). TypeScript: `switch` + `assertNever`. **`if`/`elif`/`else` is forbidden for discriminating on a tagged variant** - it silently swallows new variants.
 
-5. **Trust framework guarantees. Validate only at boundaries.** No null checks for values the type system already proves non-null. No `try/except` around code that cannot raise. No `unwrap`/`!`/`as` to paper over a contract you should have encoded in types. No defensive layer for a scenario you cannot name.
+5. **Trust framework guarantees. Validate only at boundaries.** No null checks for values the type system already proves non-null. No `try/except` around code that cannot raise. No `unwrap`/(!)/`as` to paper over a contract you should have encoded in types. No defensive layer for a scenario you cannot name.
 
 6. **Test-driven, with the right shape of test.** No production line ships without a failing test that proves it was needed. Behavior is locked by tests, not by hope. See the TDD discipline below.
 
@@ -275,9 +275,9 @@ Apply unless the per-language reference overrides with something stricter.
 | Immutable by default | `@dataclass(frozen=True, slots=True)` / Pydantic `frozen=True` | every binding is `let` (not `let mut`) unless mutation is the documented purpose | every field is `readonly`; arrays are `readonly T[]` | value types, unexported fields, no mutation methods unless mutation is the purpose |
 | Branded primitives | `UserId = NewType("UserId", int)` | `struct UserId(u64);` (newtype tuple) | `type UserId = Brand<string, "UserId">` | `type UserID string` + smart constructor with unexported field |
 | Exhaustive variant matching | `match` + `assert_never` | `match` (compiler-enforced) | `switch` + `assertNever` | sealed interface + type switch + **`exhaustive` linter** (the compiler will not help) |
-| No untyped escape hatches | no `Any` in public sigs, no `cast`, no `# type: ignore` | no `unwrap`/`expect` outside `main`/tests, no `as` for narrowing, no `#[allow]` to silence real warnings | no `any`, no `as` (except `as const`, `satisfies`), no `!`, no `@ts-ignore`, no `@ts-expect-error` | no `interface{}` / bare `any` in domain sigs; no `_ = err`; no `//nolint` without reason |
+| No untyped escape hatches | no `Any` in public sigs, no `cast`, no `# type: ignore` | no `unwrap`/`expect` outside `main`/tests, no `as` for narrowing, no `#[allow]` to silence real warnings | no `any`, no `as` (except `as const`, `satisfies`), no (!), no `@ts-ignore`, no `@ts-expect-error` | no `interface{}` / bare `any` in domain sigs; no `_ = err`; no `//nolint` without reason |
 | No bare error strings | typed exception dataclass with `__str__` | `thiserror` enum (lib) or `anyhow` with `.context(...)` (app) | `Error` subclass with typed fields | sentinel `errors.New` + typed `*XError` struct; wrap with `%w`; check via `errors.Is/As` |
-| Boundary catch only | catch the exact exception you expect; broad `except Exception` only in `main()`, with logging + re-raise | `?` everywhere; never `panic!` in library code | `catch` must narrow with `instanceof` and re-throw or convert; no empty catch | every `(T, error)` checked; `panic` only in `main`/tests; one `httperr.Write` funnel in handlers |
+| Boundary catch only | catch the exact exception you expect; broad `except Exception` only in `main()`, with logging + re-raise | `?` everywhere; never `panic!() in library code | `catch` must narrow with `instanceof` and re-throw or convert; no empty catch | every `(T, error)` checked; `panic` only in `main`/tests; one `httperr.Write` funnel in handlers |
 | Resources via RAII | `with` (sync) / `async with` (async) | `Drop` impl or RAII guard | `using`/`await using` (TC39 explicit resource management) | `defer x.Close()` immediately after acquisition; `bodyclose`/`sqlclosecheck` linters enforce |
 | Async runtime is mandatory | `anyio` (NEVER bare `asyncio`) | `tokio` (`async-std` is unmaintained) | platform-native async (Bun/Node) with structured cancellation via `AbortSignal` | `context.Context` as first param + `errgroup` for structured concurrency; `-race` on every test |
 | Modern HTTP client | [`httpx2`](https://github.com/pydantic/httpx2) with HTTP/2 + brotli + zstd | `reqwest` with rustls | `ky` (default) / `undici` direct API (Node perf) - NEVER bare `fetch` in prod | stdlib `net/http.Client` with tuned `Transport` + `go-retryablehttp` for retry/backoff |
@@ -496,7 +496,7 @@ After every code-writing session, answer these out loud (in your reply) before d
 1. **Single responsibility?** Can I name what this file owns in one short noun phrase? If the answer needs the word "and", split.
 2. **Boundary purity?** Did I parse untrusted input into a typed value at the boundary, or did I pass `dict[str, Any]` / `serde_json::Value` / `unknown` past the boundary? If the latter, fix it.
 3. **Variant discrimination?** Did I use `if`/`elif`/`else` (or `switch` without `assertNever`, or `match` without `assert_never`) anywhere to discriminate on a tagged type or enum? If yes, rewrite as exhaustive match.
-4. **Escape hatches?** Any `Any`, `# type: ignore`, `unwrap`, `expect` outside `main`/tests, `as` numeric cast, `!`, `@ts-ignore`, `@ts-expect-error`, `#[allow]` on a real warning? If yes, fix the type or document why with a comment.
+4. **Escape hatches?** Any `Any`, `# type: ignore`, `unwrap`, `expect` outside `main`/tests, `as` numeric cast, (!), `@ts-ignore`, `@ts-expect-error`, `#[allow]` on a real warning? If yes, fix the type or document why with a comment.
 5. **Defensive layer?** Any null check, try/except, or `isinstance` guarding a value the type system already proves? If yes, delete.
 6. **Helpers for one-off?** Any function, class, or trait introduced for a single caller that will never get a second caller? If yes, inline.
 7. **Tests?** Is the behavior I just introduced locked by a test that would fail if I revert this commit?

package/assets/lithermes-plugin/skills/lit-code/references/rust/README.md

@@ -164,7 +164,7 @@ match status {
 }
 ```
 
-For `#[non_exhaustive]` enums from external crates, the wildcard `_` is required — but add a `tracing::warn!` in the catch-all so you notice when new variants appear.
+For `#[non_exhaustive]` enums from external crates, the wildcard `_` is required — but add a `tracing::warn!() in the catch-all so you notice when new variants appear.
 
 ### 8. Type-State Over Runtime Checks
 
@@ -278,7 +278,7 @@ zerocopy = { version = "0.8", features = ["derive"] }
 | [unsafe-discipline.md](unsafe-discipline.md) | Any `unsafe` block — SAFETY comments, safe wrappers, miri proof |
 | [libraries.md](libraries.md) | Library selection, crate decision tree, dependency audit |
 | [cargo-strict.md](cargo-strict.md) | Project bootstrap, lint config, CI gate commands |
-| [async-tokio.md](async-tokio.md) | Async runtime, spawning, cancellation, `JoinSet`, `select!` |
+| [async-tokio.md](async-tokio.md) | Async runtime, spawning, cancellation, `JoinSet`, `select!() |
 | [axum-stack.md](axum-stack.md) | HTTP services — axum + sqlx + tower + tracing |
 | [clap-stack.md](clap-stack.md) | CLI tools — clap derive + color-eyre + indicatif |
 | [concurrency.md](concurrency.md) | Locks, atomics, channels, loom model checker |

package/assets/lithermes-plugin/skills/lit-code/references/rust/async-tokio.md

@@ -48,14 +48,14 @@ while let Some(joined) = set.join_next().await {
 - Dropping the set aborts every still-running task.
 - Lets you handle failures one by one rather than all-or-nothing.
 
-For wait-for-all semantics with one type, `join!`:
+For wait-for-all semantics with one type, `join!():
 
 ```rust
 let (a, b, c) = tokio::join!(load_a(), load_b(), load_c());
 let a = a?; let b = b?; let c = c?;
 ```
 
-For first-of-many, `select!`:
+For first-of-many, `select!():
 
 ```rust
 tokio::select! {
@@ -74,7 +74,7 @@ Without `biased`, branches are polled in random order each iteration (good for f
 
 ## Cancellation
 
-A future is cancelled when it is dropped (e.g., the `select!` arm wins another branch). **Always think: if this future is dropped mid-await, what state is left behind?**
+A future is cancelled when it is dropped (e.g., the `select!() arm wins another branch). **Always think: if this future is dropped mid-await, what state is left behind?**
 
 Cancel-safe futures (you can drop without lasting effect):
 - `recv()` on channels
@@ -229,7 +229,7 @@ async fn main() -> anyhow::Result<()> {
 }
 ```
 
-Pattern: catch signal → cancel a token shared with the server → server's `select!` arms see the cancel and exit cleanly → wait with a timeout so a hung worker can't deadlock shutdown.
+Pattern: catch signal → cancel a token shared with the server → server's `select!() arms see the cancel and exit cleanly → wait with a timeout so a hung worker can't deadlock shutdown.
 
 ## Concurrency primitives
 

package/assets/lithermes-plugin/skills/lit-code/references/rust/axum-stack.md

@@ -447,7 +447,7 @@ let app = router.merge(SwaggerUi::new("/swagger-ui").url("/api-docs/openapi.json
 - Bind to `0.0.0.0` in containers, `127.0.0.1` for local-only services.
 - Set `RUST_LOG=info,sqlx=warn` (or use `EnvFilter` defaults as shown).
 - Send logs to stdout in JSON. Ingest via Vector / Fluent Bit / Loki.
-- Run migrations on startup (`sqlx::migrate!` block). Fail fast on schema mismatch.
+- Run migrations on startup (`sqlx::migrate!() block). Fail fast on schema mismatch.
 - Health endpoint **must hit the DB** (so load balancers know if the pool is dead).
 - Add `tower::limit::RateLimitLayer` or token-bucket middleware for public endpoints.
 - Set `tower_http::limit::RequestBodyLimitLayer` to bound request size.

package/assets/lithermes-plugin/skills/lit-code/references/rust/clap-stack.md

@@ -375,7 +375,7 @@ Errors with `.wrap_err("...")` from `eyre::WrapErr` (compatible with anyhow's `.
 1. **Mixing stdout and stderr.** Tool output goes to stdout; logs and progress go to stderr.
 2. **No `--non-interactive` flag.** Interactive prompts block automation.
 3. **Printing colored output unconditionally.** Honor `NO_COLOR` env var, detect TTY with `console::user_attended()`.
-4. **`println!` for errors.** Use `tracing::error!` so logs go to stderr automatically and respect verbosity.
+4. **`println!() for errors.** Use `tracing::error!() so logs go to stderr automatically and respect verbosity.
 5. **`unwrap()` on `Cli::parse()`.** clap returns clean errors with `--help` text; `parse()` exits on its own.
 6. **Long subcommand handlers in `main.rs`.** Split into `src/commands/<name>.rs` per command.
 7. **Missing exit code semantics.** Use `std::process::exit(1)` (general error), `2` (usage), `130` (SIGINT) appropriately. Or return `Result` and let main map.

package/assets/lithermes-plugin/skills/lit-code/references/rust/libraries.md

@@ -120,7 +120,7 @@ async fn process_user(db: &Pool, user: &User) -> anyhow::Result<()> {
 }
 ```
 
-Replace `println!` with `info!`/`warn!`/`error!`. Replace `eprintln!` with `tracing::error!`.
+Replace `println!() with `info!()/`warn!()/`error!(). Replace `eprintln!() with `tracing::error!().
 
 ## Error reporting (binaries) — `color-eyre`
 
@@ -235,7 +235,7 @@ pub async fn find_user(pool: &PgPool, email: &str) -> Result<Option<User>, sqlx:
 }
 ```
 
-`query_as!` checks the SQL against the live database at compile time. To work without a live DB during builds, generate offline metadata: `cargo sqlx prepare`. Commit the resulting `.sqlx/` directory.
+`query_as!() checks the SQL against the live database at compile time. To work without a live DB during builds, generate offline metadata: `cargo sqlx prepare`. Commit the resulting `.sqlx/` directory.
 
 Avoid `diesel` (sync-first, heavy DSL), raw `tokio-postgres` (loses type checks), `sea-orm` (more magic, less control).
 
@@ -391,7 +391,7 @@ use std::sync::LazyLock;
 static CONFIG: LazyLock<Config> = LazyLock::new(|| Config::load_from_env().unwrap());
 ```
 
-Avoid `lazy_static!` (macro-heavy, predates std), `once_cell` (now in std as `LazyLock`/`OnceLock`).
+Avoid `lazy_static!() (macro-heavy, predates std), `once_cell` (now in std as `LazyLock`/`OnceLock`).
 
 ## Hash maps — `std::collections::HashMap` + `ahash` for hot paths
 

package/assets/lithermes-plugin/skills/lit-code/references/rust/proptest-insta.md

@@ -6,11 +6,11 @@ Two test types every Rust project should have alongside unit tests. Proptest hun
 
 | Want to test… | Use |
 |---|---|
-| One specific behavior with a known input | `#[test]` + `assert_eq!` |
-| All inputs of a certain shape work | `proptest!` |
-| Output structure stays stable across refactors | `insta::assert_*_snapshot!` |
-| Parser/serializer round-trips | `proptest!` (the round-trip property) |
-| CLI help text, JSON response shape, debug output | `insta::assert_snapshot!` |
+| One specific behavior with a known input | `#[test]` + `assert_eq!() |
+| All inputs of a certain shape work | `proptest!() |
+| Output structure stays stable across refactors | `insta::assert_*_snapshot!() |
+| Parser/serializer round-trips | `proptest!() (the round-trip property) |
+| CLI help text, JSON response shape, debug output | `insta::assert_snapshot!() |
 | Concurrency under all interleavings | `loom` (see `concurrency.md`) |
 
 Use all three. They cover different bug classes.
@@ -58,7 +58,7 @@ proptest! {
 }
 ```
 
-`proptest!` macro takes `(arg in strategy, ...)` pairs. Each strategy produces values; proptest runs the body with random samples, then shrinks failing cases to minimal forms.
+`proptest!() macro takes `(arg in strategy, ...)` pairs. Each strategy produces values; proptest runs the body with random samples, then shrinks failing cases to minimal forms.
 
 ## Strategies — the value-generation language
 
@@ -296,10 +296,10 @@ fn debug_repr() {
 ```
 
 Choose:
-- `assert_snapshot!` for `String`/`Display` output (CLI help, error messages, generated code).
-- `assert_debug_snapshot!` for `{:?}` (Rust-internal data).
-- `assert_json_snapshot!` for structured data crossing process boundaries.
-- `assert_yaml_snapshot!` when YAML is easier to read in diffs.
+- `assert_snapshot!() for `String`/`Display` output (CLI help, error messages, generated code).
+- `assert_debug_snapshot!() for `{:?}` (Rust-internal data).
+- `assert_json_snapshot!() for structured data crossing process boundaries.
+- `assert_yaml_snapshot!() when YAML is easier to read in diffs.
 
 ## Insta — redactions and filters
 

package/assets/lithermes-plugin/skills/lit-code/references/rust/zero-cost-safety.md

@@ -512,7 +512,7 @@ tempfile = "3"  # idiomatic RAII temp files/dirs
 | No hidden allocations | `#![no_std]` / slice-based APIs / `Cow` | Style choice | §3 |
 | `packed struct` / bitfields | `#[repr(C, packed)]` / `bitfield` / `zerocopy` | Easy | §4 |
 | `errdefer` | `scopeguard::guard` + defuse on success | Easy | §5 |
-| `defer` | `scopeguard::defer!` / `Drop` | Easy | §5 |
+| `defer` | `scopeguard::defer!() / `Drop` | Easy | §5 |
 
 All achievable within Rust's single toolchain. You get Zig's explicitness **plus** the borrow checker, lifetime analysis, trait bounds, and `miri`. The combination is strictly more powerful than either alone.
 

package/assets/lithermes-plugin/skills/lit-code/references/typescript/README.md

@@ -31,7 +31,7 @@ These are deliberate project choices. Violations are always wrong, not "style pr
 3. **Exhaustive switch** — every `switch` on a discriminated union ends with `default: assertNever(x)`. No fall-through.
 4. **No any** — `any` is banned in annotations, returns, and parameters. Use `unknown` and narrow.
 5. **No type assertions** — `as any`, `as unknown` banned. `as const` and `satisfies` are fine.
-6. **No non-null assertion** — `x!` is banned. Use narrowing or optional chaining (`x?.y`).
+6. **No non-null assertion** — `x!.y` is banned. Use narrowing or optional chaining (`x?.y`).
 7. **No @ts-ignore / @ts-expect-error** — fix the type.
 8. **No enum** — use `as const` objects + literal union types.
 9. **Zod at boundaries** — external input (API, user, file) → Zod schema. Internal → plain types.
@@ -163,7 +163,7 @@ Violations caught by `../../scripts/typescript/check-no-excuse-rules.ts`. Run af
 | `no-ts-ignore` | `@ts-ignore` | None — fix the type |
 | `no-ts-expect-error` | `@ts-expect-error` | None — fix the type |
 | `no-enum` | `enum` declarations | None — use `as const` |
-| `no-non-null-assertion` | `x!` postfix | None — narrow or `?.` |
+| `no-non-null-assertion` | `x!.y` postfix | None — narrow or `?.` |
 | `no-throw-literal` | `throw "string"` / `throw 123` | None — throw Error subclass |
 | `no-mutable-export` | `export let` / `export var` | None — use `export const` |
 | `no-any-annotation` | `: any` in parameter/return/variable types | `// no-excuse-ok: any` |

package/assets/lithermes-plugin/skills/lit-code/references/typescript/backend-hono.md

@@ -100,7 +100,7 @@ app.get(
   validator('query', QuerySchema),
   (c) => {
     const query = c.req.valid('query')
-    return c.json({ message: `Hello ${query.name ?? 'Hono'}!` })
+    return c.json({ message: `Hello ${query.name ?? 'Hono'}.` })
   },
 )
 

package/assets/lithermes-plugin/skills/lit-code/references/typescript/tsconfig-strict.md

@@ -128,7 +128,7 @@ For Bun projects, add to `compilerOptions`:
 | Rule | What |
 |---|---|
 | `noExplicitAny` | `any` in annotations is an error |
-| `noNonNullAssertion` | `x!` is an error |
+| `noNonNullAssertion` | `x!.y` is an error |
 | `noDefaultExport` | Forces named exports |
 | `useImportType` | Forces `import type` for type-only imports |
 | `noParameterAssign` | No mutation of function parameters |

package/assets/lithermes-plugin/skills/lit-code/scripts/typescript/check-no-excuse-rules.ts

@@ -8,7 +8,7 @@
  *   no-ts-ignore            - `@ts-ignore` comments
  *   no-ts-expect-error      - `@ts-expect-error` comments
  *   no-enum                 - `enum` declarations
- *   no-non-null-assertion   - `x!` postfix operator
+ *   no-non-null-assertion   - `x!.y` postfix operator
  *   no-throw-literal        - `throw "string"` / `throw 123`
  *   no-mutable-export       - `export let` / `export var`
  *   no-any-annotation       - `: any` in annotations (opt out: `// no-excuse-ok: any`)
@@ -140,7 +140,7 @@ function analyzeFile(filePath: string): Violation[] {
     // ── x! non-null assertion ──
     if (ts.isNonNullExpression(node)) {
       const p = pos(node)
-      violations.push({ ruleId: "no-non-null-assertion", filePath, ...p, message: "`x!` — use narrowing or optional chaining" })
+      violations.push({ ruleId: "no-non-null-assertion", filePath, ...p, message: "`x!.y` — use narrowing or optional chaining" })
     }
 
     // ── throw "literal" ──

package/assets/lithermes-plugin/skills/readme-studio/templates/remotion/package-lock.json

@@ -3771,9 +3771,9 @@
       "license": "ISC"
     },
     "node_modules/zod": {
-      "version": "4.5.4",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-4.5.4.tgz",
-      "integrity": "sha512-sC95tT5iHHH9gtpj6A81kh+NEaRAUFN+qlUPDUbRfOMvNf5QCBqsb3WgvnpVtK5Y+4UfA6KqufotuTvMGiTlsA==",
+      "version": "4.6.6",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.6.6.tgz",
+      "integrity": "sha512-4UmzQUF5fxvfcYHlbjBmejU+w+hbDnWFx4aS8kBx7nPBHcO2SqPbpAG8snbdg+Xse4pRefR98hgjFgIMCI/UhA==",
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"