@awak-app/simy-cli 0.7.27 → 0.7.29

package/src/sqm/knowledge-recall.js

@@ -0,0 +1,66 @@
+import { isAdvisoryGuidance } from './advisory-guidance.js';
+// Reasoning context only. Selection never enables, disables or certifies checks.
+const MAX_CONTEXT_CHARACTERS = 48_000;
+const MAX_QUERY_CHARACTERS = 12_000;
+const PAGE_SIZE = 20;
+
+function terms(value) {
+  const text = String(value).normalize('NFKC').toLowerCase();
+  const result = new Set(text.match(/[\p{L}\p{N}_-]{2,}/gu) || []);
+  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));
+  }
+  return result;
+}
+
+export function selectReasoningKnowledge(bundle, repository, { query = '', offset = 0 } = {}) {
+  if (!Number.isSafeInteger(offset) || offset < 0) throw new TypeError('Knowledge offset must be a nonnegative integer');
+  const target = repository.toLowerCase();
+  const scope = bundle.system_scope;
+  const repositories = scope?.repository?.toLowerCase() === target
+    ? 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) &&
+    !['candidate', 'retired'].includes(module.lifecycle.status) &&
+    (!module.scope.repositories?.length || module.scope.repositories.some(repo => repositories.includes(repo.toLowerCase()))));
+  const scored = 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,
+      scope: module.scope, lifecycle: module.lifecycle.status,
+      ruleCount: 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));
+  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)) {
+    const size = JSON.stringify(item.context).length;
+    if (size > MAX_CONTEXT_CHARACTERS) { consumed++; oversizedCount++; continue; }
+    if (characters + size > MAX_CONTEXT_CHARACTERS) break;
+    modules.push(item.context); characters += size; consumed++;
+  }
+  const next = offset + consumed;
+  return {
+    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',
+      queryTruncated: String(query).length > queryText.length, contextCharacters: characters,
+      oversizedCount,
+      incomplete: matches.length > modules.length || queryText.length < String(query).length,
+      outcome: modules.length ? 'matched' : matches.length ? 'page_omitted' : queryTerms.size ? 'no_lexical_match' : 'empty_catalog',
+      executedTests: 0 },
+  };
+}
+
+export const KNOWLEDGE_TRANSFER_INSTRUCTION = `Before selecting historical knowledge, reason from the current change to plausible failure mechanisms and downstream effects. Trace callers, data scale, per-operation cost, invocation frequency, concurrency, retries and shared resource capacity. The first retrieved page is not the boundary of your reasoning. Form additional mechanism queries in your own words and use the supplied search command to retrieve more context when useful. For example a changed query or polling path can warrant checking repeated scans and disk I/O saturation even without those words in the diff; inspect plans, indexes, scale and workload before claiming a defect. For each useful analogy consider applicability, counter-evidence and missing evidence. A bounded indexed query can be safe. Historical incidents and retrieval hypotheses are not observations about this candidate; knowledge scope is not executable rule authority. Empty, omitted or unavailable knowledge does not establish safety or coverage. Keep unverified runtime assumptions explicit.`;

package/src/sqm/review-worker.js

@@ -23,8 +23,9 @@ const RECOVERABLE_PROVIDER_FAILURES = new Set([
 ]);
 const isRecoverableProviderFailure = failure => ["analysis", "adjudication"].includes(failure.stage) && RECOVERABLE_PROVIDER_FAILURES.has(failure.code);
 const DEFAULT_LEASE_SECONDS = 300;
-// Claim can retrieve and freeze organization-scoped Slack evidence (45s budget).
-const DEFAULT_REQUEST_TIMEOUT_MS = 75_000;
+// Claim can freeze source evidence (45s) and scoped knowledge recall (90s).
+// Stay outside the Web upstream (150s) and legacy relay (165s) budgets.
+const DEFAULT_REQUEST_TIMEOUT_MS = 180_000;
 const DEFAULT_EXECUTION_TIMEOUT_MS = 360_000;
 const CODEX_ATTEMPT_TIMEOUT_MS = 180_000;
 const MIN_STALL_RETRY_MS = 60_000;