sneakoscope 4.1.0 → 4.2.0

package/dist/core/mad-db/mad-db-target.js

@@ -0,0 +1,64 @@
+import path from 'node:path';
+import { exists, readText, sha256 } from '../fsx.js';
+export async function resolveMadDbTarget(root, input = {}) {
+    const args = input.args || [];
+    const explicit = input.projectRef || readOption(args, '--project-ref', '') || process.env.SKS_MAD_DB_PROJECT_REF || process.env.SKS_MAD_DB_E2E_PROJECT_REF || '';
+    const candidates = explicit ? [explicit] : await projectRefCandidates(root);
+    const projectRef = explicit || (candidates.length === 1 ? candidates[0] || '' : '');
+    const target = normalizeTarget(input.target || readOption(args, '--target', '') || process.env.SKS_MAD_DB_TARGET || process.env.SKS_MAD_DB_E2E_TARGET || 'production');
+    const allowedSchemas = input.allowedSchemas?.length
+        ? input.allowedSchemas
+        : splitCsv(readOption(args, '--schema', readOption(args, '--schemas', process.env.SKS_MAD_DB_SCHEMAS || 'public')));
+    const blockers = [];
+    if (!projectRef)
+        blockers.push(candidates.length > 1 ? 'mad_db_project_ref_ambiguous' : 'mad_db_project_ref_missing');
+    return {
+        schema: 'sks.mad-db-target.v1',
+        project_ref: projectRef || null,
+        project_ref_hash: projectRef ? sha256(projectRef).slice(0, 16) : null,
+        target_environment: target,
+        allowed_schemas: allowedSchemas.length ? allowedSchemas : ['public'],
+        source: explicit ? 'explicit_or_environment' : candidates.length === 1 ? 'managed_config_single_candidate' : 'unresolved',
+        blockers,
+        candidates: candidates.map((candidate) => `${sha256(candidate).slice(0, 8)}:${candidate.slice(0, 2)}...`)
+    };
+}
+export async function projectRootHash(root) {
+    return sha256(path.resolve(root)).slice(0, 24);
+}
+async function projectRefCandidates(root) {
+    const files = ['.codex/config.toml', '.mcp.json', 'mcp.json', '.cursor/mcp.json', '.vscode/mcp.json'];
+    const out = new Set();
+    for (const rel of files) {
+        const file = path.join(root, rel);
+        if (!(await exists(file)))
+            continue;
+        const text = await readText(file, '');
+        for (const match of String(text).matchAll(/project_ref=([a-z0-9_-]+)/gi))
+            out.add(match[1] || '');
+        for (const match of String(text).matchAll(/project_ref["']?\s*[:=]\s*["']([a-z0-9_-]+)["']/gi))
+            out.add(match[1] || '');
+    }
+    return [...out].filter(Boolean);
+}
+function normalizeTarget(value) {
+    const text = String(value || '').toLowerCase();
+    if (text === 'local')
+        return 'local';
+    if (text === 'branch')
+        return 'branch';
+    if (text === 'preview')
+        return 'preview';
+    return 'production';
+}
+function splitCsv(value) {
+    return String(value || '').split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+function readOption(args, name, fallback) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return String(args[index + 1]);
+    const prefixed = args.find((arg) => String(arg).startsWith(`${name}=`));
+    return prefixed ? prefixed.slice(name.length + 1) : fallback;
+}
+//# sourceMappingURL=mad-db-target.js.map

package/dist/core/managed-assets/managed-assets-manifest.js

@@ -1,15 +1,15 @@
 import { REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
 export const MANAGED_ASSET_SCHEMA_VERSION = 1;
-export const MANAGED_ASSET_VERSION = '4.1.0';
+export const MANAGED_ASSET_VERSION = '4.2.0';
 export const MANAGED_ASSET_MARKER = 'SKS-MANAGED-ASSET';
 export const MANAGED_AGENT_ROLES = Object.freeze([
     role('sks-explorer', 'analysis-scout.toml', 'analysis_scout', 'Read-only SKS analysis scout retained for stale Codex agent-role config repair.', 'read-only', ['analysis-scout', 'analysis_scout', 'native_agent']),
     role('sks-planner', 'team-consensus.toml', 'team_consensus', 'Planning and debate specialist for SKS Team mode.', 'read-only', ['team-consensus', 'team_consensus']),
     role('sks-implementer', 'implementation-worker.toml', 'implementation_worker', 'Implementation specialist for bounded SKS Team write sets.', 'workspace-write', ['implementation-worker', 'implementation_worker']),
     role('sks-checker', 'qa-reviewer.toml', 'qa_reviewer', 'Strict read-only verification reviewer for correctness, regressions, and final evidence.', 'read-only', ['qa-reviewer', 'qa_reviewer']),
-    role('sks-release-verifier', 'native-agent-intake.toml', 'native_agent', 'Read-only Team native agent for repository/docs/tests/API/risk slices.', 'read-only', ['native-agent-intake', 'native_agent']),
-    role('sks-zellij-ui-verifier', 'native-agent-intake.toml', 'native_agent', 'Read-only Team native agent for repository/docs/tests/API/risk slices.', 'read-only', ['native-agent-intake', 'native_agent']),
-    role('sks-codex-probe-verifier', 'native-agent-intake.toml', 'native_agent', 'Read-only Team native agent for repository/docs/tests/API/risk slices.', 'read-only', ['native-agent-intake', 'native_agent']),
+    role('sks-release-verifier', 'sks-release-verifier.toml', 'sks_release_verifier', 'Read-only release verifier for repository, docs, tests, API, and risk slices.', 'read-only', ['native-agent-intake', 'native_agent', 'release-verifier']),
+    role('sks-zellij-ui-verifier', 'sks-zellij-ui-verifier.toml', 'sks_zellij_ui_verifier', 'Read-only Zellij UI verifier for session, pane, layout, and terminal evidence.', 'read-only', ['native-agent-intake', 'native_agent', 'zellij-ui-verifier']),
+    role('sks-codex-probe-verifier', 'sks-codex-probe-verifier.toml', 'sks_codex_probe_verifier', 'Read-only Codex probe verifier for CLI, App, SDK, MCP, and native capability evidence.', 'read-only', ['native-agent-intake', 'native_agent', 'codex-probe-verifier']),
     role('db-safety-reviewer', 'db-safety-reviewer.toml', 'db_safety_reviewer', 'Read-only database safety reviewer for SQL, migrations, Supabase, and rollback safety.', 'read-only', ['db-safety-reviewer', 'db_safety_reviewer'])
 ]);
 export const MANAGED_SKILLS = Object.freeze([
@@ -41,6 +41,7 @@ export const CONTEXT7_MANAGED_SERVER = Object.freeze({
 });
 export function managedAgentRoleByFile(filename) {
     const base = filename.split(/[\\/]/).pop() || filename;
+    assertUniqueManagedAgentRoleFilenames();
     return MANAGED_AGENT_ROLES.find((role) => role.filename === base) || null;
 }
 export function managedAgentRoleByName(name) {
@@ -87,6 +88,15 @@ export function managedAgentRoleOwnsText(text, role) {
 export function normalizeRoleName(name) {
     return String(name || '').trim().replace(/\.toml$/i, '').replace(/_/g, '-').toLowerCase();
 }
+export function assertUniqueManagedAgentRoleFilenames() {
+    const seen = new Map();
+    for (const role of MANAGED_AGENT_ROLES) {
+        const existing = seen.get(role.filename);
+        if (existing)
+            throw new Error(`duplicate managed agent role filename: ${role.filename} for ${existing} and ${role.id}`);
+        seen.set(role.filename, role.id);
+    }
+}
 function role(id, filename, codexName, description, sandbox, aliases) {
     return {
         id,

package/dist/core/pipeline-internals/runtime-core.js

@@ -22,6 +22,7 @@ import { SPEED_LANE_POLICY } from '../proof-field.js';
 import { validateRouteCompletionProof } from '../proof/route-proof-gate.js';
 import { routeFromState, routeRequiresCompletionProof } from '../proof/route-proof-policy.js';
 import { permissionGateSummary } from '../permission-gates.js';
+import { prepareMadDbMission } from '../mad-db/mad-db-coordinator.js';
 import { AGENT_INTAKE_STAGE_ID, AGENT_COUNT } from '../agents/agent-schema.js';
 import { normalizeAgentPolicy, routeRequiresAgentIntake, agentPipelineStage } from '../agents/agent-plan.js';
 import { readAgentGateStatus } from '../agents/agent-gate.js';
@@ -458,6 +459,8 @@ export function promptPipelineContext(prompt, route = null) {
         lines.push('AutoResearch route: load autoresearch-loop plus seo-geo-optimizer when SEO/GEO, discoverability, README, npm, GitHub stars, ranking, or AI-search visibility is relevant.');
     if (route?.id === 'DB')
         lines.push('DB route: scan/check database risk first; destructive DB operations remain forbidden.');
+    if (route?.id === 'MadDB')
+        lines.push('MadDB route: explicit invocation is the SQL-plane approval boundary. Use the mission-local write-capable Supabase MCP profile only for the bound cycle, verify execute_sql/apply_migration inventory before claiming ready, execute requested SQL-plane mutations, read back postconditions, then close the capability/profile and prove normal read-only restoration. Supabase project/account/billing/credential control-plane actions remain denied.');
     if (route?.id === 'GX')
         lines.push('GX route: use deterministic vgraph/beta render, validate, drift, and snapshot artifacts.');
     return lines.join('\n');
@@ -517,6 +520,8 @@ export async function prepareRoute(root, prompt, state = {}) {
         return withSkillDreamContext(await prepareGoal(root, route, task, routeNeedsContext7(route, cleanPrompt)), dreamContext);
     if (route.id === 'ImageUXReview')
         return withSkillDreamContext(await prepareImageUxReview(root, route, task, routeNeedsContext7(route, cleanPrompt)), dreamContext);
+    if (route.id === 'MadDB')
+        return withSkillDreamContext(await prepareMadDb(root, route, task, routeNeedsContext7(route, cleanPrompt)), dreamContext);
     const required = routeNeedsContext7(route, cleanPrompt);
     const reasoning = routeReasoning(route, cleanPrompt);
     const nativeSessionsRequired = routeRequiresSubagents(route, cleanPrompt);
@@ -1111,6 +1116,41 @@ async function prepareDb(root, route, task, required) {
     await setCurrent(root, routeState(id, route, 'DB_REVIEW_REQUIRED', required, { prompt: task, pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }));
     return routeContext(route, id, task, required, 'Run sks db policy/scan/check as needed, keep DB operations read-only, record safe MCP policy, and pass db-review.json.');
 }
+async function prepareMadDb(root, route, task, required) {
+    const prepared = await prepareMadDbMission({ root, task, verifyTools: false });
+    const dir = missionDir(root, prepared.mission_id);
+    const pipelinePlan = await writePipelinePlan(dir, {
+        missionId: prepared.mission_id,
+        route,
+        task,
+        required,
+        ambiguity: { required: true, slots: 0, auto_sealed: true, passed: true, contract_hash: prepared.capability.operator_intent_hash }
+    });
+    await appendJsonl(path.join(dir, 'events.jsonl'), {
+        ts: nowIso(),
+        type: 'mad_db.route_prepared',
+        mission_id: prepared.mission_id,
+        cycle_id: prepared.cycle_id,
+        blockers: prepared.blockers
+    });
+    await setCurrent(root, routeState(prepared.mission_id, route, prepared.ok ? 'MADDB_SQL_PLANE_CAPABILITY_ACTIVE' : 'MADDB_BLOCKED', required, {
+        prompt: task,
+        questions_allowed: false,
+        implementation_allowed: prepared.ok,
+        ambiguity_gate_required: true,
+        ambiguity_gate_passed: true,
+        mad_db_active: prepared.ok,
+        mad_db_cycle_id: prepared.cycle_id,
+        mad_db_runtime_session_id: prepared.capability.runtime_session_id,
+        mad_db_profile_sha256: prepared.capability.transport.profile_sha256,
+        mad_db_capability_mission_id: prepared.mission_id,
+        mad_db_capability_file: 'mad-db-capability.json',
+        stop_gate: 'mad-db-gate.json',
+        pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok,
+        pipeline_plan_path: PIPELINE_PLAN_ARTIFACT
+    }));
+    return routeContext(route, prepared.mission_id, task, required, `MadDB mission/capability/profile were created atomically for cycle ${prepared.cycle_id}. Verify Supabase MCP tool inventory exposes execute_sql and apply_migration before claiming ready; after execution require read-back proof, finally close the profile/capability and prove read-only restoration.`);
+}
 async function prepareGx(root, route, task, required) {
     const { id, dir } = await createMission(root, { mode: 'gx', prompt: task });
     await writeJsonAtomic(path.join(dir, 'gx-gate.json'), { passed: false, vgraph_beta_render: false, validation: false, drift_snapshot: false, context7_evidence: false });

package/dist/core/providers/glm/bench/glm-benchmark-runner.js

@@ -13,6 +13,7 @@ import { runGlmDirectBenchCase } from './glm-direct-bench-runner.js';
 import { computeGlmBenchmarkComparison } from './glm-bench-comparison.js';
 import { buildGlmBenchModelLockProof } from './glm-bench-model-lock-proof.js';
 import { writeGlmBenchReport } from './glm-bench-report.js';
+import { GLM_BENCHMARK_VERSION } from './glm-benchmark-types.js';
 const NARUTO_WORKER_COUNTS = [1, 4, 8, 12];
 export async function runGlmBenchmark(root, args = [], deps = {}) {
     const live = args.includes('--live');
@@ -130,7 +131,7 @@ export async function runGlmBenchmark(root, args = [], deps = {}) {
     };
     const result = {
         schema: 'sks.glm-benchmark-result.v1',
-        version: '4.1.0',
+        version: GLM_BENCHMARK_VERSION,
         generated_at: nowIso(),
         status: 'live',
         model: GLM_52_OPENROUTER_MODEL,
@@ -157,7 +158,7 @@ export async function runGlmBenchmark(root, args = [], deps = {}) {
 function dryRunResult(root, startedMs) {
     return {
         schema: 'sks.glm-benchmark-result.v1',
-        version: '4.1.0',
+        version: GLM_BENCHMARK_VERSION,
         generated_at: nowIso(),
         status: 'dry_run',
         model: GLM_52_OPENROUTER_MODEL,
@@ -180,7 +181,7 @@ function dryRunResult(root, startedMs) {
 function blockedResult(root, warnings) {
     return {
         schema: 'sks.glm-benchmark-result.v1',
-        version: '4.1.0',
+        version: GLM_BENCHMARK_VERSION,
         generated_at: nowIso(),
         status: 'blocked',
         model: GLM_52_OPENROUTER_MODEL,

package/dist/core/providers/glm/bench/glm-benchmark-types.js

@@ -1,2 +1,2 @@
-export const GLM_BENCHMARK_VERSION = '4.1.0';
+export const GLM_BENCHMARK_VERSION = '4.2.0';
 //# sourceMappingURL=glm-benchmark-types.js.map

package/dist/core/release/release-gate-dag.js

@@ -28,15 +28,16 @@ export async function runReleaseGateDag(input) {
     const preset = input.preset || 'release';
     const manifest = loadReleaseGateManifest(root);
     const presetGates = selectReleaseGatePreset(manifest, preset);
-    const triwikiGraph = input.triwiki !== false && (preset === 'affected' || preset === 'fast' || preset === 'confidence') && input.full !== true
-        ? computeTriWikiAffectedGraph({ root, tier: preset === 'fast' ? 'affected' : 'confidence', changedSince: input.changedSince || 'auto', ...(input.changedFiles ? { changedFiles: input.changedFiles } : {}) })
-        : null;
     const affected = (preset === 'affected' || preset === 'fast' || preset === 'confidence') && input.full !== true
         ? selectAffectedReleaseGates(root, manifest, presetGates, { changedSince: input.changedSince || 'auto', ...(input.changedFiles ? { changedFiles: input.changedFiles } : {}), preset })
         : selectAffectedReleaseGates(root, manifest, presetGates, { full: true, preset });
+    const rootReleaseSurfaceChanged = affected.selection.changed_files.some((file) => file === 'package.json' || file === 'package-lock.json' || file === 'release-gates.v2.json');
+    const triwikiGraph = input.triwiki !== false && !rootReleaseSurfaceChanged && (preset === 'affected' || preset === 'fast' || preset === 'confidence') && input.full !== true
+        ? computeTriWikiAffectedGraph({ root, tier: preset === 'fast' ? 'affected' : 'confidence', changedSince: input.changedSince || 'auto', ...(input.changedFiles ? { changedFiles: input.changedFiles } : {}) })
+        : null;
     const triwikiSelectionUsed = Boolean(triwikiGraph);
     const triwikiConservative = Boolean(triwikiGraph?.conservative_reason);
-    const triwikiSelectedIds = new Set(triwikiGraph && !triwikiConservative ? triwikiGraph.gates : presetGates.map((gate) => gate.id));
+    const triwikiSelectedIds = new Set(triwikiGraph && !triwikiConservative ? triwikiGraph.gates : affected.gates.map((gate) => gate.id));
     const selected = triwikiGraph
         ? presetGates.filter((gate) => triwikiSelectedIds.has(gate.id))
         : affected.gates;
@@ -45,7 +46,7 @@ export async function runReleaseGateDag(input) {
         affected.selection.mode = 'affected';
         affected.selection.selected_gate_ids = selected.map((gate) => gate.id);
         affected.selection.skipped_gate_ids = triwikiSkippedGates;
-        affected.selection.reasons = Object.fromEntries(selected.map((gate) => [gate.id, triwikiConservative ? `triwiki_conservative:${triwikiGraph.conservative_reason}` : 'triwiki-affected']));
+        affected.selection.reasons = Object.fromEntries(selected.map((gate) => [gate.id, triwikiConservative ? `triwiki_conservative_fallback:${triwikiGraph.conservative_reason}` : 'triwiki-affected']));
     }
     const selectedIds = new Set(selected.map((gate) => gate.id));
     const affectedExternalSatisfiedDeps = affected.selection.mode === 'affected'

package/dist/core/routes.js

@@ -231,7 +231,7 @@ export function stackCurrentDocsPolicy(commandPrefix = 'sks') {
         validate_command: `${prefix} wiki validate .sneakoscope/wiki/context-pack.json`,
         priority: 'must_precede_coding_style_defaults',
         examples: [
-            'Supabase hosted projects should prefer sb_publishable_ and sb_secret_ keys over legacy anon/service_role keys when current docs apply.',
+            'Supabase hosted projects should prefer sb_publishable_ and sb_secret_ keys over legacy anon and service role keys when current docs apply.',
             'Next.js 16 deprecates the middleware file convention in favor of proxy.ts/proxy.js.',
             'Vercel Function duration limits, including the 300s default with Fluid Compute, are deployment constraints that must shape long-running server work.'
         ]
@@ -239,7 +239,7 @@ export function stackCurrentDocsPolicy(commandPrefix = 'sks') {
 }
 export function stackCurrentDocsPolicyText(commandPrefix = 'sks') {
     const policy = stackCurrentDocsPolicy(commandPrefix);
-    return `Stack current-docs policy: whenever project tech stack is added or a framework/package/runtime/platform version changes, fetch current docs with Context7 (resolve-library-id then query-docs) or official vendor web docs before coding, record the syntax/limits/security guidance as high-priority TriWiki claims in ${policy.memory_path}, run "${policy.refresh_command}", then "${policy.validate_command}". Treat these claims as higher priority than model-memory defaults. Examples include Supabase publishable/secret keys replacing legacy anon/service_role guidance for hosted projects, Next.js 16 proxy.ts/proxy.js replacing the deprecated middleware file convention, avoiding stale webpack defaults when newer framework guidance says otherwise, and Vercel Function duration limits such as the 300s default under Fluid Compute.`;
+    return `Stack current-docs policy: whenever project tech stack is added or a framework/package/runtime/platform version changes, fetch current docs with Context7 (resolve-library-id then query-docs) or official vendor web docs before coding, record the syntax/limits/security guidance as high-priority TriWiki claims in ${policy.memory_path}, run "${policy.refresh_command}", then "${policy.validate_command}". Treat these claims as higher priority than model-memory defaults. Examples include Supabase publishable/secret keys replacing legacy anon and service role guidance for hosted projects, Next.js 16 proxy.ts/proxy.js replacing the deprecated middleware file convention, avoiding stale webpack defaults when newer framework guidance says otherwise, and Vercel Function duration limits such as the 300s default under Fluid Compute.`;
 }
 export function triwikiContextTrackingText(commandPrefix = 'sks') {
     const ctx = triwikiContextTracking(commandPrefix);
@@ -549,21 +549,34 @@ export const ROUTES = [
         cliEntrypoint: 'sks db scan',
         examples: ['$DB check this migration safely']
     },
+    {
+        id: 'MadDB',
+        command: '$MAD-DB',
+        mode: 'MADDB',
+        route: 'first-class MadDB SQL-plane execution',
+        description: 'Explicit one-cycle MadDB route. When invoked by $MAD-DB or sks mad-db run|exec|apply-migration, SQL-plane mutations such as CREATE, ALTER, table/schema DROP, column add/drop/rename, INSERT, UPDATE, DELETE including all-row mutations, TRUNCATE, execute_sql, and apply_migration are authorized for the bound Supabase project and must be executed with tool-result plus read-back proof. Supabase project/account/billing/credential control-plane actions remain denied.',
+        requiredSkills: ['mad-db', 'db-safety-guard', 'pipeline-runner', 'context7-docs', REFLECTION_SKILL_NAME, 'honest-mode'],
+        appSkillAliases: ['mad-db'],
+        lifecycle: ['explicit_invocation', 'single_mission_capability_v2', 'ephemeral_write_profile', 'tool_inventory', 'execute_sql_or_apply_migration', 'read_back_verification', 'close_and_read_only_restore', 'post_route_reflection', 'honest_mode'],
+        context7Policy: 'required',
+        reasoningPolicy: 'xhigh',
+        stopGate: 'mad-db-gate.json',
+        cliEntrypoint: 'sks mad-db run|exec|apply-migration|status|close|revoke|doctor',
+        examples: ['$MAD-DB public.users legacy_code 컬럼 삭제', '$MAD-DB truncate public.staging_events']
+    },
     {
         id: 'MadSKS',
         command: '$MAD-SKS',
         mode: 'MADSKS',
         route: 'explicit scoped permission-widening modifier',
-        description: 'Explicit high-risk authorization modifier that can be combined with other $ commands to temporarily open approved target-project scopes such as files, shell, package installs, services, network, Computer Use/browser workflows, generated assets, file permissions, migrations, Supabase MCP DB writes, direct execute SQL, schema cleanup, and normal targeted DB writes for the active invocation, while preserving catastrophic wipe/all-row/project-management, credential-exfiltration, persistent security-weakening, and unrequested fallback safeguards.',
+        description: 'Explicit high-risk authorization modifier that can be combined with other $ commands to temporarily open approved target-project scopes such as files, shell, package installs, services, network, Computer Use/browser workflows, generated assets, file permissions, migrations, Supabase MCP DB writes, direct execute SQL, schema cleanup, and normal targeted DB writes for the active invocation, while preserving catastrophic wipe/all-row/project-management, credential-exfiltration, persistent security-weakening, and unrequested fallback safeguards. It is not the first-class MadDB destructive SQL-plane route.',
         requiredSkills: ['mad-sks', 'db-safety-guard', 'pipeline-runner', 'context7-docs', REFLECTION_SKILL_NAME, 'honest-mode'],
-        dollarAliases: ['$MAD-DB'],
-        appSkillAliases: ['mad-db'],
         lifecycle: ['explicit_invocation', 'auto_sealed_permission_scope', 'scoped_permission_override', 'catastrophic_guard', 'permission_deactivation', 'post_route_reflection', 'honest_mode'],
         context7Policy: 'required',
         reasoningPolicy: 'xhigh',
         stopGate: 'mad-sks-gate.json',
         cliEntrypoint: 'Codex App prompt route only: $MAD-SKS <task>',
-        examples: ['$MAD-SKS $Team target project maintenance with package/service/file and DB scopes', '$DB Supabase 점검 $MAD-SKS', '$MAD-DB enable one-cycle DB break-glass only after explicit ack']
+        examples: ['$MAD-SKS $Team target project maintenance with package/service/file and DB scopes', '$DB Supabase 점검 $MAD-SKS']
     },
     {
         id: 'GX',
@@ -964,6 +977,8 @@ export function routeRequiresSubagents(route, prompt = '') {
         return false;
     if (route.id === 'ImageUXReview')
         return false;
+    if (route.id === 'MadDB')
+        return false;
     if (route.id === 'Research' || route.id === 'AutoResearch')
         return true;
     if (route.id === 'Goal')
@@ -996,7 +1011,7 @@ export function simpleGitOnlyRouteId(prompt = '') {
 }
 export function reflectionRequiredForRoute(route) {
     const id = String(route?.id || route?.mode || route?.route || route || '').replace(/^\$/, '');
-    return /^(team|naruto|shadowclone|shadow-clone|kagebunshin|kage-bunshin|qaloop|qa-loop|ppt|imageuxreview|image-ux-review|research|autoresearch|db|database|madsks|mad-sks|gx)$/i.test(id);
+    return /^(team|naruto|shadowclone|shadow-clone|kagebunshin|kage-bunshin|qaloop|qa-loop|ppt|imageuxreview|image-ux-review|research|autoresearch|db|database|madsks|mad-sks|maddb|mad-db|gx)$/i.test(id);
 }
 export function looksLikeCodeChangingWork(prompt = '') {
     const text = String(prompt || '');
@@ -1038,7 +1053,7 @@ export function routeReasoning(route, prompt = '') {
     const base = ALLOWED_REASONING_EFFORTS.has(route?.reasoningPolicy) ? route.reasoningPolicy : 'medium';
     if (hasFromChatImgSignal(text))
         return reasoning('xhigh', 'from_chat_img_image_work_order_analysis');
-    if (/(?:^|\s)sks\s+--mad\b|(?:^|\s)--mad\b|\$MAD-SKS\b|\bmad-sks\b|\bmadsks\b/i.test(text))
+    if (/(?:^|\s)sks\s+--mad\b|(?:^|\s)--mad\b|\$MAD-SKS\b|\$MAD-DB\b|\bmad-sks\b|\bmadsks\b|\bmad-db\b|\bmaddb\b/i.test(text))
         return reasoning('xhigh', 'mad_sks_or_mad_launch_default');
     if (route?.id === 'Team' || route?.id === 'Naruto')
         return teamRouteReasoning(text);