@rmrdeveloper/sideroom-pi 8.11.0 → 8.12.0

package/extensions/jev/guard.ts

@@ -6,6 +6,7 @@ import {
   isWriteToolResult,
   type ToolCallEvent,
 } from '@earendil-works/pi-coding-agent';
+import { commandMatches, detectCheckCommand } from '../done/detect.ts';
 import {
   projectRelativePath,
   resolveFileToolPath,
@@ -14,7 +15,7 @@ import { readFileIfExists } from '../shared/read-file.ts';
 import { REVIEW_NOTE_EVENT, type ReviewNote } from '../shared/review-note.ts';
 import { startsUserTurn } from '../shared/settle.ts';
 import {
-  askJev,
+  askJevRequest,
   JEV_FAILURE,
   type JevFailure,
   type JevTransport,
@@ -24,12 +25,25 @@ import {
   type AddedLine,
   addedLinesForEdit,
   addedLinesForWrite,
+  buildRequestBody,
   findingKey,
   formatFindings,
   isReviewablePath,
   type JevFinding,
+  type JevRequestBody,
 } from './model.ts';
 
+import {
+  buildAskReview,
+  buildBoardReview,
+  completedItems,
+  completionIds,
+  createWorkflowEvidence,
+  recordFileEvidence,
+  resetWorkflowEvidence,
+  type WorkflowEvidence,
+} from './workflow.ts';
+
 export const JEV_TRANSIENT_FAILURE_LIMIT = 3;
 
 const MUTATION_KIND = {
@@ -64,6 +78,7 @@ export interface JevGuardState {
   rateLimitedThisTurn: boolean;
   lastModel: string | undefined;
   calls: number;
+  readonly evidence: WorkflowEvidence;
   readonly pending: Map<string, PendingMutation>;
   readonly notedThisTurn: Set<string>;
 }
@@ -81,6 +96,7 @@ export function createJevGuardState(): JevGuardState {
     rateLimitedThisTurn: false,
     lastModel: undefined,
     calls: 0,
+    evidence: createWorkflowEvidence(),
     pending: new Map(),
     notedThisTurn: new Set(),
   };
@@ -88,6 +104,7 @@ export function createJevGuardState(): JevGuardState {
 
 // The F10 screen calls this after the user stores a key or asks to retry.
 export function resetJevGuard(state: JevGuardState): void {
+  resetWorkflowEvidence(state.evidence);
   state.halted = undefined;
   state.transientFailures = 0;
   state.rateLimitedThisTurn = false;
@@ -96,6 +113,7 @@ export function resetJevGuard(state: JevGuardState): void {
 // Usage and per-turn memory belong to the active session: a new session starts
 // counting from zero. The breaker stays, because it tracks the key.
 export function resetJevSession(state: JevGuardState): void {
+  resetWorkflowEvidence(state.evidence);
   state.calls = 0;
   state.rateLimitedThisTurn = false;
   state.pending.clear();
@@ -131,6 +149,7 @@ export function registerJevGuard(
     if (!startsUserTurn(event)) {
       return;
     }
+    resetWorkflowEvidence(state.evidence);
     state.notedThisTurn.clear();
     state.rateLimitedThisTurn = false;
   });
@@ -145,7 +164,7 @@ export function registerJevGuard(
   // the previous content is gone. The body is read after, from disk.
   pi.on('tool_call', (event, ctx) => {
     const mutation = extractMutation(event, ctx.cwd);
-    if (mutation === undefined || !isWorthAsking(mutation)) {
+    if (mutation === undefined || !isReviewablePath(mutation.relativePath)) {
       return undefined;
     }
     state.pending.set(event.toolCallId, mutation);
@@ -155,48 +174,108 @@ export function registerJevGuard(
   pi.on('tool_result', async (event, ctx) => {
     const pending = state.pending.get(event.toolCallId);
     state.pending.delete(event.toolCallId);
-    if (pending === undefined || event.isError) {
-      return undefined;
-    }
-    if (!isWriteToolResult(event) && !isEditToolResult(event)) {
-      return undefined;
-    }
-
     const apiKey = dependencies.apiKey();
-    if (apiKey === undefined) {
-      dependencies.report(JEV_STATUS.noKey, ctx);
+    if (
+      apiKey === undefined ||
+      !shouldCallJev(state) ||
+      ctx.signal?.aborted === true
+    ) {
+      if (!event.isError && pending !== undefined && isWorthAsking(pending)) {
+        dependencies.report(
+          apiKey === undefined ? JEV_STATUS.noKey : guardStatus(state),
+          ctx,
+        );
+      }
       return undefined;
     }
-    if (!shouldCallJev(state)) {
-      dependencies.report(guardStatus(state), ctx);
+    if (event.isError) {
+      if (
+        event.toolName === 'bash' &&
+        typeof event.input.command === 'string'
+      ) {
+        const check = detectCheckCommand(ctx.cwd);
+        if (check !== undefined && commandMatches(event.input.command, check)) {
+          state.evidence.checks = 'failed';
+        }
+      }
       return undefined;
     }
-
-    const body = readFileIfExists(pending.absolutePath);
-    if (body === undefined) {
+    if (event.toolName === 'bash' && typeof event.input.command === 'string') {
+      const check = detectCheckCommand(ctx.cwd);
+      if (check !== undefined && commandMatches(event.input.command, check)) {
+        state.evidence.checks = 'passed';
+      }
       return undefined;
     }
-    if (ctx.signal?.aborted === true) {
-      return undefined;
+    let requestBody: JevRequestBody | undefined;
+    let subject: string;
+    if (event.toolName === 'sideroom_ask') {
+      if (
+        typeof event.details !== 'object' ||
+        event.details === null ||
+        !('cancelled' in event.details) ||
+        event.details.cancelled !== false
+      ) {
+        return undefined;
+      }
+      requestBody = buildAskReview(event.input);
+      subject = 'sideroom_ask';
+    } else if (event.toolName === 'sideroom_todo') {
+      const items = completedItems(event.details);
+      if (items === undefined) {
+        return undefined;
+      }
+      requestBody = buildBoardReview({
+        items,
+        evidence: state.evidence,
+        changedIds: completionIds(event.input),
+      });
+      subject = 'sideroom_todo';
+    } else {
+      if (
+        pending === undefined ||
+        (!isWriteToolResult(event) && !isEditToolResult(event))
+      ) {
+        return undefined;
+      }
+      subject = pending.relativePath;
+      state.evidence.checks = 'stale';
+      // Replace cached evidence even when this version no longer fits the budget.
+      state.evidence.files.delete(subject);
+      if (!isWorthAsking(pending)) {
+        state.evidence.partial = true;
+        return undefined;
+      }
+      const body = readFileIfExists(pending.absolutePath);
+      if (body === undefined) {
+        state.evidence.partial = true;
+        return undefined;
+      }
+      const fileState = buildContextualState(
+        ctx.cwd,
+        subject,
+        body,
+        pending.kind,
+        pending.lines,
+      );
+      if (fileState === undefined) {
+        state.evidence.partial = true;
+        return undefined;
+      }
+      recordFileEvidence(state.evidence, fileState);
+      requestBody = buildRequestBody(fileState);
     }
-    const fileState = buildContextualState(
-      ctx.cwd,
-      pending.relativePath,
-      body,
-      pending.kind,
-      pending.lines,
-    );
-    if (fileState === undefined) {
+    if (requestBody === undefined) {
       return undefined;
     }
 
     state.calls += 1;
-    const attempt = await askJev(
-      dependencies.transport,
+    const attempt = await askJevRequest({
+      transport: dependencies.transport,
       apiKey,
-      fileState,
-      ctx.signal,
-    );
+      requestBody,
+      signal: ctx.signal,
+    });
     if (attempt.failure !== undefined) {
       registerFailure(state, attempt.failure);
       dependencies.report(guardStatus(state), ctx);
@@ -211,14 +290,14 @@ export function registerJevGuard(
 
     const findings = attempt.findings ?? [];
     const fresh = findings.filter((finding) =>
-      isUnnoted(state, pending.relativePath, finding),
+      isUnnoted(state, subject, finding),
     );
     if (fresh.length === 0) {
       return undefined;
     }
-    markNoted(state, pending.relativePath, fresh);
+    markNoted(state, subject, fresh);
     const note: ReviewNote = {
-      text: formatFindings(pending.relativePath, fresh),
+      text: formatFindings(subject, fresh),
     };
     pi.events.emit(REVIEW_NOTE_EVENT, note);
     return undefined;

package/extensions/jev/model.ts

@@ -147,12 +147,70 @@ export const JEV_RULES: readonly JevRule[] = [
       },
     },
   },
+  {
+    id: 'testability',
+    question: {
+      type: NOUL_TYPE,
+      instructions:
+        'Do the added lines hardcode clock, network or randomness inside business logic, making deterministic tests difficult? Do not flag infrastructure adapters or entry points merely for using their own APIs.',
+      criteria: {
+        true: 'Business behavior directly depends on an uncontrollable external dependency with no visible injection point',
+        false:
+          'Dependencies are supplied, or the code is the adapter/composition boundary itself',
+      },
+    },
+  },
+  {
+    id: 'contract-compatibility',
+    question: {
+      type: NOUL_TYPE,
+      instructions:
+        'Do added lines change a function signature, return shape or behavior in a way that demonstrably conflicts with a supplied non-test consumer? Require a concrete mismatch in visible code; do not speculate about unseen callers.',
+      criteria: {
+        true: 'A supplied consumer calls or interprets the changed contract incompatibly',
+        false:
+          'Visible consumers remain compatible, or there is insufficient evidence',
+      },
+    },
+  },
+  {
+    id: 'test-quality',
+    question: {
+      type: NOUL_TYPE,
+      instructions:
+        'For behavior touched by the added lines, do supplied related tests have a demonstrable blind spot: assertions that cannot detect that behavior failing, or an explicit changed error branch left untested? Use both production and test bodies. Never infer absent repository coverage from missing files or partial context. Do not request tests that mirror implementation or cover unrelated code.',
+      criteria: {
+        true: 'Visible relevant tests fail to assert the changed observable behavior or a visible changed error case, with concrete evidence',
+        false:
+          'Assertions cover the behavior, the change is low-impact, or evidence is incomplete',
+      },
+    },
+  },
+  {
+    id: 'unnecessary-abstraction',
+    question: {
+      type: NOUL_TYPE,
+      instructions:
+        'Do the added lines introduce a demonstrably redundant layer or combine visibly different domain concepts solely for similar syntax? Require evidence in supplied bodies. A single caller, delegation, injection, compatibility or a clear responsibility is not by itself a violation. Never infer requirements are absent or recommend removing required behavior.',
+      criteria: {
+        true: 'The added abstraction duplicates an existing role without adding a contract, responsibility or testability, or mixes visibly distinct concepts',
+        false:
+          'It serves a present responsibility or contract, or evidence is insufficient',
+      },
+    },
+  },
 ];
 
+export function isTestPath(path: string): boolean {
+  return /(?:^|\/)(?:__tests__|tests?|specs?)\/|(?:[._-](?:test|spec)|_test)\.[^/]+$|(?:^|\/)test_[^/]+$|Test\.java$/u.test(
+    path,
+  );
+}
+
 export interface JevRelatedFile {
   readonly path: string;
   readonly body: string;
-  readonly relation: 'imported' | 'consumer';
+  readonly relation: 'imported' | 'consumer' | 'test';
 }
 
 export interface JevFileState {
@@ -173,7 +231,7 @@ export interface JevFileState {
 
 export interface JevRequestBody {
   readonly model: string;
-  readonly state: JevFileState;
+  readonly state: unknown;
   readonly questions: Readonly<Record<string, JevNoulQuestion>>;
 }
 
@@ -225,14 +283,17 @@ export function isReviewablePath(path: string): boolean {
 }
 
 export function stateFitsBudget(state: JevFileState): boolean {
-  const request = buildRequestBody(state);
+  return requestFitsBudget(buildRequestBody(state));
+}
+
+export function requestFitsBudget(request: JevRequestBody): boolean {
   const longestQuestion = Object.values(request.questions).reduce(
     (longest, question) =>
       Math.max(longest, Buffer.byteLength(JSON.stringify(question))),
     0,
   );
   return (
-    Buffer.byteLength(JSON.stringify(state)) + longestQuestion <=
+    Buffer.byteLength(JSON.stringify(request.state)) + longestQuestion <=
       MAX_STATE_BYTES &&
     Buffer.byteLength(JSON.stringify(request)) <= MAX_REQUEST_BYTES
   );
@@ -243,6 +304,15 @@ export function buildRequestBody(file: JevFileState): JevRequestBody {
   const hasImportedFile = file.context.files.some(
     (related) => related.relation === 'imported',
   );
+  const hasConsumer = file.context.files.some(
+    (related) => related.relation === 'consumer' && !isTestPath(related.path),
+  );
+  const hasTest =
+    isTestPath(file.file.path) ||
+    file.context.files.some((related) => isTestPath(related.path));
+  const hasProduction =
+    !isTestPath(file.file.path) ||
+    file.context.files.some((related) => !isTestPath(related.path));
   const addedText = file.change.addedLines.join('\n');
   for (const rule of JEV_RULES) {
     if (rule.id === 'dependency-direction' && !hasImportedFile) {
@@ -251,6 +321,12 @@ export function buildRequestBody(file: JevFileState): JevRequestBody {
     if (rule.id === 'comments' && !/(?:\/\/|\/\*|#)/u.test(addedText)) {
       continue;
     }
+    if (rule.id === 'contract-compatibility' && !hasConsumer) {
+      continue;
+    }
+    if (rule.id === 'test-quality' && (!hasTest || !hasProduction)) {
+      continue;
+    }
     questions[rule.id] = rule.question;
   }
   return { model: JEV_MODEL, state: file, questions };
@@ -274,15 +350,17 @@ export function readFindings(
     return [];
   }
   const findings: JevFinding[] = [];
-  for (const rule of JEV_RULES) {
-    if (!askedRuleIds.has(rule.id)) {
-      continue;
-    }
-    const answer = answers[rule.id];
-    if (answer === undefined || answer.noul < VIOLATION_PROBABILITY) {
+  for (const ruleId of askedRuleIds) {
+    const answer = answers[ruleId];
+    if (
+      answer === undefined ||
+      !Number.isFinite(answer.noul) ||
+      answer.noul > 1 ||
+      answer.noul < VIOLATION_PROBABILITY
+    ) {
       continue;
     }
-    findings.push({ ruleId: rule.id, probability: answer.noul });
+    findings.push({ ruleId, probability: answer.noul });
   }
   return findings;
 }
@@ -299,7 +377,7 @@ export function formatFindings(
     `Sideroom Jev review flagged ${path}:`,
     ...findings.map(
       (finding) =>
-        `- [${finding.ruleId}] Jev scored ${finding.probability.toFixed(2)} probability that the added lines break this rule. Verify against the loaded guide before changing anything.`,
+        `- [${finding.ruleId}] Jev scored ${finding.probability.toFixed(2)} probability of a review concern. Verify the supplied evidence and applicable contract against the loaded guide before changing anything. Missing context is not proof of a violation.`,
     ),
   ].join('\n');
 }

package/extensions/jev/workflow.ts

@@ -0,0 +1,188 @@
+import { type AskParams, parseAskParams } from '../ask/model.ts';
+import {
+  parseTodoParams,
+  TODO_STATUS,
+  type TodoItem,
+  type TodoToolParameters,
+} from '../todo/model.ts';
+import {
+  JEV_MODEL,
+  type JevFileState,
+  type JevNoulQuestion,
+  type JevRequestBody,
+  requestFitsBudget,
+} from './model.ts';
+
+const MAX_EVIDENCE_FILES = 4;
+
+type ChangedFileEvidence = Pick<JevFileState, 'file' | 'change'>;
+
+export interface WorkflowEvidence {
+  readonly files: Map<string, ChangedFileEvidence>;
+  readonly completed: Map<string, string>;
+  partial: boolean;
+  checks: 'unknown' | 'passed' | 'failed' | 'stale';
+}
+
+export function createWorkflowEvidence(): WorkflowEvidence {
+  return {
+    files: new Map(),
+    completed: new Map(),
+    partial: false,
+    checks: 'unknown',
+  };
+}
+
+export function resetWorkflowEvidence(evidence: WorkflowEvidence): void {
+  evidence.files.clear();
+  evidence.completed.clear();
+  evidence.partial = false;
+  evidence.checks = 'unknown';
+}
+
+export function recordFileEvidence(
+  evidence: WorkflowEvidence,
+  file: JevFileState,
+): void {
+  evidence.checks = 'stale';
+  evidence.files.delete(file.file.path);
+  evidence.files.set(file.file.path, { file: file.file, change: file.change });
+  if (evidence.files.size > MAX_EVIDENCE_FILES) {
+    const oldest = evidence.files.keys().next().value;
+    if (oldest !== undefined) {
+      evidence.files.delete(oldest);
+    }
+    evidence.partial = true;
+  }
+}
+
+function question(instructions: string, violation: string): JevNoulQuestion {
+  return {
+    type: 'noul',
+    instructions,
+    criteria: {
+      true: violation,
+      false:
+        'No concrete contradiction is visible, or the supplied evidence is insufficient',
+    },
+  };
+}
+
+export function buildAskReview(input: unknown): JevRequestBody | undefined {
+  const parsed = parseAskParams(input as AskParams);
+  if (!parsed.ok) {
+    return undefined;
+  }
+  const request: JevRequestBody = {
+    model: JEV_MODEL,
+    state: { kind: 'questionnaire', questions: parsed.questions },
+    questions: {
+      'question-options': question(
+        'Do the supplied questions contain overlapping single-selection options or bundle independent decisions so no option can express a reasonable combination? Multiple selections may intentionally overlap. Judge only the question text, not unseen requirements.',
+        'The wording visibly prevents a clear independent choice',
+      ),
+      'question-recommendation': question(
+        'Does a recommended option claim factual certainty or decisive cost/performance figures without support in the supplied question, or contradict its stated constraints? A preference alone need not include proof. Do not assume unseen project evidence is absent; flag only a demonstrably unsupported assertion or contradiction in the wording.',
+        'The recommendation visibly contradicts stated constraints or asserts an unsupported decisive fact',
+      ),
+    },
+  };
+  return requestFitsBudget(request) ? request : undefined;
+}
+
+export function completedItems(
+  details: unknown,
+): readonly TodoItem[] | undefined {
+  if (typeof details !== 'object' || details === null || 'error' in details) {
+    return undefined;
+  }
+  const parsed = parseTodoParams({
+    action: 'propose',
+    items: 'items' in details ? details.items : undefined,
+  } as TodoToolParameters);
+  if (!parsed.ok || parsed.params.action !== 'propose') {
+    return undefined;
+  }
+  return parsed.params.items.filter(
+    (item) => item.status === TODO_STATUS.completed,
+  );
+}
+
+export function buildBoardReview({
+  items,
+  evidence,
+  changedIds,
+}: {
+  readonly items: readonly TodoItem[];
+  readonly evidence: WorkflowEvidence;
+  readonly changedIds?: ReadonlySet<string>;
+}): JevRequestBody | undefined {
+  const newlyCompleted = items.filter(
+    (item) =>
+      (changedIds === undefined || changedIds.has(item.id)) &&
+      evidence.completed.get(item.id) !== item.content,
+  );
+  evidence.completed.clear();
+  for (const item of items) {
+    evidence.completed.set(item.id, item.content);
+  }
+  if (
+    newlyCompleted.length === 0 ||
+    (evidence.files.size === 0 &&
+      evidence.checks !== 'passed' &&
+      evidence.checks !== 'failed')
+  ) {
+    return undefined;
+  }
+  const files: ChangedFileEvidence[] = [];
+  const state = {
+    kind: 'completion',
+    items: newlyCompleted,
+    evidence: { files, checks: evidence.checks, partial: evidence.partial },
+  };
+  const request: JevRequestBody = {
+    model: JEV_MODEL,
+    state,
+    questions: {
+      'board-completion': question(
+        'Do the newly completed tasks make a concrete claim contradicted by the supplied code changes or check status? Check status concerns only the detected project check in this user turn and becomes stale after a mutation. Missing evidence, unknown/stale checks and partial files do not prove unfinished work. Do not require every task to involve code or tests. Flag only an explicit mismatch, such as claiming checks passed when the observed latest checks failed.',
+        'A completed task claims behavior or a check result demonstrably contradicted by visible evidence',
+      ),
+    },
+  };
+  for (const file of evidence.files.values()) {
+    files.push(file);
+    if (!requestFitsBudget(request)) {
+      files.pop();
+      state.evidence.partial = true;
+    }
+  }
+  return (files.length > 0 ||
+    evidence.checks === 'passed' ||
+    evidence.checks === 'failed') &&
+    requestFitsBudget(request)
+    ? request
+    : undefined;
+}
+
+export function completionIds(input: unknown): ReadonlySet<string> {
+  const parsed = parseTodoParams(input as TodoToolParameters);
+  if (!parsed.ok) {
+    return new Set();
+  }
+  if (parsed.params.action === 'propose') {
+    return new Set(
+      parsed.params.items
+        .filter((item) => item.status === TODO_STATUS.completed)
+        .map((item) => item.id),
+    );
+  }
+  return new Set(
+    parsed.params.patches
+      .filter(
+        (patch) =>
+          patch.status === TODO_STATUS.completed || patch.content !== undefined,
+      )
+      .map((patch) => patch.id),
+  );
+}

package/extensions/persona/execute.ts

@@ -1,8 +1,6 @@
-import {
-  formatPersonaDetail,
-  type PersonaToolDetails,
-  personaToolDetails,
-} from './model.ts';
+import { readFileSync } from 'node:fs';
+import { PERSONA_SKILL_PATH } from './catalog.ts';
+import { type PersonaToolDetails, personaToolDetails } from './model.ts';
 
 export interface PersonaToolResult {
   readonly content: { readonly type: 'text'; readonly text: string }[];
@@ -11,7 +9,7 @@ export interface PersonaToolResult {
 
 export function executePersona(): PersonaToolResult {
   return {
-    content: [{ type: 'text', text: formatPersonaDetail() }],
+    content: [{ type: 'text', text: readFileSync(PERSONA_SKILL_PATH, 'utf8') }],
     details: personaToolDetails(),
   };
 }

package/extensions/persona/index.ts

@@ -15,9 +15,10 @@ import { personaStatusLabel } from './model.ts';
 import { appendPersonaReminder } from './prompt.ts';
 
 export const PERSONA_DESCRIPTION =
-  "Read Sideroom's voice rules and hard prohibitions for user-facing answers.";
+  'Load the complete Sideroom writing guide before a substantial explanation, findings report, implementation summary, or user-facing documentation; also use when asked for clearer, shorter, or less technical wording. Reuse while in context.';
 
-export const PERSONA_PROMPT_SNIPPET = 'Read the active Sideroom persona.';
+export const PERSONA_PROMPT_SNIPPET =
+  'Load the complete writing guide before substantial user-facing prose.';
 
 // Pi loads extensions/*/index.ts through export default.
 export default function registerPersona(pi: ExtensionAPI): void {

package/extensions/persona/model.ts

@@ -1,11 +1,4 @@
-import {
-  PERSONA_SKILL_PATH,
-  PERSONA_TOOL_NAME,
-  PROHIBITIONS,
-  type Prohibition,
-  TEXT_SCOPE,
-  VOICE_RULES,
-} from './catalog.ts';
+import { PERSONA_TOOL_NAME, PROHIBITIONS, VOICE_RULES } from './catalog.ts';
 import type { ProhibitionViolation } from './checks.ts';
 
 // Pi narrows these blocks before handing the message over; the shape is
@@ -45,22 +38,6 @@ export function personaToolDetails(): PersonaToolDetails {
   };
 }
 
-export function formatPersonaDetail(): string {
-  return [
-    'Sideroom persona: one always-on voice; no profiles or switching.',
-    '',
-    'Voice rules',
-    ...VOICE_RULES.map((rule) => `- ${rule.instruction}`),
-    '',
-    'Hard prohibitions',
-    ...PROHIBITIONS.map(
-      (prohibition) => `- ${prohibition.rule} (${enforcementOf(prohibition)})`,
-    ),
-    '',
-    `Complete guide: ${PERSONA_SKILL_PATH}`,
-  ].join('\n');
-}
-
 export function formatBlockReason(
   path: string,
   violations: readonly ProhibitionViolation[],
@@ -112,10 +89,3 @@ export function assistantMessageText(content: readonly TextBlock[]): string {
   }
   return parts.join('\n');
 }
-
-function enforcementOf(prohibition: Prohibition): string {
-  if (prohibition.scopes.includes(TEXT_SCOPE.artifact)) {
-    return 'blocked on write and edit';
-  }
-  return 'corrected with a steer';
-}

package/extensions/persona/prompt.ts

@@ -23,12 +23,14 @@ export const PERSONA_EXAMPLES = [
 ] as const;
 
 export const PERSONA_REMINDER = `${PERSONA_REMINDER_HEADING}
+Apply this voice to progress messages, final answers, and user-facing documentation.
 Voice: ${VOICE_SUMMARY}
 Never: ${PROHIBITION_SUMMARY}
 ${ENFORCEMENT_SUMMARY}
 Examples:
 ${PERSONA_EXAMPLES.join('\n')}
-Full guide: call ${PERSONA_TOOL_NAME} or read ${PERSONA_SKILL_PATH}.`;
+Before the first substantial explanation or report, call ${PERSONA_TOOL_NAME} or read ${PERSONA_SKILL_PATH}; reuse the complete guide while it remains in context.
+Before sending prose, check: outcome first, necessary terms explained, no repetition or invented labels. Preserve evidence and requested detail.`;
 
 export function appendPersonaReminder(systemPrompt: string): string {
   if (systemPrompt.includes(PERSONA_REMINDER_HEADING)) {