@rmrdeveloper/sideroom-pi 8.5.0 → 8.7.0

package/README.md

@@ -121,7 +121,7 @@ chat. It never creates a repository task file or a `/todos` command.
 - Widget: at most five rows — open items before resolved ones, the
   `in_progress` row always visible — plus a `…+N more · F9: view all` hint.
   `F9` opens the full board as a read-only overlay, so the widget stays small
-  without hiding work from you; the agent still gets every item in its prompt.
+  without hiding work from you; the agent still gets every item in its context.
 
 ### Edited files — proof, not promises
 

package/extensions/ask/index.ts

@@ -15,8 +15,8 @@ export const ASK_PROMPT_SNIPPET =
   'Ask the user one or more questions with a recommended option, in their language.';
 
 export const ASK_PROMPT_GUIDELINES = [
-  'When a non-trivial request is not yet a settled spec, follow the sideroom-grill skill before implementing; it owns the interview and drives sideroom_ask rounds. One sideroom_ask call is one batch; call it again for another round.',
-  'A decision the repository already settles consistently is a project fact: read the code and reuse it. A decision that materially affects architecture, dependencies, cost, security, operations, persistence, public contracts, or future change difficulty is an architectural decision: expose it through sideroom_ask before committing, with the practical consequences of each alternative and one recommendation that carries a one-line justification, never a list of technology names. If the repository shows two inconclusive patterns for the same kind of decision, name the inconsistency in the prompt. Everything else is a minor decision: take it yourself.',
+  'When a non-trivial request is not yet a settled spec, follow the sideroom-grill skill before implementing; it drives sideroom_ask rounds. One sideroom_ask call is one batch; call it again for another round.',
+  'A decision the repository already settles consistently is a project fact: read the code and reuse it. A decision that materially affects architecture, dependencies, cost, security, operations, persistence, public contracts, or future change difficulty is an architectural decision: never assume it; follow the sideroom-architecture skill and expose it through sideroom_ask before committing, with the practical consequences of each alternative and one recommendation carrying a one-line justification, never technology names. If the repository shows two inconclusive patterns for the same decision, name the inconsistency in the prompt. Everything else is a minor decision: take it yourself.',
   'Write sideroom_ask prompts, tab labels, option labels, and option descriptions in the language the user is speaking; keep ids and option values in English.',
   'sideroom_ask always adds Out of scope and a write-your-own answer; never send them yourself. A single-selection question needs recommendationIndex; a multiple-selection question needs recommendedIndices and never recommendationIndex.',
   'sideroom_ask only works in the interactive TUI; it errors in print, JSON, and RPC modes.',

package/extensions/done/detect.ts

@@ -157,6 +157,30 @@ function shellOperatorAt(
   return undefined;
 }
 
+export function hasTestSetup(cwd: string): boolean {
+  if (hasPackageTestScript(cwd)) {
+    return true;
+  }
+  if (
+    existsSync(join(cwd, 'pyproject.toml')) ||
+    existsSync(join(cwd, 'setup.py'))
+  ) {
+    return true;
+  }
+  if (existsSync(join(cwd, 'go.mod'))) {
+    return true;
+  }
+  return existsSync(join(cwd, 'Cargo.toml'));
+}
+
+function hasPackageTestScript(cwd: string): boolean {
+  const packagePath = join(cwd, 'package.json');
+  if (!existsSync(packagePath)) {
+    return false;
+  }
+  return typeof readScripts(packagePath).test === 'string';
+}
+
 function detectPackageCommand(cwd: string): CheckCommand | undefined {
   const packagePath = join(cwd, 'package.json');
   if (!existsSync(packagePath)) {

package/extensions/done/guard.ts

@@ -11,6 +11,11 @@ import {
   DONE_GATE_TYPE,
   type DoneState,
   formatDoneSteer,
+  formatMissingTestNotice,
+  isSourcePath,
+  isTestPath,
+  MISSING_TEST_NOTICE_TYPE,
+  shouldNoticeMissingTest,
   shouldSteerDone,
 } from './model.ts';
 
@@ -18,18 +23,29 @@ export type ResolveCommand = (
   ctx: Pick<ExtensionContext, 'cwd'>,
 ) => CheckCommand | undefined;
 
+export type ResolveTestSetup = (ctx: Pick<ExtensionContext, 'cwd'>) => boolean;
+
 export function registerDoneGuard(
   pi: ExtensionAPI,
   state: DoneState,
   resolveCommand: ResolveCommand,
+  resolveTestSetup: ResolveTestSetup,
 ): void {
   const checkRuns = new Set<string>();
+  const mutationPaths = new Map<string, string>();
 
   pi.on('turn_start', () => {
     state.steeredThisTurn = false;
   });
 
   pi.on('tool_call', (event, ctx) => {
+    if (
+      isToolCallEventType('write', event) ||
+      isToolCallEventType('edit', event)
+    ) {
+      mutationPaths.set(event.toolCallId, event.input.path);
+      return;
+    }
     if (!isToolCallEventType('bash', event)) {
       return;
     }
@@ -44,10 +60,14 @@ export function registerDoneGuard(
 
   pi.on('tool_result', (event) => {
     if (isWriteToolResult(event) || isEditToolResult(event)) {
-      if (!event.isError) {
-        state.mutated = true;
-        state.checksGreen = false;
+      const path = mutationPaths.get(event.toolCallId);
+      mutationPaths.delete(event.toolCallId);
+      if (event.isError) {
+        return;
       }
+      state.mutated = true;
+      state.checksGreen = false;
+      recordMutationPath(state, path);
       return;
     }
     if (isBashToolResult(event)) {
@@ -60,18 +80,45 @@ export function registerDoneGuard(
 
   pi.on('turn_end', (_event, ctx) => {
     const check = resolveCommand(ctx);
-    if (check === undefined || !shouldSteerDone(state, true)) {
+    if (check !== undefined && shouldSteerDone(state, true)) {
+      state.steeredThisTurn = true;
+      state.steerCount += 1;
+      pi.sendMessage(
+        {
+          customType: DONE_GATE_TYPE,
+          content: formatDoneSteer(check.display),
+          display: false,
+        },
+        { triggerTurn: true, deliverAs: 'steer' },
+      );
+      return;
+    }
+
+    if (!shouldNoticeMissingTest(state, resolveTestSetup(ctx))) {
       return;
     }
-    state.steeredThisTurn = true;
+    state.noticedMissingTest = true;
     state.steerCount += 1;
     pi.sendMessage(
       {
-        customType: DONE_GATE_TYPE,
-        content: formatDoneSteer(check.display),
+        customType: MISSING_TEST_NOTICE_TYPE,
+        content: formatMissingTestNotice(),
         display: false,
       },
       { triggerTurn: true, deliverAs: 'steer' },
     );
   });
 }
+
+function recordMutationPath(state: DoneState, path: string | undefined): void {
+  if (path === undefined) {
+    return;
+  }
+  if (isTestPath(path)) {
+    state.mutatedTest = true;
+    return;
+  }
+  if (isSourcePath(path)) {
+    state.mutatedSource = true;
+  }
+}

package/extensions/done/index.ts

@@ -2,14 +2,23 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from '@earendil-works/pi-coding-agent';
-import { type CheckCommand, detectCheckCommand } from './detect.ts';
-import { type ResolveCommand, registerDoneGuard } from './guard.ts';
+import {
+  type CheckCommand,
+  detectCheckCommand,
+  hasTestSetup,
+} from './detect.ts';
+import {
+  type ResolveCommand,
+  type ResolveTestSetup,
+  registerDoneGuard,
+} from './guard.ts';
 import { createDoneState, resetDoneRun } from './model.ts';
 
 // Pi loads extensions/*/index.ts through export default.
 export default function registerDone(pi: ExtensionAPI): void {
   const state = createDoneState();
   const cache = new Map<string, CheckCommand | undefined>();
+  const testCache = new Map<string, boolean>();
   const resolveCommand: ResolveCommand = (
     ctx: Pick<ExtensionContext, 'cwd'>,
   ) => {
@@ -20,8 +29,19 @@ export default function registerDone(pi: ExtensionAPI): void {
     cache.set(ctx.cwd, command);
     return command;
   };
+  const resolveTestSetup: ResolveTestSetup = (
+    ctx: Pick<ExtensionContext, 'cwd'>,
+  ) => {
+    const cached = testCache.get(ctx.cwd);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const hasTests = hasTestSetup(ctx.cwd);
+    testCache.set(ctx.cwd, hasTests);
+    return hasTests;
+  };
 
-  registerDoneGuard(pi, state, resolveCommand);
+  registerDoneGuard(pi, state, resolveCommand, resolveTestSetup);
 
   pi.on('input', (event) => {
     if (event.source === 'interactive' || event.source === 'rpc') {

package/extensions/done/model.ts

@@ -3,18 +3,35 @@ export interface DoneState {
   checksGreen: boolean;
   steeredThisTurn: boolean;
   steerCount: number;
+  mutatedSource: boolean;
+  mutatedTest: boolean;
+  noticedMissingTest: boolean;
 }
 
 export const MAX_DONE_STEERS = 2;
 
 export const DONE_GATE_TYPE = 'sideroom-done-gate';
 
+export const MISSING_TEST_NOTICE_TYPE = 'sideroom-missing-test-notice';
+
+const TEST_DIRECTORY = /(?:^|\/)(?:__tests__|tests?|specs?)(?:\/|$)/;
+
+// Test paths are recognised by name only: the notice never claims the right
+// test exists, so a missed convention only costs a nudge, never a false pass.
+const TEST_FILE =
+  /(?:^|\/)(?:test_[\w.-]*\.py|[\w.-]*[._](?:test|spec)\.[\w.-]+|[\w.-]*(?:Test|Tests)\.java)$/;
+
+const SOURCE_FILE = /\.(?:[cm]?js|jsx|ts|tsx|go|java|php|py|rs)$/i;
+
 export function createDoneState(): DoneState {
   return {
     mutated: false,
     checksGreen: false,
     steeredThisTurn: false,
     steerCount: 0,
+    mutatedSource: false,
+    mutatedTest: false,
+    noticedMissingTest: false,
   };
 }
 
@@ -23,6 +40,19 @@ export function resetDoneRun(state: DoneState): void {
   state.checksGreen = false;
   state.steeredThisTurn = false;
   state.steerCount = 0;
+  state.mutatedSource = false;
+  state.mutatedTest = false;
+  state.noticedMissingTest = false;
+}
+
+export function isTestPath(path: string): boolean {
+  const normalized = path.replaceAll('\\', '/');
+  return TEST_DIRECTORY.test(normalized) || TEST_FILE.test(normalized);
+}
+
+export function isSourcePath(path: string): boolean {
+  const normalized = path.replaceAll('\\', '/');
+  return SOURCE_FILE.test(normalized);
 }
 
 export function shouldSteerDone(
@@ -38,6 +68,23 @@ export function shouldSteerDone(
   );
 }
 
+export function shouldNoticeMissingTest(
+  state: DoneState,
+  hasTests: boolean,
+): boolean {
+  return (
+    hasTests &&
+    state.mutatedSource &&
+    !state.mutatedTest &&
+    !state.noticedMissingTest &&
+    state.steerCount < MAX_DONE_STEERS
+  );
+}
+
 export function formatDoneSteer(display: string): string {
   return `Run \`${display}\` and make it pass before finishing.`;
 }
+
+export function formatMissingTestNotice(): string {
+  return 'This run changed code files and no test file. Add or update the test that covers the change before finishing.';
+}

package/extensions/rules/catalog.ts

@@ -18,19 +18,23 @@ export type LanguageId = (typeof LANGUAGE)[keyof typeof LANGUAGE];
 
 export type RuleId =
   | 'braced-conditionals'
+  | 'explicit-any'
   | 'explicit-error-handling'
   | 'clear-names'
   | 'comments'
-  | 'debug-artifacts';
+  | 'debug-artifacts'
+  | 'suppressed-type-errors';
 
 export type RuleSeverity = (typeof SEVERITY)[keyof typeof SEVERITY];
 
 export const RULE_SEVERITY: Readonly<Record<RuleId, RuleSeverity>> = {
   'braced-conditionals': SEVERITY.block,
+  'explicit-any': SEVERITY.block,
   'explicit-error-handling': SEVERITY.block,
   'clear-names': SEVERITY.warn,
   comments: SEVERITY.warn,
   'debug-artifacts': SEVERITY.warn,
+  'suppressed-type-errors': SEVERITY.warn,
 };
 
 export function languageForPath(path: string): LanguageId {
@@ -69,3 +73,7 @@ export function languageForPath(path: string): LanguageId {
 export function supportsBracedConditionals(language: LanguageId): boolean {
   return language !== LANGUAGE.python && language !== LANGUAGE.generic;
 }
+
+export function supportsExplicitAny(language: LanguageId): boolean {
+  return language === LANGUAGE.typescript;
+}

package/extensions/rules/checks.ts

@@ -4,6 +4,7 @@ import {
   RULE_SEVERITY,
   type RuleId,
   supportsBracedConditionals,
+  supportsExplicitAny,
 } from './catalog.ts';
 import { maskNonCode } from './lexer.ts';
 import type { AddedLine, RuleViolation } from './model.ts';
@@ -38,6 +39,29 @@ const DEBUG_PATTERNS: readonly RegExp[] = [
   /\bdbg!\s*\(/,
 ];
 
+// Keep these patterns on syntax that can only introduce a type. Value-level
+// commas, assignments, and operators may legally surround an identifier named
+// `any`, so they are deliberately absent.
+const EXPLICIT_ANY_PATTERNS: readonly RegExp[] = [
+  /\bas\s+any\b/,
+  /\b(?:keyof|satisfies)\s+any\b/,
+  /\bany\s*\[\s*\]/,
+  /\b[$\w]+<[^<>\n]*\bany\b[^<>\n]*>(?!\s*[$\w])/,
+  /\binterface\s+[$\w]+(?:\s*<[^;{\n]*>)?\s*\{[^}\n]*:\s*[^;}\n]*\bany\b/,
+  /\b(?:const|let|var)\s+[$\w]+\s*:\s*(?:(?:=>)|[^;=\n])*\bany\b/,
+  /(?:^|[(,])\s*(?:\.\.\.)?[$\w]+\??\s*:\s*(?:(?:=>)|[^;=\n])*\bany\b/,
+  /\)\s*:\s*(?:(?:=>)|[^;={\n])*\bany\b/,
+  /^\s*(?:(?:public|private|protected|readonly|static|declare|abstract)\s+)*[$\w]+[?!]?\s*:\s*(?:(?:=>)|[^;,=\n])*\bany\b[^;=\n]*(?:;|=)/,
+];
+
+// A suppression is a comment whose first token is the directive; prose that
+// mentions the directive, or a string that quotes it, is not one.
+const SUPPRESSED_TYPE_ERRORS =
+  /(?:^|\s)(?:\/\/|\/\*)\s*@ts-(?:ignore|nocheck)\b/;
+
+const TYPE_ALIAS = /\btype\s+[$\w]+(?:\s*<[^;=]*>)?\s*=/g;
+const ANY_TOKEN = /\bany\b/g;
+
 const FUNCTION_PARAMS: readonly RegExp[] = [
   /\bfunction\s+\w*\s*\(([^()]*)\)/g,
   /\bdef\s+\w+\s*\(([^()]*)\)/g,
@@ -54,10 +78,17 @@ export function evaluateAddedLines(
   const code = maskNonCode(joined, language);
   const codeLines = code.split('\n');
   const usesBracedConditionals = supportsBracedConditionals(language);
+  const usesExplicitAny = supportsExplicitAny(language);
+  const commentLines = usesExplicitAny
+    ? maskNonCode(joined, language, { keepComments: true }).split('\n')
+    : [];
 
   if (usesBracedConditionals) {
     collectBracedConditionals(code, lines, violations);
   }
+  if (usesExplicitAny) {
+    collectTypeAliasAny(code, lines, violations);
+  }
 
   for (let index = 0; index < lines.length; index += 1) {
     const added = lines[index];
@@ -71,6 +102,13 @@ export function evaluateAddedLines(
     if (language === LANGUAGE.python) {
       collectPythonSuite(codeLine, violations);
     }
+    if (usesExplicitAny) {
+      collectExplicitAny(codeLine, violations);
+      collectSuppressedTypeErrors(
+        { line: added.line, text: commentLines[index] ?? '' },
+        violations,
+      );
+    }
     collectClearNames(codeLine, violations);
     collectComments(added, violations);
     collectDebugArtifacts(codeLine, violations);
@@ -274,6 +312,123 @@ function collectDebugArtifacts(
   }
 }
 
+function collectExplicitAny(
+  codeLine: AddedLine,
+  violations: RuleViolation[],
+): void {
+  const typeCode = codeLine.text
+    .replaceAll(/\btypeof\s+any\b/g, (match) => ' '.repeat(match.length))
+    .replaceAll(/^\s*(?:import|export)\s*\{[^}]*\}/g, (match) =>
+      ' '.repeat(match.length),
+    );
+  if (EXPLICIT_ANY_PATTERNS.some((pattern) => pattern.test(typeCode))) {
+    violations.push(
+      violation(
+        'explicit-any',
+        "[explicit-any] Replace 'any' with the type the value actually has; use 'unknown' only when it must be narrowed first.",
+        codeLine.line,
+      ),
+    );
+  }
+}
+
+function collectTypeAliasAny(
+  code: string,
+  lines: readonly AddedLine[],
+  violations: RuleViolation[],
+): void {
+  const aliases = code.matchAll(
+    new RegExp(TYPE_ALIAS.source, TYPE_ALIAS.flags),
+  );
+  for (const alias of aliases) {
+    const bodyOffset = (alias.index ?? 0) + alias[0].length;
+    const endOffset = typeAliasEndOffset(code, bodyOffset);
+    const body = code.slice(bodyOffset, endOffset);
+    for (const anyMatch of body.matchAll(
+      new RegExp(ANY_TOKEN.source, ANY_TOKEN.flags),
+    )) {
+      const anyOffset = bodyOffset + (anyMatch.index ?? 0);
+      if (isValueLevelAnyInType(code, anyOffset)) {
+        continue;
+      }
+      violations.push(
+        violation(
+          'explicit-any',
+          "[explicit-any] Replace 'any' with the type the value actually has; use 'unknown' only when it must be narrowed first.",
+          lineForOffset(code, lines, anyOffset),
+        ),
+      );
+    }
+  }
+}
+
+function typeAliasEndOffset(code: string, bodyOffset: number): number {
+  let braceDepth = 0;
+  let bracketDepth = 0;
+  let parenthesisDepth = 0;
+  for (let index = bodyOffset; index < code.length; index += 1) {
+    const character = code[index];
+    if (character === '{') {
+      braceDepth += 1;
+      continue;
+    }
+    if (character === '}') {
+      braceDepth -= 1;
+      continue;
+    }
+    if (character === '[') {
+      bracketDepth += 1;
+      continue;
+    }
+    if (character === ']') {
+      bracketDepth -= 1;
+      continue;
+    }
+    if (character === '(') {
+      parenthesisDepth += 1;
+      continue;
+    }
+    if (character === ')') {
+      parenthesisDepth -= 1;
+      continue;
+    }
+    if (
+      character === ';' &&
+      braceDepth === 0 &&
+      bracketDepth === 0 &&
+      parenthesisDepth === 0
+    ) {
+      return index;
+    }
+  }
+  return code.length;
+}
+
+function isValueLevelAnyInType(code: string, anyOffset: number): boolean {
+  const prefix = code.slice(0, anyOffset);
+  if (/\btypeof\s*$/.test(prefix) || /\.\s*$/.test(prefix)) {
+    return true;
+  }
+  const suffix = code.slice(anyOffset + 'any'.length);
+  return /^\s*\??\s*(?::|\()/.test(suffix);
+}
+
+function collectSuppressedTypeErrors(
+  commentLine: AddedLine,
+  violations: RuleViolation[],
+): void {
+  if (!SUPPRESSED_TYPE_ERRORS.test(commentLine.text)) {
+    return;
+  }
+  violations.push(
+    violation(
+      'suppressed-type-errors',
+      "[suppressed-type-errors] Replace '@ts-ignore' or '@ts-nocheck' with '@ts-expect-error' and an explanation, or fix the type.",
+      commentLine.line,
+    ),
+  );
+}
+
 function closingParenthesisOffset(
   code: string,
   openingOffset: number,

package/extensions/rules/lexer.ts

@@ -9,8 +9,18 @@ const LEXICAL_MODE = {
 
 type LexicalMode = (typeof LEXICAL_MODE)[keyof typeof LEXICAL_MODE];
 
-export function maskNonCode(source: string, language: LanguageId): string {
+export interface MaskOptions {
+  /** Keep comment text so a caller can read the directives inside it. */
+  readonly keepComments?: boolean;
+}
+
+export function maskNonCode(
+  source: string,
+  language: LanguageId,
+  options: MaskOptions = {},
+): string {
   const masked = [...source];
+  const keepComments = options.keepComments === true;
   let mode: LexicalMode = LEXICAL_MODE.code;
   let delimiter = '';
 
@@ -22,20 +32,20 @@ export function maskNonCode(source: string, language: LanguageId): string {
         mode = LEXICAL_MODE.code;
         continue;
       }
-      maskCharacter(masked, index);
+      maskComment(masked, index, keepComments);
       continue;
     }
 
     if (mode === LEXICAL_MODE.blockComment) {
       const closesComment = character === '*' && source[index + 1] === '/';
       if (closesComment) {
-        maskCharacter(masked, index);
-        maskCharacter(masked, index + 1);
+        maskComment(masked, index, keepComments);
+        maskComment(masked, index + 1, keepComments);
         index += 1;
         mode = LEXICAL_MODE.code;
         continue;
       }
-      maskCharacter(masked, index);
+      maskComment(masked, index, keepComments);
       continue;
     }
 
@@ -58,7 +68,7 @@ export function maskNonCode(source: string, language: LanguageId): string {
         mode = LEXICAL_MODE.code;
         continue;
       }
-      if (delimiter.length === 1 && character === '\n') {
+      if (delimiter !== '`' && character === '\n') {
         mode = LEXICAL_MODE.code;
         continue;
       }
@@ -68,8 +78,8 @@ export function maskNonCode(source: string, language: LanguageId): string {
 
     const startsLineComment = character === '/' && source[index + 1] === '/';
     if (startsLineComment) {
-      maskCharacter(masked, index);
-      maskCharacter(masked, index + 1);
+      maskComment(masked, index, keepComments);
+      maskComment(masked, index + 1, keepComments);
       index += 1;
       mode = LEXICAL_MODE.lineComment;
       continue;
@@ -77,8 +87,8 @@ export function maskNonCode(source: string, language: LanguageId): string {
 
     const startsBlockComment = character === '/' && source[index + 1] === '*';
     if (startsBlockComment) {
-      maskCharacter(masked, index);
-      maskCharacter(masked, index + 1);
+      maskComment(masked, index, keepComments);
+      maskComment(masked, index + 1, keepComments);
       index += 1;
       mode = LEXICAL_MODE.blockComment;
       continue;
@@ -87,7 +97,7 @@ export function maskNonCode(source: string, language: LanguageId): string {
     const startsHashComment =
       character === '#' && supportsHashComments(language);
     if (startsHashComment) {
-      maskCharacter(masked, index);
+      maskComment(masked, index, keepComments);
       mode = LEXICAL_MODE.lineComment;
       continue;
     }
@@ -134,3 +144,14 @@ function maskCharacter(masked: string[], index: number): void {
     masked[index] = ' ';
   }
 }
+
+function maskComment(
+  masked: string[],
+  index: number,
+  keepComments: boolean,
+): void {
+  if (keepComments) {
+    return;
+  }
+  maskCharacter(masked, index);
+}

package/extensions/todo/index.ts

@@ -50,7 +50,7 @@ export default function registerTodo(pi: ExtensionAPI): void {
     notifyWidgetRefresh(ctx);
   };
 
-  registerSessionRefreshEvents(pi, restoreAndRefresh);
+  registerSessionRefreshEvents(pi, store, restoreAndRefresh);
   registerGuardEvents(pi, store, restore);
   registerBoardContext(pi, store, restoreAndRefresh);
   registerTodoTool(pi, store, notifyWidgetRefresh);

package/extensions/todo/session.ts

@@ -13,11 +13,13 @@ import {
 import { renderTodoWidget } from './ui.ts';
 
 export const SNAPSHOT_TYPE = 'sideroom-todo';
+export const BOARD_MESSAGE_TYPE = 'sideroom-todo-board';
 export const WIDGET_KEY = 'sideroom-todo';
 export const TODO_WIDGET_REFRESH_EVENT = 'sideroom:todo-widget-refreshed';
 
 export interface TodoStore {
   items: readonly TodoItem[];
+  lastSentBlock?: string;
 }
 
 export type BoardLifecycle = (ctx: ExtensionContext) => void;
@@ -89,11 +91,29 @@ export function commitBoard(
 
 export function registerSessionRefreshEvents(
   pi: ExtensionAPI,
+  store: TodoStore,
   restoreAndRefresh: BoardLifecycle,
 ): void {
-  pi.on('session_start', (_event, ctx) => restoreAndRefresh(ctx));
-  pi.on('session_tree', (_event, ctx) => restoreAndRefresh(ctx));
-  pi.on('session_compact', (_event, ctx) => restoreAndRefresh(ctx));
+  // A restore can drop the sent block from the model's context, so an unchanged
+  // board still has to be announced again.
+  const restoreSession = (ctx: ExtensionContext) => {
+    restoreAndRefresh(ctx);
+    forgetSentBoardBlock(store);
+  };
+  pi.on('session_start', (_event, ctx) => restoreSession(ctx));
+  pi.on('session_tree', (_event, ctx) => restoreSession(ctx));
+  pi.on('session_compact', (event, ctx) => {
+    restoreSession(ctx);
+    if (!event.willRetry) {
+      return;
+    }
+    const block = pendingBoardBlock(store);
+    if (block === undefined) {
+      return;
+    }
+    store.lastSentBlock = block;
+    pi.sendMessage(boardMessage(block), { deliverAs: 'steer' });
+  });
 }
 
 export function registerBoardContext(
@@ -101,17 +121,46 @@ export function registerBoardContext(
   store: TodoStore,
   restoreAndRefresh: BoardLifecycle,
 ): void {
-  pi.on('before_agent_start', (event, ctx) => {
+  pi.on('before_agent_start', (_event, ctx) => {
     restoreAndRefresh(ctx);
-    if (store.items.length === 0) {
+    const block = pendingBoardBlock(store);
+    if (block === undefined) {
       return;
     }
-    return {
-      systemPrompt: `${event.systemPrompt}\n\n${formatBoardBlock(store.items)}`,
-    };
+    store.lastSentBlock = block;
+    return { message: boardMessage(block) };
   });
 }
 
+// The block rides a session message instead of the system prompt: a volatile
+// system prompt invalidates the cached prefix of the whole request.
+function pendingBoardBlock(store: TodoStore): string | undefined {
+  if (store.items.length === 0) {
+    return undefined;
+  }
+  const block = formatBoardBlock(store.items);
+  if (block === store.lastSentBlock) {
+    return undefined;
+  }
+  return block;
+}
+
+function forgetSentBoardBlock(store: TodoStore): void {
+  store.lastSentBlock = undefined;
+}
+
+function boardMessage(block: string): {
+  customType: typeof BOARD_MESSAGE_TYPE;
+  content: string;
+  display: false;
+} {
+  return {
+    customType: BOARD_MESSAGE_TYPE,
+    content: block,
+    display: false,
+  };
+}
+
 function findSnapshotItems(
   branch: SessionBranch,
 ): readonly TodoItem[] | undefined {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rmrdeveloper/sideroom-pi",
-  "version": "8.5.0",
+  "version": "8.7.0",
   "description": "Pi coding-agent package that asks clarifying questions, shows a live todo board, enforces coding guidelines, and will not call it done while your checks are red.",
   "type": "module",
   "files": [
@@ -22,6 +22,7 @@
     "format": "biome format --write extensions scripts package.json biome.json commitlint.config.mjs .changeset/config.json",
     "format:check": "biome format extensions scripts package.json biome.json commitlint.config.mjs .changeset/config.json",
     "preview": "node scripts/render-preview.mjs",
+    "cache:report": "node scripts/cache-report.mjs",
     "check:if-blocks": "node scripts/check-if-blocks.mjs",
     "check": "npm run types && npm run check:if-blocks && biome check extensions scripts package.json biome.json commitlint.config.mjs .changeset/config.json && npm test"
   },
@@ -69,7 +70,8 @@
   },
   "pi": {
     "extensions": [
-      "./extensions"
+      "./extensions",
+      "!extensions/*.test.ts"
     ],
     "skills": [
       "./skills"

package/skills/sideroom-architecture/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: sideroom-architecture
+description: "Surface the architectural decisions a change forces so they are asked, not silently assumed. Use when a feature or change touches module boundaries, data ownership, integration contracts, failure behavior, quality attributes, operations, cost, lock-in, or reversibility, or when the user says the architecture is not settled. Do not use for a trivial or reversible change, a pure glossary lookup, or an already-closed spec."
+license: MIT
+metadata:
+  author: RMRdeveloper
+  version: "1.0"
+---
+
+# Sideroom architecture
+
+## Purpose
+
+An LLM's default failure is to assume the architecture and start typing. This
+skill forces the opposite: name the architectural decisions a change forces and
+ask the ones that matter, instead of picking them silently. It does not turn
+every change into an interrogation.
+
+## Activation Contract
+
+Load this skill when a change is about to commit an architectural decision:
+something that materially affects module boundaries, data ownership,
+integration contracts, failure behavior, quality attributes (latency,
+throughput, availability), operations, cost, lock-in, or the difficulty of
+changing course later. It runs under `sideroom-grill` for the architectural
+part of an interview, and on its own when only the architecture is open.
+
+Do not load it for a minor decision (reversible, no boundary or contract
+impact), or for a word conflict — that is `sideroom-domain-modeling`.
+
+## Hard Rules
+
+- Assume nothing architectural. When a change forces an architectural decision
+  the code does not already settle, expose it through `sideroom_ask` before
+  writing the code. Silent selection of an architectural default is the failure
+  this skill exists to prevent.
+- Pick the dimensions this decision actually touches; do not march the whole
+  catalog. Two sharp questions beat nine shallow ones. A dimension the change
+  does not touch is not asked.
+- Read the code first. A decision the repository already settles consistently
+  is a project fact: reuse it, never ask it. When the repository shows two
+  inconclusive patterns for the same kind of decision, name that inconsistency
+  in the prompt instead of picking one.
+- Quantify or decline. An architectural dimension does not close without a
+  number, a range, or an explicit `Out of scope` from the user. A decision
+  without a figure is a preference in disguise.
+- Every option of an architectural question carries a `description`: its
+  practical consequence, its cost, and the obligation it imposes. The label
+  names the choice; the description carries the trade-off. Never a one-word
+  technology label.
+- Present the decision as the current situation, the alternatives by their
+  practical consequences, and one recommendation with a one-line justification.
+  Never reduce it to technology names.
+- One open architectural dimension blocks implementation. `Out of scope` closes
+  a thread, is recorded, and is not re-asked.
+
+## Dimension catalog
+
+Reference, not a checklist. Pick only what the change touches; force a number or
+an explicit `Out of scope` on each one you pick.
+
+| Dimension | The question it forces |
+| --- | --- |
+| Boundaries | Which modules are in, which are out, which dependency direction is forbidden |
+| Data | What is the source of truth, who owns it, how the schema evolves and migrates |
+| Integration | Synchronous or asynchronous, backward compatibility, version window |
+| Quality attributes | Expected latency and volume, availability target — in figures |
+| Failure | What degrades, what retries, what must be idempotent |
+| Operations | How it deploys, how it rolls back, which signal warns it is going wrong |
+| Cost and lock-in | Operating cost, the cost of leaving the provider or dependency |
+| Ownership | Who maintains it, who responds when it breaks |
+| Reversibility | What reopens the decision, and how expensive undoing it is |
+
+## Execution Steps
+
+1. Read the code around the change. Settle every project fact from the
+   codebase, and note any inconsistent pattern to name in a prompt.
+2. List the architectural decisions the change forces. Drop the ones the code
+   already settles.
+3. For each remaining decision, pick the dimensions it touches and run one
+   `sideroom_ask` round: situation, alternatives by consequence, one
+   recommendation, each option with a `description`. Force a number or an
+   explicit `Out of scope`.
+4. Repeat rounds until no architectural dimension is open. Do not implement
+   with one open.
+5. Record an accepted decision as an ADR under `docs/adr/` only when it clears
+   the three `sideroom-domain-modeling` gates: hard to reverse, surprising
+   without context, the result of a real trade-off. The ADR names the rejected
+   alternatives and what reopens the decision.
+
+## Output Contract
+
+Before the first round: a one-line statement of what is built, what it touches,
+what is out. After the rounds: the architectural decisions closed with their
+figures, the dimensions marked out of scope, and any ADR written with its
+rejected alternatives and its revision trigger. No architectural default
+reaches the code without having been asked or read from the repository.
+
+## References
+
+- Driven by `sideroom-grill` for the architectural part of an interview; that
+  skill owns the interview, this one owns the architectural interrogation.
+- Hands qualifying decisions to `sideroom-domain-modeling` for the ADR
+  three-gate offer and records shared vocabulary through it.