mixdog 0.9.3 → 0.9.5

package/scripts/tui-render-smoke.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * scripts/tui-render-smoke.mjs — undeclared-identifier gate for the TUI bundle.
+ *
+ * Why: esbuild does not flag free (undeclared) identifiers in JSX modules —
+ * they may legitimately be runtime globals — and no smoke actually renders
+ * App. That gap shipped two ReferenceErrors (promptContentRows,
+ * TRANSCRIPT_WINDOW_OVERSCAN_ROWS) during the App.jsx split.
+ *
+ * How: parse src/tui/dist/index.mjs with acorn, run eslint-scope, and fail on
+ * any reference that resolves to no binding and is not a known JS/Node/DOM
+ * global. Static, deterministic, no terminal or engine session needed.
+ *
+ * Run:  node scripts/tui-render-smoke.mjs   (or `npm run smoke:tui`)
+ * Exit: 0 = clean, 1 = undeclared identifiers found or bundle missing.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from 'acorn';
+import { analyze } from 'eslint-scope';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const BUNDLE = join(ROOT, 'src', 'tui', 'dist', 'index.mjs');
+
+// Globals that are legal free identifiers in the bundle. Anything outside
+// this set that resolves to no binding is a guaranteed ReferenceError at
+// runtime (module scope is strict; there is no window fallback in node ESM).
+const KNOWN_GLOBALS = new Set([
+  // ECMAScript builtins
+  'Array', 'ArrayBuffer', 'Atomics', 'BigInt', 'BigInt64Array', 'BigUint64Array', 'Boolean',
+  'DataView', 'Date', 'Error', 'EvalError', 'FinalizationRegistry', 'Float32Array',
+  'Float64Array', 'Function', 'Infinity', 'Int8Array', 'Int16Array', 'Int32Array',
+  'Intl', 'JSON', 'Map', 'Math', 'NaN', 'Number', 'Object', 'Promise', 'Proxy',
+  'RangeError', 'ReferenceError', 'Reflect', 'RegExp', 'Set', 'SharedArrayBuffer',
+  'String', 'Symbol', 'SyntaxError', 'TypeError', 'URIError', 'Uint8Array',
+  'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap', 'WeakRef', 'WeakSet',
+  'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'eval',
+  'globalThis', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined',
+  // Node.js globals
+  'AbortController', 'AbortSignal', 'Blob', 'Buffer', 'ByteLengthQueuingStrategy',
+  'CompressionStream', 'CountQueuingStrategy', 'Crypto', 'CryptoKey', 'CustomEvent',
+  'DecompressionStream', 'Event', 'EventTarget', 'File', 'FormData', 'Headers',
+  'MessageChannel', 'MessageEvent', 'MessagePort', 'Navigator', 'PerformanceEntry',
+  'PerformanceObserver', 'ReadableStream', 'ReadableStreamDefaultReader', 'Request',
+  'Response', 'SubtleCrypto', 'TextDecoder', 'TextDecoderStream', 'TextEncoder',
+  'TextEncoderStream', 'TransformStream', 'URL', 'URLSearchParams', 'WebAssembly',
+  'WebSocket', 'WritableStream', 'atob', 'btoa', 'clearImmediate', 'clearInterval',
+  'clearTimeout', 'console', 'crypto', 'fetch', 'navigator', 'performance',
+  'process', 'queueMicrotask', 'require', 'setImmediate', 'setInterval',
+  'setTimeout', 'structuredClone',
+  // Bundler/runtime artifacts occasionally referenced defensively
+  'window', 'document', 'reportError',
+]);
+
+if (!existsSync(BUNDLE)) {
+  console.error(`tui-render-smoke: FAIL — bundle not found at ${BUNDLE}; run \`npm run build:tui\` first`);
+  process.exit(1);
+}
+
+const source = readFileSync(BUNDLE, 'utf8');
+
+let ast;
+try {
+  ast = parse(source, { ecmaVersion: 'latest', sourceType: 'module', locations: true, ranges: true });
+} catch (err) {
+  console.error(`tui-render-smoke: FAIL — bundle does not parse: ${err.message}`);
+  process.exit(1);
+}
+
+const scopeManager = analyze(ast, { ecmaVersion: 2022, sourceType: 'module' });
+const unresolved = scopeManager.globalScope.through.filter(
+  (ref) => !KNOWN_GLOBALS.has(ref.identifier.name),
+);
+
+if (unresolved.length > 0) {
+  const seen = new Map();
+  for (const ref of unresolved) {
+    const { name } = ref.identifier;
+    if (!seen.has(name)) seen.set(name, ref.identifier.loc?.start);
+  }
+  console.error(`tui-render-smoke: FAIL — ${seen.size} undeclared identifier(s) in src/tui/dist/index.mjs:`);
+  for (const [name, loc] of seen) {
+    console.error(`  ${name} (dist/index.mjs:${loc ? `${loc.line}:${loc.column}` : '?'})`);
+  }
+  console.error('These throw ReferenceError when the TUI renders. Fix missing imports in src/tui/ and rebuild.');
+  process.exit(1);
+}
+
+console.log('tui-render-smoke: ok — no undeclared identifiers in TUI bundle');

package/scripts/webhook-smoke.mjs

@@ -0,0 +1,208 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as crypto from 'node:crypto';
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { readMarkdownDocument } from '../src/runtime/shared/markdown-frontmatter.mjs';
+
+// DATA_DIR resolves from MIXDOG_DATA_DIR at module import time (via
+// ./config.mjs -> resolvePluginData), so the env var MUST be set before
+// the first dynamic import of webhook.mjs.
+const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-webhook-test-'));
+process.env.MIXDOG_DATA_DIR = dataDir;
+
+const {
+  extractSignature,
+  verifySignature,
+  loadEndpointConfig,
+  STRIPE_TOLERANCE_MS,
+} = await import('../src/runtime/channels/lib/webhook.mjs');
+
+function hmacHex(secret, payload) {
+  return crypto.createHmac('sha256', secret).update(payload).digest('hex');
+}
+
+// ── verifySignature: github/generic hex HMAC ──────────────────────────
+
+test('verifySignature: github parser accepts a valid sha256 hex signature', () => {
+  const secret = 'shh';
+  const body = '{"hello":"world"}';
+  const sig = hmacHex(secret, body);
+  assert.equal(verifySignature(secret, body, sig, 'github'), true);
+});
+
+test('verifySignature: generic parser accepts a valid sha256 hex signature', () => {
+  const secret = 'shh';
+  const body = '{"hello":"world"}';
+  const sig = hmacHex(secret, body);
+  assert.equal(verifySignature(secret, body, sig, 'generic'), true);
+});
+
+test('verifySignature: github/generic reject a wrong signature', () => {
+  const secret = 'shh';
+  const body = '{"hello":"world"}';
+  const wrong = hmacHex('other-secret', body);
+  assert.equal(verifySignature(secret, body, wrong, 'github'), false);
+});
+
+test('verifySignature: length-mismatch hex signature returns false without throwing', () => {
+  const secret = 'shh';
+  const body = 'payload';
+  // Valid hex, wrong byte length vs the 32-byte sha256 digest.
+  assert.doesNotThrow(() => {
+    assert.equal(verifySignature(secret, body, 'ab', 'github'), false);
+  });
+});
+
+test('verifySignature: malformed (non-hex) signature returns false without throwing', () => {
+  const secret = 'shh';
+  const body = 'payload';
+  assert.doesNotThrow(() => {
+    assert.equal(verifySignature(secret, body, 'not-hex-zzzz', 'github'), false);
+  });
+});
+
+// ── verifySignature: stripe t= / v1= scheme ───────────────────────────
+
+test('verifySignature: stripe accepts a valid t+v1 pair', () => {
+  const secret = 'stripe-secret';
+  const body = '{"id":"evt_1"}';
+  const t = Math.floor(Date.now() / 1000);
+  const v1 = hmacHex(secret, `${t}.${body}`);
+  assert.equal(verifySignature(secret, body, `t=${t},v1=${v1}`, 'stripe'), true);
+});
+
+test('verifySignature: stripe rejects a header missing t=', () => {
+  const secret = 'stripe-secret';
+  const body = '{"id":"evt_1"}';
+  const t = Math.floor(Date.now() / 1000);
+  const v1 = hmacHex(secret, `${t}.${body}`);
+  assert.equal(verifySignature(secret, body, `v1=${v1}`, 'stripe'), false);
+});
+
+test('verifySignature: stripe rejects a header missing v1=', () => {
+  const secret = 'stripe-secret';
+  const body = '{"id":"evt_1"}';
+  const t = Math.floor(Date.now() / 1000);
+  assert.equal(verifySignature(secret, body, `t=${t}`, 'stripe'), false);
+});
+
+test('verifySignature: stripe rejects a stale timestamp beyond the tolerance window (replay)', () => {
+  const secret = 'stripe-secret';
+  const body = '{"id":"evt_1"}';
+  const staleT = Math.floor((Date.now() - STRIPE_TOLERANCE_MS - 60_000) / 1000);
+  const v1 = hmacHex(secret, `${staleT}.${body}`);
+  assert.equal(verifySignature(secret, body, `t=${staleT},v1=${v1}`, 'stripe'), false);
+});
+
+test('verifySignature: stripe rejects a tampered v1 (HMAC mismatch) with a fresh t', () => {
+  const secret = 'stripe-secret';
+  const body = '{"id":"evt_1"}';
+  const t = Math.floor(Date.now() / 1000);
+  const tamperedV1 = hmacHex('wrong-secret', `${t}.${body}`);
+  assert.equal(verifySignature(secret, body, `t=${t},v1=${tamperedV1}`, 'stripe'), false);
+});
+
+// ── extractSignature: parser mapping + fallback scan ──────────────────
+
+test('extractSignature: github parser strips the sha256= prefix from x-hub-signature-256', () => {
+  const headers = { 'x-hub-signature-256': 'sha256=deadbeef' };
+  assert.equal(extractSignature(headers, 'github'), 'deadbeef');
+});
+
+test('extractSignature: generic parser strips the sha256= prefix from x-signature-256', () => {
+  const headers = { 'x-signature-256': 'sha256=cafebabe' };
+  assert.equal(extractSignature(headers, 'generic'), 'cafebabe');
+});
+
+test('extractSignature: stripe parser returns the raw stripe-signature value (no prefix)', () => {
+  const headers = { 'stripe-signature': 't=1,v1=abc123' };
+  assert.equal(extractSignature(headers, 'stripe'), 't=1,v1=abc123');
+});
+
+test('extractSignature: sentry parser returns the raw sentry-hook-signature value', () => {
+  const headers = { 'sentry-hook-signature': 'raw-sig-value' };
+  assert.equal(extractSignature(headers, 'sentry'), 'raw-sig-value');
+});
+
+test('extractSignature: unknown parser name falls back to scanning all known headers', () => {
+  const headers = { 'x-signature-256': 'sha256=fallback-hit' };
+  assert.equal(extractSignature(headers, 'no-such-parser'), 'fallback-hit');
+});
+
+test('extractSignature: no parser given scans known headers in declaration order', () => {
+  const headers = { 'x-hub-signature-256': 'sha256=github-hit' };
+  assert.equal(extractSignature(headers, undefined), 'github-hit');
+});
+
+test('extractSignature: returns null when no known signature header is present', () => {
+  const headers = { 'x-some-other-header': 'value' };
+  assert.equal(extractSignature(headers, 'github'), null);
+});
+
+// ── endpoint config loader: WEBHOOK.md frontmatter + secret side file ─
+
+test('loadEndpointConfig: loads frontmatter + reads secret from side file', () => {
+  const name = 'my-endpoint';
+  const dir = join(dataDir, 'webhooks', name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, 'WEBHOOK.md'),
+    [
+      '---',
+      'channel: main',
+      'parser: github',
+      'enabled: true',
+      '---',
+      '',
+      'Handle this webhook by summarizing the payload.',
+      '',
+    ].join('\n'),
+    'utf8',
+  );
+  writeFileSync(join(dir, 'secret'), 'my-webhook-secret\n', 'utf8');
+
+  const cfg = loadEndpointConfig(name);
+  assert.equal(cfg.channel, 'main');
+  assert.equal(cfg.parser, 'github');
+  assert.equal(cfg.enabled, true);
+});
+
+test('loadEndpointConfig: enabled: false frontmatter casts to boolean false', () => {
+  const name = 'disabled-endpoint';
+  const dir = join(dataDir, 'webhooks', name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, 'WEBHOOK.md'),
+    ['---', 'channel: main', 'enabled: false', '---', '', 'body text', ''].join('\n'),
+    'utf8',
+  );
+  const cfg = loadEndpointConfig(name);
+  assert.equal(cfg.enabled, false);
+});
+
+test('loadEndpointConfig: returns null for a name with no WEBHOOK.md', () => {
+  assert.equal(loadEndpointConfig('never-registered'), null);
+});
+
+// loadEndpointConfig only surfaces the frontmatter (by design — see
+// webhook.mjs comment above loadEndpointConfig); confirm the underlying
+// shared parser it delegates to also recovers the markdown body, since
+// the loader's frontmatter/body split is not independently exercised
+// through the exported loadEndpointConfig surface.
+test('readMarkdownDocument: WEBHOOK.md-shaped input yields frontmatter + body', () => {
+  const raw = [
+    '---',
+    'channel: main',
+    'parser: github',
+    '---',
+    '',
+    'Handle this webhook by summarizing the payload.',
+    '',
+  ].join('\n');
+  const { frontmatter, body } = readMarkdownDocument(raw);
+  assert.equal(frontmatter.channel, 'main');
+  assert.equal(frontmatter.parser, 'github');
+  assert.equal(body, 'Handle this webhook by summarizing the payload.');
+});

package/src/agents/debugger/AGENT.md

@@ -8,4 +8,7 @@ Root-cause analysis agent.
 
 Smallest confirmed cause chain before fixes. Return likely cause, evidence
 (`file:line`), smallest next check/fix. Mark confirmed facts vs inferences;
-avoid broad speculation.
+avoid broad speculation. Fragments only; no narration, no report bloat.
+
+Converge, don't sweep: when new reads stop adding evidence, report the best
+cause chain so far — a partial/blocked report is a valid completion.

package/src/agents/heavy-worker/AGENT.md

@@ -8,13 +8,14 @@ Broad implementation agent.
 Bounded slices; smallest coherent change, not rewrite. Stop: unclear scope,
 growing blast radius, or Lead-only verification.
 
-EDIT-FIRST DISCIPLINE. Survey the slice with ONE batched read/grep round,
-then start patching the first bounded piece — broad scope means edit
-incrementally, not read exhaustively. NEVER "one more confirming read": if
-an anchor is plausible, the next call is `apply_patch`. 3+ consecutive
-read-only calls without an edit = stalling — patch the piece you understand
-or stop and report blocked. Self-check comes AFTER edits; deep verification
-is Lead's.
+EDIT-FIRST DISCIPLINE. Survey the slice with ONE batched read/grep round, then
+patch the first bounded piece — broad scope means edit incrementally, not read
+exhaustively. NEVER "one more confirming read": if an anchor is plausible, the
+next call is `apply_patch`. Repeated read-only turns without an edit = stalling;
+any runtime reminder is your cue to patch the piece you understand or report
+blocked — a blocked report is a valid completion. Self-check comes AFTER edits;
+deep verification is Lead's.
 
-Minimal checks + how-to-verify.
+Minimal checks + how-to-verify. Hand off outcome as fragments anchored to
+`file:line`; no narration, no report bloat.
 

package/src/agents/maintainer/AGENT.md

@@ -5,3 +5,7 @@ permission: read-write
 # Maintainer
 
 Maintenance and cleanup agent.
+
+Smallest coherent change; no scope growth. Repeated read-only turns without
+an edit = stalling; patch or return blocked — a blocked report is a valid
+completion. Hand off as fragments (`file:line`); no narration.

package/src/agents/reviewer/AGENT.md

@@ -8,4 +8,5 @@ Regression/risk review agent.
 
 Find actionable correctness/regression/security/verification risks. Findings
 first, severity-ordered, one line with `file:line`; skip non-risky nits. If
-clean, one line + only material residual risk.
+clean, one line + only material residual risk. Fragments only; no narration,
+no report bloat.

package/src/agents/scheduler-task/AGENT.md

@@ -7,6 +7,5 @@ toolSchemaProfile: read-write-search
 
 Scheduled task execution agent.
 
-Output a concise English handoff for Lead: outcome, action taken or skipped,
-notable evidence, and any remaining risk. If there is nothing actionable, use
-the skip protocol.
+Concise English handoff for Lead: outcome, action taken or skipped, notable
+evidence, remaining risk. Nothing actionable → use the skip protocol.

package/src/agents/webhook-handler/AGENT.md

@@ -7,6 +7,5 @@ toolSchemaProfile: read-write-search
 
 Inbound webhook event analysis agent.
 
-Output a concise English handoff for Lead: event outcome, action taken or
-skipped, notable evidence, and any remaining risk. If there is nothing
-actionable, use the skip protocol.
+Concise English handoff for Lead: event outcome, action taken or skipped,
+notable evidence, remaining risk. Nothing actionable → use the skip protocol.

package/src/agents/worker/AGENT.md

@@ -7,11 +7,14 @@ Scoped implementation agent.
 
 Smallest scoped change; no drive-by cleanup. Stop when done/blocked.
 
-EDIT-FIRST DISCIPLINE. Brief anchors (`file:line`) are pre-verified — trust
-them and patch. No anchor: locate with AT MOST 1-2 reads, then edit. NEVER
-"one more confirming read": if you know the file and the change, the next
-call is `apply_patch`. 3+ read-only calls without an edit = you are stalling
-— either patch now or return blocked with what's missing. Confidence
-threshold is "plausible", not "proven"; self-check comes AFTER the edit, and
-Lead/Reviewer own final verification.
+EDIT-FIRST DISCIPLINE. Brief anchors (`file:line`) are pre-verified — trust and
+patch. No anchor: locate with AT MOST 1-2 reads, then edit. NEVER "one more
+confirming read": if you know the file and the change, the next call is
+`apply_patch`. Repeated read-only turns without an edit = stalling; any runtime
+reminder is your cue to patch now or return blocked with what's missing — a
+blocked report is a valid completion. Threshold is "plausible", not "proven";
+self-check comes AFTER the edit, and Lead/Reviewer own final verification.
+
+Hand off outcome as fragments anchored to `file:line`; no narration, no report
+bloat.
 

package/src/app.mjs

@@ -4,8 +4,12 @@ import { fileURLToPath } from 'node:url';
 import { performance } from 'node:perf_hooks';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const VALUE_OPTIONS = new Set(['--provider', '--model']);
+// --workflow is consumed (with its value) but ignored on the headless role
+// path: workflow selection is Lead-session-scoped. Accepting it keeps a
+// mistakenly passed `--workflow X` from leaking "X" into the role message.
+const VALUE_OPTIONS = new Set(['--provider', '--model', '--effort', '--workflow']);
 const FLAG_OPTIONS = new Set(['--readonly', '--help', '-h', '--plain', '--react', '--remote', '--onboarding']);
+const HEADLESS_FLAG_OPTIONS = new Set(['--fast']);
 const HEADLESS_ROLE_ALIASES = new Map([
   ['explorer', 'explore'],
   ['explore', 'explore'],
@@ -52,6 +56,7 @@ function unknownOption(argv) {
       continue;
     }
     if (FLAG_OPTIONS.has(arg)) continue;
+    if (HEADLESS_FLAG_OPTIONS.has(arg)) continue;
     if (String(arg || '').startsWith('-')) return arg;
   }
   return null;
@@ -66,6 +71,7 @@ function positionalArgs(argv) {
       continue;
     }
     if (FLAG_OPTIONS.has(arg)) continue;
+    if (HEADLESS_FLAG_OPTIONS.has(arg)) continue;
     if (String(arg || '').startsWith('-')) continue;
     out.push(arg);
   }
@@ -109,12 +115,15 @@ export async function run(argv = []) {
 
   const provIdx = argv.indexOf('--provider');
   const modelIdx = argv.indexOf('--model');
+  const effortIdx = argv.indexOf('--effort');
   const toolMode = argv.includes('--readonly') ? 'readonly' : 'full';
   const remote = argv.includes('--remote');
   const forceOnboarding = argv.includes('--onboarding');
   const opts = {
     provider: provIdx >= 0 ? argv[provIdx + 1] : undefined,
     model: modelIdx >= 0 ? argv[modelIdx + 1] : undefined,
+    effort: effortIdx >= 0 ? argv[effortIdx + 1] : undefined,
+    fast: argv.includes('--fast'),
     toolMode,
     remote,
     forceOnboarding,
@@ -150,6 +159,8 @@ export async function run(argv = []) {
       message: headless.message,
       provider: opts.provider,
       model: opts.model,
+      effort: opts.effort,
+      fast: opts.fast,
       cwd: process.cwd(),
     });
   }

package/src/headless-role.mjs

@@ -25,7 +25,7 @@ function makeTag(agent) {
     .replace(/^-+|-+$/g, '');
 }
 
-export function buildHeadlessSpawnArgs({ agent, tag, cwd, message, provider, model } = {}) {
+export function buildHeadlessSpawnArgs({ agent, tag, cwd, message, provider, model, effort, fast } = {}) {
   const spawnArgs = {
     type: 'spawn',
     agent: clean(agent),
@@ -35,6 +35,8 @@ export function buildHeadlessSpawnArgs({ agent, tag, cwd, message, provider, mod
   };
   if (clean(provider)) spawnArgs.provider = clean(provider);
   if (clean(model)) spawnArgs.model = clean(model);
+  if (clean(effort)) spawnArgs.effort = clean(effort);
+  if (fast === true) spawnArgs.fast = true;
   return spawnArgs;
 }
 
@@ -56,6 +58,8 @@ export async function runHeadlessRole({
   message,
   provider,
   model,
+  effort,
+  fast,
   cwd = process.cwd(),
   write = (text) => stdout.write(text),
   writeErr = (text) => stderr.write(text),
@@ -86,6 +90,8 @@ export async function runHeadlessRole({
     message: cleanMessage,
     provider,
     model,
+    effort,
+    fast,
   });
 
   let taskId = null;

package/src/lib/rules-builder.cjs

@@ -21,6 +21,7 @@
  * Source files (rules/):
  *   - shared/01-tool.md              — universal tool policy (Lead + agent BP1, identical full set)
  *   - lead/lead-tool.md             — Lead-specific control-tower / delegation / ToolSearch guidance
+ *   - lead/lead-brief.md            — Lead brief contract (agent handoff briefs)
  *   - lead/01-02                     — Lead general / channels
  *   - output-styles/<name>.md        — Lead output style, selected by config outputStyle
  *   - agent/00-common.md             — agent common behavior + universal worker contract (BP2)
@@ -275,6 +276,9 @@ function buildLeadRoleContent({ PLUGIN_ROOT, DATA_DIR }) {
   const toolLead = readOptional(path.join(LEAD_DIR, 'lead-tool.md'));
   if (toolLead) parts.push(toolLead);
 
+  const briefLead = readOptional(path.join(LEAD_DIR, 'lead-brief.md'));
+  if (briefLead) parts.push(briefLead);
+
   if (generalSplit.role) parts.push(generalSplit.role);
 
   const channels = readOptional(path.join(LEAD_DIR, '02-channels.md'));