synabun 2.0.0 → 2.0.5

package/neural-interface/lib/assistant-test-density.js

@@ -0,0 +1,142 @@
+// ═══════════════════════════════════════════
+// SynaBun — Assistant: test density
+// ═══════════════════════════════════════════
+//
+// How much testing SynaBun asks of the workers the Assistant dispatches. The
+// user picks a level next to the permission toggle in the Assistant's
+// composer; it is stored per session like the route mode (the runtime's
+// record.testDensity, null = the default) and read by the dispatcher when it
+// composes a worker's prompt, so a stale brain prompt never changes what the
+// worker gets. This module is the wording and the rules: the TESTING block of
+// a worker brief, the line the brain's prompt carries, the "[SynaBun Tests]"
+// line a change sends, and when a "Not tested" result is not a claim to check.
+// Pure module: no I/O, no server imports.
+
+export const TEST_DENSITIES = Object.freeze(['none', 'light', 'standard', 'thorough']);
+export const DEFAULT_TEST_DENSITY = 'light';
+export const TEST_DENSITY_LABELS = Object.freeze({ none: 'None', light: 'Light', standard: 'Standard', thorough: 'Thorough' });
+export const TESTS_HEADER = '[SynaBun Tests]';
+
+/** A known level, else `fallback` (the default level unless the caller wants to tell "not set" apart). */
+export function normalizeTestDensity(value, fallback = DEFAULT_TEST_DENSITY) {
+  const key = String(value ?? '').trim().toLowerCase();
+  return TEST_DENSITIES.includes(key) ? key : fallback;
+}
+
+export function testDensityLabel(level) {
+  return TEST_DENSITY_LABELS[normalizeTestDensity(level)];
+}
+
+// The classes whose work is code. A dispatch with no class is treated as one of them.
+const TESTING_CLASSES = new Set(['code', 'complex', 'quick']);
+
+/** Does a run of this class get the TESTING block? (review, research, browser, computer, automation, design and media runs do not.) */
+export function testingApplies(taskClass) {
+  const cls = String(taskClass ?? '').trim();
+  return !cls || TESTING_CLASSES.has(cls);
+}
+
+const TESTING_RULES = Object.freeze({
+  none: [
+    'Do not write tests and do not run test suites.',
+    'Only confirm the change loads: a syntax or type check of the files you touched, nothing more.',
+    'No browser, visual or live checks.',
+    'In ## Result say "Not tested" and list what a person should check.',
+  ],
+  light: [
+    'Run only the existing test files that directly cover the code you changed: a few files, never the whole suite.',
+    'Add a test only for a bug fix (one regression test) or for new logic that is easy to get wrong; at most one new test file.',
+    'No browser, visual or live checks unless TASK names one.',
+    'In ## Result list what you ran and what you did not verify.',
+  ],
+  standard: [
+    'Add focused tests for the behavior you add or change.',
+    'Run the test files for the area you touched, then that package\'s regular non-browser suite once at the end.',
+    'Browser or visual checks only when the change is user-facing and TASK asks for one.',
+    'In ## Result list what you ran and what you did not verify.',
+  ],
+  thorough: [
+    'Cover the change with unit and integration tests, including edge cases and failure paths; add or update browser tests for user-facing changes.',
+    'Run the whole suite and fix what you broke.',
+    'Verify the result live where the environment allows.',
+    'In ## Result list everything you ran and its outcome.',
+  ],
+});
+
+/** What workers do at a level, in one sentence (the brain's lines and a follow-up turn's). */
+const TESTING_SUMMARY = Object.freeze({
+  none: 'workers write no tests and run no suites; they only check that the change loads and report "Not tested"',
+  light: 'workers run only the test files that cover the change and add a test only for a bug fix or logic that is easy to get wrong',
+  standard: 'workers add focused tests, run the test files of the area and then the package\'s regular non-browser suite once',
+  thorough: 'workers cover the change with unit and integration tests, run the whole suite and verify live where they can',
+});
+
+export function testDensitySummary(level) {
+  return TESTING_SUMMARY[normalizeTestDensity(level)];
+}
+
+/**
+ * The TESTING block of a worker brief (assistant-task-prompt.js buildTaskPrompt): the one place
+ * SynaBun tells a worker how much to test. '' for a class that gets none, and when no level is given.
+ */
+export function testingBlock(level, taskClass = null) {
+  if (level === null || level === undefined || level === '' || !testingApplies(taskClass)) return '';
+  const id = normalizeTestDensity(level);
+  return [
+    `TESTING (the user's Test density setting: ${TEST_DENSITY_LABELS[id]}). Binding: it overrides any heavier test or verification instruction in TASK or CONTEXT. Exception: when writing or running tests is itself what TASK asks you to deliver, do that work in full.`,
+    ...TESTING_RULES[id].map((rule) => `- ${rule}`),
+  ].join('\n');
+}
+
+/** A follow-up turn of a run whose level changed since its brief: the new rules, in place of the brief's. */
+export function testingFollowUpLine(level) {
+  const id = normalizeTestDensity(level);
+  return `TESTING changed (the user's Test density setting is now ${TEST_DENSITY_LABELS[id]}; this replaces the TESTING block of your brief): ${TESTING_RULES[id].join(' ')}`;
+}
+
+/** At these levels the brain reports what was not tested instead of verifying it. */
+export function reportsUntested(level) {
+  const id = normalizeTestDensity(level);
+  return id === 'none' || id === 'light';
+}
+
+/**
+ * The entry of the brain's system prompt (assistant-persona.js, Rails).
+ * `where`: how the prompt names the control (a chat channel has no composer).
+ */
+export function testDensityPersonaLine(level, { where = 'next to the permission toggle' } = {}) {
+  const id = normalizeTestDensity(level);
+  return `- Test density: ${TEST_DENSITY_LABELS[id]} (the user's setting, ${where}): ${TESTING_SUMMARY[id]}. SynaBun adds the matching binding TESTING rules to every code / complex / quick worker brief. `
+    + 'Do not write test or verification requirements into a task beyond what the user asked for in this request, and do not dispatch a run whose only purpose is to test another run at None or Light unless the user asks. '
+    + 'Follow the same level in your own direct edits. At None or Light, report what was not tested instead of verifying it yourself. '
+    + `A change of level arrives as a "${TESTS_HEADER}" line.`;
+}
+
+/** The line a running brain gets when the level changes (like the router's "[SynaBun Router]" line). */
+export function testDensityStamp(level) {
+  const id = normalizeTestDensity(level);
+  return `${TESTS_HEADER} Test density: ${TEST_DENSITY_LABELS[id]} - ${TESTING_SUMMARY[id]}. Do not write heavier test or verification requirements into a task, and follow the same level in your own edits.`;
+}
+
+// "Not tested", "untested", "no tests were run", "did not run tests".
+const NOT_TESTED_RE = /\b(?:not|un)[\s-]?tested\b|\bno tests? (?:were |was )?(?:run|ran|written|added)\b|\b(?:did not|didn't|have not|haven't) (?:run|write) (?:any |the )?tests?\b/i;
+// A report that tests ran green: "tests pass", "the suite is green", "12 tests passed", "all specs passing".
+const TESTS_PASSED_RE = /\b(?:tests?|suites?|specs?)\b[^.\n]{0,40}\b(?:pass(?:es|ed|ing)?|green|succeed(?:s|ed)?)\b|\b\d+\s+pass(?:ed|ing)?\b/i;
+
+/**
+ * Is the worker-claim question left out for this turn? Only at None, for a run that got the
+ * TESTING block: the worker was told not to test and to say "Not tested", so a "done" with no test
+ * output is the report that was asked for, not a claim to check. Still judged, at every level: a
+ * message that says tests passed, and a turn in which a command or a tool failed.
+ * `text`: the worker's final message; `evidence`: assistant-evidence.js evidenceSnapshot.
+ */
+export function claimCheckWaived({ level, taskClass = null, text = '', evidence = null } = {}) {
+  if (level === null || level === undefined || level === '') return false;
+  if (normalizeTestDensity(level) !== 'none' || !testingApplies(taskClass)) return false;
+  const message = String(text || '');
+  if (!NOT_TESTED_RE.test(message) || TESTS_PASSED_RE.test(message)) return false;
+  const commands = Array.isArray(evidence?.commands) ? evidence.commands : [];
+  const results = Array.isArray(evidence?.results) ? evidence.results : [];
+  if (commands.some((c) => c?.exit === 'error') || results.some((r) => r?.is_error === true)) return false;
+  return true;
+}

package/neural-interface/lib/assistant-user-context-budgets.js

@@ -0,0 +1,123 @@
+// ═══════════════════════════════════════════
+// SynaBun — Assistant user context: every number and name in one place
+// ═══════════════════════════════════════════
+//
+// The user-context engine (assistant-user-context.js: what the Assistant knows
+// about the user, the nudges from recent conversations, the learning loop)
+// reads all of its limits from here. Pure: no I/O, no SynaBun imports.
+
+/** `assistant-config.json` → `userContext`: the three layers, all on by default. */
+export const USER_CONTEXT_DEFAULTS = Object.freeze({ knowledge: true, nudges: true, trace: true });
+
+/** The settings as booleans; anything that is not exactly `false` reads as on. */
+export function normalizeUserContext(raw) {
+  const value = raw && typeof raw === 'object' ? raw : {};
+  return { knowledge: value.knowledge !== false, nudges: value.nudges !== false, trace: value.trace !== false };
+}
+
+// Where the engine keeps what it learns: two child categories, created on first use.
+export const CATEGORIES = Object.freeze({
+  knowledge: 'user-knowledge',
+  knowledgeParent: 'communication-style',
+  threads: 'assistant-threads',
+  threadsParent: 'conversations',
+});
+export const CATEGORY_DESCRIPTIONS = Object.freeze({
+  knowledge: 'One statement per memory about how the user wants the Assistant to work: line 1 is the statement, then Evidence lines and a "Seen N× · confidence X · facet F" line. Written by the SynaBun Assistant\'s learning loop; edit line 1 to correct a statement. Do not store session summaries here.',
+  knowledgeParent: 'How the user communicates and wants work done: preferences, corrections, standing instructions.',
+  threads: 'One memory per SynaBun Assistant conversation, rewritten in place by the harness: title, time span, the last asks, runs with outcomes and open items. Do not store anything else here.',
+  threadsParent: 'Records of past conversations and sessions.',
+});
+
+/** What a statement is about. A memory's `subcategory` is one of these. */
+export const FACETS = Object.freeze(['instructions', 'expectations', 'decisions', 'corrections', 'expertise', 'rules', 'goals']);
+/** The memory kinds a statement can have. */
+export const KNOWLEDGE_KINDS = Object.freeze(['preference', 'decision', 'fact']);
+/** facet → memory kind. */
+export const FACET_KIND = Object.freeze({
+  instructions: 'preference', expectations: 'preference', corrections: 'preference', rules: 'preference',
+  decisions: 'decision', expertise: 'fact', goals: 'fact',
+});
+
+/** The digest in the system-level slot. */
+export const DIGEST = Object.freeze({
+  maxTokens: 300,
+  perFacet: 3,
+  statementMaxChars: 160,
+  // Rows read from the store before ranking (newest first): bounds the work, not the digest.
+  readLimit: 400,
+});
+
+/** The per-turn block. */
+export const TURN_BLOCK = Object.freeze({
+  firstTokens: 120,
+  laterTokens: 80,
+  // One item: short enough that the later budget holds the header and one of them.
+  itemMaxChars: 160,
+  // Deltas (knowledge learned since the digest was frozen) said in one turn.
+  deltasPerTurn: 2,
+});
+
+/** Nudges from recent interactions. */
+export const NUDGES = Object.freeze({
+  // The last thread is offered at session open when it is in the same project, or this recent.
+  lastThreadHours: 24,
+  // A pause this long between two turns of one conversation is said once.
+  gapHours: 4,
+  openItemsShown: 2,
+  // Significant words an open item shares with the prompt before it counts as overlapping.
+  overlapWords: 2,
+  // Keys kept in assistant-user-context.json.
+  nudgedKept: 500,
+  threadsKept: 300,
+});
+
+/** The learning loop. */
+export const LEARN = Object.freeze({
+  minChars: 16,
+  // A paste this long, or this many lines, is not the user's typed words.
+  pasteChars: 200,
+  pasteLines: 4,
+  messageClip: 2000,
+  replyClip: 600,
+  maxSentences: 12,
+  sentenceClip: 300,
+  knownStatements: 6,
+  // Jev thresholds: a durable signal, a match with a known statement, a contradiction
+  // (the bar automatic supersession uses), the writer's statement adding nothing.
+  durableMin: 0.8,
+  matchMin: 0.7,
+  contradictMin: 0.9,
+  faithfulMin: 0.8,
+  evidenceMax: 3,
+  quoteMax: 200,
+  // Per session.
+  gateCap: 30,
+  writerCap: 8,
+  writeCap: 6,
+  hashesKept: 60,
+  timeoutMs: 4000,
+});
+
+/** The thread record (one memory per conversation). */
+export const THREAD = Object.freeze({
+  asks: 6,
+  askClip: 120,
+  runs: 8,
+  openItems: 6,
+  itemClip: 160,
+  // The memory is rewritten this long after the conversation's last turn ended.
+  writeDebounceMs: 45_000,
+});
+
+/** The statement writer (a Claude one-shot on the cheapest Claude model). */
+export const WRITER = Object.freeze({
+  timeoutMs: 20_000,
+  // The CLI's own alias: used when the catalog names no cheaper Claude model.
+  fallbackModel: 'haiku',
+});
+
+/** The repo's estimator (mcp-server memory-retrieval `estimateTokens`): UTF-8 bytes / 3, which over-counts. */
+export function estimateTokens(value) {
+  return Math.ceil(Buffer.byteLength(String(value ?? ''), 'utf8') / 3);
+}