@awak-app/simy-cli 0.7.37 → 0.7.39

package/src/session-supervision/conversation-context.js

@@ -1,6 +1,8 @@
 // Only human/assistant prose crosses the analysis boundary. Tool payloads,
 // attachments, paths and provider envelopes are deliberately excluded.
 export const CONVERSATION_LIMITS = Object.freeze({ messages: 32, text: 4_000, total: 24_000, bytes: 512 * 1024 });
+// Independent review preserves complete original requests within its own budget.
+export const REVIEW_USER_CONTEXT_LIMITS = Object.freeze({ messages: 32, text: 64 * 1024, total: 128 * 1024 });
 const CREDENTIAL_KEY = 'api[_ -]?key|access[_ -]?token|password|authorization';
 const QUOTED_CREDENTIAL = new RegExp(String.raw`(["'])(${CREDENTIAL_KEY})\1(\s*:\s*)(["'])(?:\\.|(?!\4)[^\\])*\4`, 'gi');
 const PLAIN_CREDENTIAL = new RegExp(String.raw`\b(${CREDENTIAL_KEY})\s*[:=]\s*(?:Bearer\s+)?[^\s,;]+`, 'gi');
@@ -41,32 +43,62 @@ export function boundProviderGoal(goal) {
     ...(goal.textTruncated === true || objective.length > 4000 ? { textTruncated: true } : {}) };
 }
 
+// Streaming readers and array callers share one prose-selection policy. Keep
+// the first goal, latest messages and latest-user identity without retaining
+// an entire transcript or sanitizing/trimming an already clipped message twice.
+export function createConversationCollector({ reviewUserContext = false } = {}) {
+  const limits = reviewUserContext ? REVIEW_USER_CONTEXT_LIMITS : CONVERSATION_LIMITS;
+  const prose = [];
+  let count = 0, clipped = false, latestUser = null, foundRedacted = false;
+  return {
+    add(message) {
+      if (!['user', 'assistant'].includes(message?.role) || reviewUserContext && message.role !== 'user') return;
+      const text = sanitizedText(message.text);
+      if (reviewUserContext) {
+        foundRedacted ||= text.includes('[REDACTED]');
+        clipped ||= message.textTruncated === true;
+      }
+      if (!text) return;
+      if (text.length > limits.text) clipped = true;
+      const normalized = { role: message.role, turnRef: sanitizedText(message.turnRef).slice(0, 160) || `message:${count}`,
+        textTruncated: message.textTruncated === true || text.length > limits.text,
+        text: text.slice(0, limits.text) };
+      count++; prose.push(normalized);
+      if (normalized.role === 'user') latestUser = normalized;
+      if (prose.length > limits.messages + 1) prose.splice(1, 1);
+    },
+    finish({ truncated = false, incomplete = false, redacted = false } = {}) {
+      redacted ||= foundRedacted;
+      incomplete ||= reviewUserContext && redacted;
+      truncated ||= clipped || prose.length > limits.messages;
+      // Preserve goal provenance as well as the latest user/assistant exchange.
+      const selected = prose.length > limits.messages ? [prose[0], ...prose.slice(-(limits.messages - 1))] : prose;
+      let total = 0;
+      const result = [];
+      // Spend the bounded budget from newest to oldest; never trim a latest
+      // request to make room for early goal provenance.
+      for (const message of selected.toReversed()) {
+        if (total + message.text.length > limits.total) { truncated = true; continue; }
+        result.unshift(message);
+        total += message.text.length;
+      }
+      const finalMessage = prose.at(-1);
+      if (!latestUser || !result.includes(latestUser) || latestUser.textTruncated || finalMessage?.textTruncated) incomplete = true;
+      return { messages: result.map(({ textTruncated, ...message }) => ({ ...message, ...(textTruncated ? { textTruncated: true } : {}) })), truncated, incomplete, ...(reviewUserContext ? { redacted } : {}) };
+    },
+  };
+}
+
 export function boundConversation(messages, { truncated = false, incomplete = false } = {}) {
   if (!Array.isArray(messages)) return { messages: [], truncated: false, incomplete: true };
-  const prose = [];
-  for (const message of messages) {
-    if (!['user', 'assistant'].includes(message?.role)) continue;
-    const text = sanitizedText(message.text);
-    if (!text) continue;
-    if (text.length > CONVERSATION_LIMITS.text) truncated = true;
-    prose.push({ role: message.role, turnRef: sanitizedText(message.turnRef).slice(0, 160) || `message:${prose.length}`,
-      textTruncated: message.textTruncated === true || text.length > CONVERSATION_LIMITS.text,
-      text: text.slice(0, CONVERSATION_LIMITS.text) });
-  }
-  if (prose.length > CONVERSATION_LIMITS.messages) truncated = true;
-  // Preserve goal provenance as well as the latest user/assistant exchange.
-  const selected = prose.length > CONVERSATION_LIMITS.messages ? [prose[0], ...prose.slice(-(CONVERSATION_LIMITS.messages - 1))] : prose;
-  let total = 0;
-  const result = [];
-  // Spend the bounded budget from newest to oldest; never trim a latest
-  // request to make room for early goal provenance.
-  for (const message of selected.toReversed()) {
-    if (total + message.text.length > CONVERSATION_LIMITS.total) { truncated = true; continue; }
-    result.unshift(message);
-    total += message.text.length;
-  }
-  const latestUser = prose.findLast(message => message.role === 'user');
-  const finalMessage = prose.at(-1);
-  if (!latestUser || !result.includes(latestUser) || latestUser.textTruncated || finalMessage?.textTruncated) incomplete = true;
-  return { messages: result.map(({ textTruncated, ...message }) => ({ ...message, ...(textTruncated ? { textTruncated: true } : {}) })), truncated, incomplete };
+  const collector = createConversationCollector();
+  for (const message of messages) collector.add(message);
+  return collector.finish({ truncated, incomplete });
+}
+
+export function boundReviewUserContext(messages, { truncated = false, incomplete = false, redacted = false } = {}) {
+  if (!Array.isArray(messages)) return { messages: [], truncated: false, incomplete: true, redacted };
+  const collector = createConversationCollector({ reviewUserContext: true });
+  for (const message of messages) collector.add(message);
+  return collector.finish({ truncated, incomplete, redacted });
 }

package/src/session-supervision/discovery-window.js

@@ -4,14 +4,16 @@ export const RECENT_SESSION_LIMIT = 200;
 
 // Explicit tracking and unsettled work remain visible outside recent history.
 // Completed, untracked records are history, not an unlimited extra catalog.
-export const retainedSession = record => Boolean(record?.listPinned || record?.autoContinue || record?.monitor || record?.tracked ||
+export const supervisedSession = record => Boolean(record?.autoContinue || record?.monitor || record?.tracked ||
   record?.run && !TERMINAL.has(record.run.state));
+export const retainedSession = record => Boolean(record?.listPinned || supervisedSession(record));
 
-export function recentSessionWindow(items, { limit = RECENT_SESSION_LIMIT, priority = () => false } = {}) {
+export function recentSessionWindow(items, { limit = RECENT_SESSION_LIMIT, priority = () => false, includeAncestors = true } = {}) {
   const recent = [...items].sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0) || a.session.localeCompare(b.session));
   const retained = [], history = [];
   for (const item of recent) (priority(item) ? retained : history).push(item);
   const selected = [...retained, ...history.slice(0, Math.max(0, limit - retained.length))];
+  if (!includeAncestors) return selected;
   const byKey = new Map(items.map(item => [`${item.provider}:${item.session}`, item]));
   const included = new Set(selected.map(item => `${item.provider}:${item.session}`));
   // Keep observed ancestors so a recent child does not silently become a root.
@@ -25,3 +27,7 @@ export function recentSessionWindow(items, { limit = RECENT_SESSION_LIMIT, prior
   }
   return selected;
 }
+
+// Tree visibility and navigation pins do not subscribe all ancestors to live
+// work. Explicit supervision and owned jobs are supplied by each caller.
+export const liveSessionWindow = (items, options = {}) => recentSessionWindow(items, { ...options, includeAncestors: false });

package/src/session-supervision/index.js

@@ -16,7 +16,7 @@ import { loadPurposeRuleSet } from './purpose-instruction.js';
 import { originalSessionTarget } from './original-session-target.js';
 import { readCodexChildSessions } from './codex-children.js';
 import { readCodexTitles, sessionTitle } from './session-titles.js';
-import { recentSessionWindow, retainedSession } from './discovery-window.js';
+import { RECENT_SESSION_LIMIT, liveSessionWindow, retainedSession, supervisedSession } from './discovery-window.js';
 import { requireProviderLink } from '../provider-links.js';
 import { readDispatchGate, rootFromDelivery, sessionDispatchReadiness } from '../codex-plugins/simy/hooks/update-dispatch-gate.mjs';
 
@@ -165,13 +165,13 @@ export async function discoverSessions(options = {}) {
 }
 
 async function discoverSessionCatalog({ root, openClient = openCodexAppServer, listClaude = listClaudeSessions,
-  inspectProcess = processIdentity, now: requestedNow, signal, listCodexTitles = readCodexTitles, listCodexChildren = readCodexChildSessions, codexHome, connectedProviders = ['codex', 'claude'], includeArchived = false, includeSelectionCandidates = false, catalogSnapshot, recordSnapshot, archiveReconciliations = new Map(), readRecords = listRecords, onProgress } = {}) {
+  inspectProcess = processIdentity, now: requestedNow, signal, listCodexTitles = readCodexTitles, listCodexChildren = readCodexChildSessions, codexHome, connectedProviders = ['codex', 'claude'], includeArchived = false, includeSelectionCandidates = false, recentOnly = false, catalogSnapshot, recordSnapshot, archiveReconciliations = new Map(), readRecords = listRecords, onProgress } = {}) {
   const now = requestedNow ?? Date.now();
   const assertActive = () => { if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.'); };
   assertActive();
   const connected = new Set(connectedProviders);
   const records = (recordSnapshot || await readRecords(root)).filter(record => connected.has(record.provider));
-  const priorities = records.filter(retainedSession);
+  const priorities = records.filter(supervisedSession);
   let archivedCodex = [];
   let discovered = [], codexError = null, codexReasonCode = null, claude = [], claudeError = null;
   let archiveStates = new Map();
@@ -192,7 +192,7 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
   } else await Promise.all([
     (async () => {
       try { if (connected.has('codex')) discovered = await withClient(openClient, async client => {
-        const active = await listCodexSessions({ client, all: true, signal, inspectState: true, codexHome,
+        const active = await listCodexSessions({ client, all: !recentOnly, signal, inspectState: true, codexHome,
           onPage: async items => { discovered = [...items]; await progress({ discovered, archivedCodex }); },
           prioritySessions: priorities.filter(record => record.provider === 'codex').map(record => record.session) });
         if (includeArchived) {
@@ -207,7 +207,7 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
             }
             return response;
           } };
-          try { await listCodexSessions({ client: archiveClient, all: true, signal, archived: true,
+          try { await listCodexSessions({ client: archiveClient, all: !recentOnly, signal, archived: true,
             onPage: async () => { archivedCodex = [...observedArchives.values()]; await progress({ discovered, archivedCodex }); } }); }
           catch (error) {
             codexError = 'Codex archive discovery incomplete. Refresh to retry.';
@@ -216,7 +216,7 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
           archivedCodex = [...observedArchives.values()];
         }
         const ids = new Set(active.map(item => item.session));
-        archiveStates = await readCodexArchiveStates(client, records.filter(record => record.provider === 'codex' && !ids.has(record.session)), { codexHome });
+        archiveStates = await readCodexArchiveStates(client, records.filter(record => record.provider === 'codex' && !ids.has(record.session) && (!recentOnly || supervisedSession(record))), { codexHome });
         for (const item of archivedCodex) archiveStates.set(item.session, true);
         return active;
       }, signal); }
@@ -226,17 +226,22 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
       }
     })(),
     (async () => {
-      try { if (connected.has('claude')) claude = await listClaude({ signal, all: true, onProgress: items => { claude = items; return progress({ claude }); },
+      try { if (connected.has('claude')) claude = await listClaude({ signal, all: !recentOnly, limit: RECENT_SESSION_LIMIT, onProgress: items => { claude = items; return progress({ claude }); },
         prioritySessions: priorities.filter(record => record.provider === 'claude').map(record => record.session) }); }
       catch { claudeError = 'Claude conversation discovery unavailable.'; }
     })(),
   ]);
   assertActive();
   const activeCodex = new Set(discovered.map(item => item.session));
+  const claudeByIdentity = new Map();
+  for (const item of claude) {
+    const key = JSON.stringify([item.session, item.cwd]);
+    if (!claudeByIdentity.has(key)) claudeByIdentity.set(key, item);
+  }
   for (let index = 0; index < records.length; index++) {
     assertActive();
     const record = records[index];
-    const claudeItem = record.provider === 'claude' ? claude.find(item => item.session === record.session && item.cwd === record.cwd) : null;
+    const claudeItem = record.provider === 'claude' ? claudeByIdentity.get(JSON.stringify([record.session, record.cwd])) : null;
     const archiveState = record.provider === 'codex' ? archiveStates.get(record.session) ?? (activeCodex.has(record.session) ? false : undefined) : claudeItem?.archived;
     if (typeof archiveState !== 'boolean') continue;
     const key = `${record.provider}:${record.session}`;
@@ -325,9 +330,10 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
     const parentSession = navigationParent(item, record);
     return { ...item, localHidden: record?.listHidden === true, ...(parentSession ? { parentSession } : {}) };
   });
-  const liveItems = [...recentSessionWindow(catalog.filter(item => item.archived !== true && !item.localHidden), {
-    priority: item => retainedSession(recordsByKey.get(`${item.provider}:${item.session}`)),
-  }), ...recentSessionWindow(catalog.filter(item => item.archived === true || item.localHidden), { priority: item => item.localHidden })];
+  const liveItems = liveSessionWindow(catalog.filter(item => item.archived !== true && (!item.localHidden ||
+    supervisedSession(recordsByKey.get(`${item.provider}:${item.session}`)))), {
+    priority: item => supervisedSession(recordsByKey.get(`${item.provider}:${item.session}`)),
+  });
   const liveKeys = new Set(liveItems.map(item => `${item.provider}:${item.session}`));
   const items = [...catalog];
   // Include archived ancestors of active rows even when archive visibility is off.
@@ -357,6 +363,13 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
   const selectionCandidates = includeSelectionCandidates ? [...codexTitles].map(([session, title]) => ({ provider: 'codex', session, title })) : undefined;
   assertActive();
   let nextItem = 0;
+  // Many conversations share a workspace. Resolve it once in this attempt,
+  // never across attempts or in the exact-session execution authority reader.
+  const workspaces = new Map();
+  const resolveWorkspace = cwd => {
+    if (!workspaces.has(cwd)) workspaces.set(cwd, realpath(cwd));
+    return workspaces.get(cwd);
+  };
   const project = async item => {
     if (item.delegated === true) return { ...item,
       tracked: false, autoContinue: false, binding: { mode: 'unmanaged', taskId: null },
@@ -379,7 +392,7 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
     if (supported || liveHook) {
       try {
         continuationAdmission = { provider: item.provider, session: item.session,
-          cwd: await realpath(item.cwd), source: item.observation.source, model: item.model, validatedAt: now };
+          cwd: await resolveWorkspace(item.cwd), source: item.observation.source, model: item.model, validatedAt: now };
       } catch { /* Missing workspaces cannot grant an admission. */ }
     }
     const availability = archived ? { canEnable: false, reasonCode: 'session_archived',

package/src/session-supervision/purpose-verification.js

@@ -1,4 +1,4 @@
-import { boundConversation } from './conversation-context.js';
+import { boundConversation, boundReviewUserContext } from './conversation-context.js';
 import { currentAcceptanceRead } from './acceptance-reads.js';
 import { normalizeOutcomeReview } from '../codex-plugins/simy/hooks/loop-kernel.mjs';
 import { createHash } from 'node:crypto';
@@ -11,19 +11,28 @@ export { workspaceIdentity } from '../codex-plugins/simy/hooks/purpose-workspace
 // Filter before bounding so worker prose cannot crowd out user corrections.
 // Untyped legacy snapshots cannot establish human provenance.
 export function independentRequestContext(...snapshots) {
+  return requestContext(boundConversation, snapshots);
+}
+
+export function independentReviewRequestContext(...snapshots) {
+  return requestContext(boundReviewUserContext, snapshots);
+}
+
+function requestContext(bound, snapshots) {
   const messages = [], seen = new Set();
-  let incomplete = false, truncated = false;
+  let incomplete = false, truncated = false, redacted = false;
   for (const snapshot of snapshots) {
     if (!snapshot || !Array.isArray(snapshot.messages)) { incomplete = true; continue; }
     incomplete ||= snapshot.incomplete === true;
     truncated ||= snapshot.truncated === true;
+    redacted ||= snapshot.redacted === true;
     for (const message of snapshot.messages) {
       if (message?.role !== 'user') continue;
       const key = JSON.stringify([message.turnRef, message.text]);
       if (!seen.has(key)) { seen.add(key); messages.push(message); }
     }
   }
-  return boundConversation(messages, { incomplete, truncated });
+  return bound(messages, { incomplete, truncated, redacted });
 }
 
 export function verificationInstruction(record, currentEvidence = null, sourceContext = null, observations = []) {

package/src/sqm/advisory-guidance.js

@@ -1,4 +1,5 @@
 // Signed guidance is scoped reference data, never executable checks or authority.
+export const MECHANISM_GUIDANCE_CAPABILITY = 'sqm-mechanism-guidance.v1';
 export const ADVISORY_GUIDANCE_CAPABILITY = 'sqm-advisory-guidance.v1';
 export const isAdvisoryGuidance = module => module?.schema_version === '1.2.0' && module?.kind === 'advisory_guidance';
 

package/src/sqm/checkers.js

@@ -45,7 +45,8 @@ export async function evaluateKnowledgeBundle(bundle, repository, options = {})
       if (rule.type === 'reasoned_assessment') {
         const assess = semanticCalls < (options.maxSemanticCalls ?? 4) ? options.assess : undefined;
         if (assess) semanticCalls++;
-        assessment = await evaluateReasonedAssessment(module, rule, repository, { assess, signal: options.signal });
+        const contextRepository = assess ? await withAssessmentContext(module, rule, repository) : repository;
+        assessment = await evaluateReasonedAssessment(module, rule, contextRepository, { assess, signal: options.signal });
         if (!assess && options.assess) assessment.reason = 'semantic_call_budget_exhausted';
       }
       const violations = assessment
@@ -96,6 +97,43 @@ export async function evaluateKnowledgeBundle(bundle, repository, options = {})
   return { findings, modules, matcherDiagnostics, advisoryGuidance: advisoryGuidanceDescriptions(bundle, repository.repository) };
 }
 
+// Supply bounded, line-numbered current code around changed hunks. Historical
+// references cannot supply repository context or broaden the rule's routing.
+async function withAssessmentContext(module, rule, repository) {
+  const routed = module.detection.matchers.flatMap(matcher => matcher.paths || []);
+  const files = routed.length ? repository.diff.filter(file => routed.some(pattern => globMatches(pattern, file.path))) : repository.diff;
+  // Scope only this assessment's code input. Repository identity, the full
+  // changed-path catalog and the signed proof continue to bind the entire diff.
+  const scoped = routed.length ? { ...repository, assessment_diff: files,
+    assessment_diff_scope: { matcher_paths: routed, omitted_unrelated_files: repository.diff.length - files.length } } : repository;
+  if (!rule.assessment.inputs.some(input => input.source.type === 'runtime_context' && input.source.key === 'repository.context')) return scoped;
+  const excerpts = []; let characters = 0;
+  for (const file of files.slice(0, 8)) {
+    try {
+      const lines = (await readText(repository.root, file.path)).split(/\r?\n/);
+      const selected = new Set();
+      for (const change of file.lines.filter(line => line.side === 'added')) {
+        for (let index = Math.max(0, change.line - 21); index < Math.min(lines.length, change.line + 20); index++) selected.add(index);
+      }
+      const text = [...selected].sort((a, b) => a - b).map(index => `${index + 1}: ${lines[index]}`).join('\n');
+      if (!text) continue;
+      const size = JSON.stringify({ file: file.path, excerpt: text }).length;
+      if (characters + size > 24_000) break;
+      excerpts.push({ file: file.path, excerpt: text }); characters += size;
+    } catch {
+      excerpts.push({ file: file.path, status: 'unavailable' });
+    }
+  }
+  const omitted = files.filter(file => !excerpts.some(item => item.file === file.path)).map(file => file.path);
+  // Keep code literal: serializing excerpts into nested JSON makes otherwise
+  // correct multiline quotations fail exact evidence validation.
+  return { ...scoped, assessment_context: [
+    'selection: changed_hunks_with_20_surrounding_lines; scope: bounded_context_only',
+    ...excerpts.map(item => `File: ${item.file}\n${item.excerpt || 'unavailable'}`),
+    `Omitted files: ${JSON.stringify(omitted)}`,
+  ].join('\n\n') };
+}
+
 function moduleDiagnostic(module, reason, matchers = []) {
   return {
     module_id: module.id,

package/src/sqm/claude-plugin.js

@@ -14,6 +14,7 @@ const AUTHOR = "Specialist Doctors Inc.";
 // Generate both providers from the maintained workflow source. Only provider
 // terminology, manifest schema, and hook environment names differ.
 export async function claudePluginFiles() {
+  const packageInfo = JSON.parse(await readFile(new URL("../../package.json", import.meta.url), "utf8"));
   const sourceManifest = JSON.parse(await readFile(path.join(SOURCE, ".codex-plugin/plugin.json"), "utf8"));
   const files = new Map();
   files.set('agents/outcome-review.md', '---\nname: outcome-review\ndescription: Independent tool-free outcome review under the original Claude budget\ntools: []\n---\n' + CLAUDE_NATIVE_REVIEW_PROMPT + '\n');
@@ -34,7 +35,10 @@ export async function claudePluginFiles() {
     files.set(`hooks/${name}`, await readFile(path.join(SOURCE, "hooks", name), "utf8"));
   }
   const collector = await readFile(new URL("../cli-observability.js", import.meta.url), "utf8");
-  files.set("hooks/cli-observability.mjs", collector.replace("./web-api.js", "./web-api.mjs"));
+  // Standalone hooks do not ship the CLI capability dependency graph. Freeze the
+  // maintained package version into their generated collector instead.
+  files.set("hooks/cli-observability.mjs", collector.replace("./web-api.js", "./web-api.mjs")
+    .replace("import { CLI_VERSION } from './cli-contract.js';", `const CLI_VERSION = ${JSON.stringify(packageInfo.version)};`));
   files.set("hooks/web-api.mjs", await readFile(new URL("../web-api.js", import.meta.url), "utf8"));
   const deliveryLoop = await readFile(path.join(SOURCE, "hooks/delivery-loop.mjs"), "utf8");
   files.set("hooks/delivery-loop.mjs", deliveryLoop.replace(
@@ -61,10 +65,14 @@ export async function claudePluginFiles() {
   files.set("hooks/purpose-cycle.mjs", await readFile(path.join(SOURCE, "hooks/purpose-cycle.mjs"), "utf8"));
   files.set("hooks/purpose-rule-policy.mjs", await readFile(path.join(SOURCE, "hooks/purpose-rule-policy.mjs"), "utf8"));
   files.set("hooks/acceptance-policy.mjs", await readFile(path.join(SOURCE, "hooks/acceptance-policy.mjs"), "utf8"));
+  files.set("hooks/requirement-acceptance.mjs", await readFile(path.join(SOURCE, "hooks/requirement-acceptance.mjs"), "utf8"));
+  files.set("hooks/registered-requirement-checker.mjs", await readFile(path.join(SOURCE, "hooks/registered-requirement-checker.mjs"), "utf8"));
   files.set("hooks/purpose-rule-review.mjs", await readFile(path.join(SOURCE, "hooks/purpose-rule-review.mjs"), "utf8"));
   files.set("hooks/workspace-lease.mjs", await readFile(path.join(SOURCE, "hooks/workspace-lease.mjs"), "utf8"));
   for (const name of ["update-state-store.mjs", "update-dispatch-gate.mjs", "update-dispatch-identity.mjs"]) files.set(`hooks/${name}`, await readFile(path.join(SOURCE, "hooks", name), "utf8"));
   files.set("hooks/connection-reminder.mjs", await readFile(path.join(SOURCE, "hooks/connection-reminder.mjs"), "utf8"));
+  files.set("hooks/mention-router.mjs", await readFile(path.join(SOURCE, "hooks/mention-router.mjs"), "utf8"));
+  files.set("agents/simy.md", await readFile(new URL("./claude-simy-agent.md", import.meta.url), "utf8"));
   files.set("hooks/dev-work.mjs", await readFile(path.join(SOURCE, "hooks/dev-work.mjs"), "utf8"));
   const hooks = JSON.parse(await readFile(path.join(SOURCE, "hooks/hooks.json"), "utf8"));
   delete hooks.hooks.Interrupt; // Codex-only event; Claude interruptions cannot be vetoed.
@@ -92,6 +100,12 @@ export async function claudePluginFiles() {
       }
     }
   }
+  hooks.hooks.UserPromptSubmit.unshift({ hooks: [{
+    type: "command",
+    command: hookRuntimeCommand("node --input-type=module -e \"import { pathToFileURL } from 'node:url'; import { join } from 'node:path'; const hook = await import(pathToFileURL(join(process.env.CLAUDE_PLUGIN_ROOT, 'hooks', 'mention-router.mjs')).href); await hook.main();\""),
+    timeout: 3,
+    statusMessage: "SIMY request routing",
+  }] });
   files.set("hooks/hooks.json", json(hooks));
   const hash = createHash("sha256");
   for (const [name, contents] of [...files].sort(([a], [b]) => a.localeCompare(b))) hash.update(name).update("\0").update(contents);

package/src/sqm/claude-simy-agent.md

@@ -0,0 +1,11 @@
+---
+name: simy
+description: SIMY — interpret @simy requests for continuation, diagnosis, quality checks, PR review, status or stopping work. Return guidance to the original Claude conversation.
+tools: []
+---
+
+You are SIMY's intent guide, not an execution owner. Interpret the user's entire request in context, in Japanese or English. Return the intended action and which installed SIMY skill the parent Claude should read: continue (continuation, status, Auto Continue off or stopping), diagnose (why work stopped or explicitly authorized repair), sqm-loop (explicit quality check), or pr-review (explicit PR review). Answer questions about SIMY directly. For combined requests preserve each scope.
+
+Do not start, resume, stop, review, or certify work yourself. This agent has no tools. The parent conversation must use its own verified original provider/session and the existing SIMY controls, and report their actual receipts. Never use this child agent's session identity. The parent's prompt hook supplies the skill paths.
+
+A mention, selected agent, quote, code example, hypothetical, negation or request to wait is not permission to start work. Diagnosis does not authorize repair/continuation; continuation does not imply SQM; PR review does not authorize fixes. Clarify ambiguous requests. Preserve stops, approvals, opt-outs and permissions. Do not infer completion from an accepted setting or missing evidence.

package/src/sqm/delivery-assessment.js

@@ -0,0 +1,78 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { canStartProvider, refreshBudgetState } from '../orchestrator/budget.js';
+import { createProviderStreamDecoder, completeProviderUsage } from '../provider-stream.js';
+import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, observeDispatchEvent } from '../update-detachment/dispatch-gate.js';
+import { captureDispatchProvenance } from '../update-detachment/provenance.js';
+import { createLocalAssessmentRunner } from './reasoned-assessment.js';
+
+// A semantic check is another reviewer call under the existing task authority
+// and token ceiling, not an unaccounted provider invocation.
+export function createDeliveryAssessmentRunner(run, { repositoryPath, authorize, persist, ...options }) {
+  const provider = run.snapshot.charter.audit_backend || run.snapshot.charter.backend;
+  return async (request, context = {}) => {
+    const owner = captureDispatchOwner(run.sqmHistoryRoot || (run.localStateRoot ? path.dirname(run.localStateRoot) : undefined));
+    const invocationId = randomUUID();
+    const attemptId = `${run.snapshot.id}:reviewer:sqm:${invocationId}`;
+    const provenance = captureDispatchProvenance({ root: owner.root, provider, worktree: repositoryPath,
+      accountSession: run.session, origin: run.apiOrigin || undefined, taskId: run.snapshot.id,
+      recordRef: run.localStateRoot ? path.join(run.localStateRoot, `${run.snapshot.id}.json`) : `coding-run:${run.snapshot.id}` });
+    const records = [], writes = [];
+    let terminalCount = 0, incomplete = false, persistenceError;
+    const checkpoint = status => {
+      run.snapshot.metadata.provider_usage_checkpoints ??= {};
+      run.snapshot.metadata.provider_usage_checkpoints[invocationId] = {
+        invocation_id: invocationId, phase: 'reviewer', purpose: 'sqm_semantic', backend: provider,
+        usage_status: status, token_usage: { records: structuredClone(records) },
+      };
+      refreshBudgetState(run.snapshot);
+      writes.push(Promise.resolve().then(persist).catch(error => { persistenceError ||= error; }));
+    };
+    const assess = createLocalAssessmentRunner(provider, {
+      ...options,
+      beforeDispatch: async () => {
+        await authorize();
+        context.signal?.throwIfAborted();
+        assertTaskAdmission(owner, { taskId: run.snapshot.id, provenance });
+        const permission = canStartProvider(run.snapshot, { phase: 'reviewer' });
+        if (!permission.allowed) throw Object.assign(new Error(`SQM reviewer is held: ${permission.reason}`), { code: permission.reason });
+      },
+      dispatchTransport: initiate => {
+        // Recheck immediately at the synchronous spawn boundary as well.
+        authorize();
+        const permission = canStartProvider(run.snapshot, { phase: 'reviewer' });
+        if (!permission.allowed) throw Object.assign(new Error(`SQM reviewer is held: ${permission.reason}`), { code: permission.reason });
+        if (run.stopRequested) throw Object.assign(new Error('SQM review cancelled'), { code: 'analysis_cancelled' });
+        const child = dispatchWithFence(owner, { taskId: run.snapshot.id, attemptId, provenance }, initiate);
+        run.child = child;
+        checkpoint('pending');
+        const decoder = createProviderStreamDecoder({ backend: provider, onLine() {},
+          onUsage: usage => { records.push({ ...usage, backend: provider, phase: 'reviewer', invocation_id: invocationId }); checkpoint('pending'); },
+          onEvent: event => {
+            if (provider === 'claude' && event.type === 'result' || provider === 'codex' && event.type === 'turn.completed') {
+              terminalCount++; incomplete ||= !completeProviderUsage(provider, event);
+            }
+            observeDispatchEvent({ root: owner.root, attemptId, provider, event,
+              onError: error => { run.snapshot.metadata.dispatch_recovery_required = error.code || 'provenance_persistence_failed'; } });
+          },
+        });
+        child.stdout?.on('data', chunk => decoder.push(chunk.toString('utf8')));
+        child.once('close', () => {
+          decoder.flush();
+          if (run.child === child) run.child = null;
+          checkpoint(terminalCount > 0 && !incomplete && (provider !== 'claude' || terminalCount === 1) && records.length ? 'observed' : 'unknown');
+        });
+        return child;
+      },
+    });
+    try { return await assess(request, context); }
+    finally {
+      await Promise.all(writes);
+      if (persistenceError) {
+        run.snapshot.metadata.provider_usage_checkpoints[invocationId].usage_status = 'unknown';
+        refreshBudgetState(run.snapshot);
+        throw persistenceError;
+      }
+    }
+  };
+}

package/src/sqm/hypothesis-knowledge.js

@@ -1,4 +1,4 @@
-import { ADVISORY_GUIDANCE_CAPABILITY, isAdvisoryGuidance, advisoryGuidanceDescriptions } from './advisory-guidance.js';
+import { ADVISORY_GUIDANCE_CAPABILITY, MECHANISM_GUIDANCE_CAPABILITY, isAdvisoryGuidance, advisoryGuidanceDescriptions } from './advisory-guidance.js';
 import { CLI_VERSION } from '../cli-contract.js';
 import { isSessionValid, readSession } from '../session-store.js';
 import { resolveWebOrigin } from '../web-origin.js';
@@ -39,7 +39,7 @@ export async function loadHypothesisKnowledge({ cwd, webOrigin, allowNetwork = f
     const credentials = explicit ? { organizationId: env.SIMY_SQM_ORGANIZATION_ID, accountId: env.SIMY_SQM_ACCOUNT_ID, token: env.SIMY_SQM_TOKEN || env.SIMY_ACCESS_TOKEN, endpoint: env.SIMY_SQM_BUNDLE_URL } : { organizationId: session.organization_id || session.org_id, accountId: session.account_id || session.auth_user_id || session.device_id, token: session.token, endpoint: savedEndpoint };
     if (!credentials.accountId || !credentials.organizationId || !credentials.token) return unavailable('existing_sqm_identity_incomplete');
     const repository = await repositoryIdentityImpl(cwd, { signal });
-    const loaded = await loadBundleImpl({ repository, capabilities: [ADVISORY_GUIDANCE_CAPABILITY], cliVersion: CLI_VERSION,
+    const loaded = await loadBundleImpl({ repository, capabilities: [ADVISORY_GUIDANCE_CAPABILITY, MECHANISM_GUIDANCE_CAPABILITY], cliVersion: CLI_VERSION,
       ...credentials,
       fetchImpl: async (...args) => {
         if (!allowNetwork) throw Error('Network knowledge retrieval is unavailable.');
@@ -73,7 +73,7 @@ export async function loadHypothesisKnowledge({ cwd, webOrigin, allowNetwork = f
     return { status: 'available', repository, bundleDigest: loaded.bundle.integrity.digest,
       ...recalled, changeContextStatus,
       searchCommand: ['simy', 'sqm', 'knowledge', '--host', origin, ...(!allowNetwork ? ['--offline'] : []), '--json'],
-      advisoryGuidance: advisoryGuidanceDescriptions(loaded.bundle, repository), source: loaded.source, fetchedFor: 'hypothesis_reasoning_only', executedTests: 0 };
+      advisoryGuidance: advisoryGuidanceDescriptions(loaded.bundle, repository).filter(item => recalled.modules.some(module => module.moduleId === item.module_id)), source: loaded.source, fetchedFor: 'hypothesis_reasoning_only', executedTests: 0 };
   } catch (error) {
     if (signal?.aborted) throw signal.reason;
     const diagnostic = sqmDiagnostic(error, 'knowledge_loading');

package/src/sqm/knowledge-recall.js

@@ -5,8 +5,14 @@ const MAX_QUERY_CHARACTERS = 12_000;
 const PAGE_SIZE = 20;
 
 function terms(value) {
-  const text = String(value).normalize('NFKC').toLowerCase();
+  const normalized = String(value).normalize('NFKC');
+  const text = normalized.toLowerCase();
   const result = new Set(text.match(/[\p{L}\p{N}_-]{2,}/gu) || []);
+  // Keep exact identifiers searchable while also finding their natural-language
+  // components. A change need not repeat the original camelCase or snake_case.
+  const components = normalized.replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, '$1 $2')
+    .replace(/(\p{Lu})(\p{Lu}\p{Ll})/gu, '$1 $2').toLowerCase();
+  for (const term of components.match(/[\p{L}\p{N}]{2,}/gu) || []) result.add(term);
   for (const [run] of text.matchAll(/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]+/gu)) {
     for (let i = 0; i + 1 < run.length; i++) result.add(run.slice(i, i + 2));
   }
@@ -21,26 +27,42 @@ export function selectReasoningKnowledge(bundle, repository, { query = '', offse
     ? scope.repositories.map(repo => repo.toLowerCase()) : [target];
   const queryText = String(query).slice(0, MAX_QUERY_CHARACTERS);
   const queryTerms = terms(queryText);
-  const eligible = bundle.modules.filter(module => !isAdvisoryGuidance(module) &&
+  const eligible = bundle.modules.filter(module =>
     !['candidate', 'retired'].includes(module.lifecycle.status) &&
     (!module.scope.repositories?.length || module.scope.repositories.some(repo => repositories.includes(repo.toLowerCase()))));
-  const scored = eligible.map(module => {
+  const documents = eligible.map(module => {
     // Keep all bounded invariant fields together, particularly applicability and
     // counter-evidence. A short title alone cannot support causal transfer.
     const context = {
       moduleId: module.id, version: module.version, title: module.title,
-      invariant: module.invariant.statement, failureCondition: module.invariant.failure_condition || null,
-      remediation: module.invariant.remediation || null,
+      invariant: isAdvisoryGuidance(module) ? module.guidance.statement : module.invariant.statement,
+      failureCondition: isAdvisoryGuidance(module) ? module.guidance.rationale : module.invariant.failure_condition || null,
+      remediation: isAdvisoryGuidance(module) ? null : module.invariant.remediation || null,
+      ...(isAdvisoryGuidance(module) ? { kind: module.kind, applicability: module.guidance.applicability,
+        limitations: module.guidance.limitations, sources: module.sources } : {}),
       scope: module.scope, lifecycle: module.lifecycle.status,
-      ruleCount: module.detection.checks.length, scenarioDefinitionCount: module.assurance?.scenarios?.length || 0,
-      incidentRefs: module.incident_refs,
+      ruleCount: isAdvisoryGuidance(module) ? 0 : module.detection.checks.length, scenarioDefinitionCount: module.assurance?.scenarios?.length || 0,
+      incidentRefs: module.incident_refs || [],
       transferStatus: module.scope.repositories?.some(repo => repo.toLowerCase() === target) || !module.scope.repositories?.length
         ? 'target_not_evaluated' : 'cross_repository_hypothesis',
     };
-    const vocabulary = terms(JSON.stringify(context));
-    const score = [...queryTerms].filter(term => vocabulary.has(term)).length;
-    return { context, score };
-  }).sort((a, b) => b.score - a.score || a.context.moduleId.localeCompare(b.context.moduleId) || a.context.version.localeCompare(b.context.version));
+    // Schema property names and shared repository identity are transport data,
+    // not evidence of mechanism relevance.
+    const vocabulary = terms([context.moduleId, context.title, context.invariant,
+      context.failureCondition, context.remediation, ...(context.applicability || []), ...(context.limitations || []), ...(module.scope.boundaries || []),
+      ...(module.scope.languages || []), ...(module.scope.frameworks || [])].filter(Boolean).join(' '));
+    return { context, vocabulary };
+  });
+  const frequencies = new Map();
+  for (const { vocabulary } of documents) {
+    for (const term of queryTerms) if (vocabulary.has(term)) frequencies.set(term, (frequencies.get(term) || 0) + 1);
+  }
+  const scored = documents.map(({ context, vocabulary }) => ({ context,
+    // Inverse document frequency keeps a rare causal term ahead of many shared
+    // framework words. Scores rank context only; they never authorize checks.
+    score: [...queryTerms].reduce((sum, term) => vocabulary.has(term)
+      ? sum + Math.log(1 + (documents.length - frequencies.get(term) + 0.5) / (frequencies.get(term) + 0.5)) : sum, 0),
+  })).sort((a, b) => b.score - a.score || a.context.moduleId.localeCompare(b.context.moduleId) || a.context.version.localeCompare(b.context.version));
   const matches = queryTerms.size ? scored.filter(item => item.score > 0) : scored;
   const modules = []; let characters = 0; let consumed = 0; let oversizedCount = 0;
   for (const item of matches.slice(offset, offset + PAGE_SIZE)) {
@@ -54,7 +76,7 @@ export function selectReasoningKnowledge(bundle, repository, { query = '', offse
     modules, availableCount: eligible.length, matchedCount: matches.length,
     omittedCount: eligible.length - modules.length,
     nextOffset: next < matches.length && consumed ? next : null,
-    retrieval: { policyVersion: 'sqm-reasoning-recall.v3', mode: 'unicode_lexical',
+    retrieval: { policyVersion: 'sqm-reasoning-recall.v5', mode: 'unicode_lexical',
       queryTruncated: String(query).length > queryText.length, contextCharacters: characters,
       oversizedCount,
       incomplete: matches.length > modules.length || queryText.length < String(query).length,