@ryuenn3123/agentic-senior-core 2.5.22 → 3.0.2

package/scripts/frontend-usability-audit.mjs

@@ -21,8 +21,8 @@ const REQUIRED_FILES = [
   'docs/v1.7-issue-breakdown.md',
   'docs/v1.7-execution-playbook.md',
   '.agent-context/rules/frontend-architecture.md',
-  '.agent-context/review-checklists/frontend-usability.md',
-  '.agent-context/review-checklists/frontend-excellence-rubric.md',
+  '.agent-context/review-checklists/pr-checklist.md',
+  '.agent-context/review-checklists/architecture-review.md',
 ];
 
 const REQUIRED_ROADMAP_SNIPPETS = [
@@ -32,24 +32,17 @@ const REQUIRED_ROADMAP_SNIPPETS = [
   'Delivered Scope',
 ];
 
-const REQUIRED_CHECKLIST_SNIPPETS = [
-  'Responsiveness',
-  'Accessibility',
-  'Performance',
-  'Documentation and Release Evidence',
+const REQUIRED_PR_CHECKLIST_SNIPPETS = [
+  '### 2. Architecture (→ rules/architecture.md)',
+  '### 10. Documentation',
+  '### 15. Universal SOP Consolidation',
 ];
 
-const REQUIRED_EXCELLENCE_RUBRIC_SNIPPETS = [
-  'Visual Direction and Identity',
-  'Typography Quality',
-  'Color System Diversity and Contrast',
-  'Interaction Choreography',
-  'Language and Content Consistency',
-  'Text Contrast and Collision Safety',
-  'UX Narrative and Conversion Clarity',
-  'Template Diversity and Originality',
-  'Low-Diversity Template Output Policy',
-  'Awwwards-level reference quality',
+const REQUIRED_ARCHITECTURE_CHECKLIST_SNIPPETS = [
+  '## Backend Universal Principles',
+  'No clever hacks in backend and shared core modules',
+  'No premature abstraction',
+  'Readability over brevity',
 ];
 
 const REQUIRED_FRONTEND_RULE_SNIPPETS = [
@@ -86,17 +79,17 @@ function runAudit() {
 
   const roadmapPath = 'docs/roadmap.md';
   const frontendRulePath = '.agent-context/rules/frontend-architecture.md';
-  const checklistPath = '.agent-context/review-checklists/frontend-usability.md';
-  const excellenceRubricPath = '.agent-context/review-checklists/frontend-excellence-rubric.md';
+  const prChecklistPath = '.agent-context/review-checklists/pr-checklist.md';
+  const architectureChecklistPath = '.agent-context/review-checklists/architecture-review.md';
 
   if (existsSync(resolve(REPOSITORY_ROOT, roadmapPath))) {
     const roadmapContent = readFileSync(resolve(REPOSITORY_ROOT, roadmapPath), 'utf8');
     assertContains('Roadmap', roadmapPath, roadmapContent, REQUIRED_ROADMAP_SNIPPETS, failures);
   }
 
-  if (existsSync(resolve(REPOSITORY_ROOT, checklistPath))) {
-    const checklistContent = readFileSync(resolve(REPOSITORY_ROOT, checklistPath), 'utf8');
-    assertContains('Checklist', checklistPath, checklistContent, REQUIRED_CHECKLIST_SNIPPETS, failures);
+  if (existsSync(resolve(REPOSITORY_ROOT, prChecklistPath))) {
+    const checklistContent = readFileSync(resolve(REPOSITORY_ROOT, prChecklistPath), 'utf8');
+    assertContains('PR checklist', prChecklistPath, checklistContent, REQUIRED_PR_CHECKLIST_SNIPPETS, failures);
   }
 
   if (existsSync(resolve(REPOSITORY_ROOT, frontendRulePath))) {
@@ -104,13 +97,13 @@ function runAudit() {
     assertContains('Frontend rule', frontendRulePath, frontendRuleContent, REQUIRED_FRONTEND_RULE_SNIPPETS, failures);
   }
 
-  if (existsSync(resolve(REPOSITORY_ROOT, excellenceRubricPath))) {
-    const excellenceRubricContent = readFileSync(resolve(REPOSITORY_ROOT, excellenceRubricPath), 'utf8');
+  if (existsSync(resolve(REPOSITORY_ROOT, architectureChecklistPath))) {
+    const excellenceRubricContent = readFileSync(resolve(REPOSITORY_ROOT, architectureChecklistPath), 'utf8');
     assertContains(
-      'Frontend excellence rubric',
-      excellenceRubricPath,
+      'Architecture checklist',
+      architectureChecklistPath,
       excellenceRubricContent,
-      REQUIRED_EXCELLENCE_RUBRIC_SNIPPETS,
+      REQUIRED_ARCHITECTURE_CHECKLIST_SNIPPETS,
       failures
     );
   }

package/scripts/governance-weekly-report.mjs

@@ -12,7 +12,6 @@ import fs from 'node:fs/promises';
 import { spawnSync } from 'node:child_process';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { calculateTrustScore } from './trust-scorer.mjs';
 
 const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
 const SCRIPT_DIR = dirname(SCRIPT_FILE_PATH);
@@ -23,7 +22,20 @@ const ARGUMENT_FLAGS = new Set(process.argv.slice(2));
 const isStdoutOnlyMode = ARGUMENT_FLAGS.has('--stdout-only');
 const WEEKLY_WINDOW_DAYS = 7;
 const HISTORY_LIMIT = 26;
-const REQUIRED_VERIFIED_DOMAINS = new Set(['cli', 'frontend', 'fullstack', 'distribution', 'review-quality']);
+const REQUIRED_VERIFIED_DOMAINS = new Set([
+  'canonical-instructions',
+  'pr-checklist',
+  'architecture-review',
+  'mcp-server',
+  'state-continuity',
+]);
+const GOVERNANCE_SURFACE_PATHS = {
+  'canonical-instructions': '.instructions.md',
+  'pr-checklist': '.agent-context/review-checklists/pr-checklist.md',
+  'architecture-review': '.agent-context/review-checklists/architecture-review.md',
+  'mcp-server': 'scripts/mcp-server.mjs',
+  'state-continuity': '.agent-context/state',
+};
 
 function readJsonOrNull(filePath) {
   if (!existsSync(filePath)) {
@@ -139,13 +151,6 @@ function collectCommitSignals(windowDays) {
 }
 
 async function collectSkillTrustSignals() {
-  const skillDirectoryPath = join(REPOSITORY_ROOT, '.agent-context', 'skills');
-  const skillDirectoryEntries = await fs.readdir(skillDirectoryPath, { withFileTypes: true });
-  const skillDomainNames = skillDirectoryEntries
-    .filter((directoryEntry) => directoryEntry.isDirectory())
-    .map((directoryEntry) => directoryEntry.name)
-    .sort((leftDomainName, rightDomainName) => leftDomainName.localeCompare(rightDomainName));
-
   const trustRows = [];
   const tierCounts = {
     verified: 0,
@@ -153,17 +158,26 @@ async function collectSkillTrustSignals() {
     experimental: 0,
   };
 
-  for (const skillDomainName of skillDomainNames) {
-    const trustResult = await calculateTrustScore(join(skillDirectoryPath, skillDomainName));
+  const sortedDomainNames = Array.from(REQUIRED_VERIFIED_DOMAINS).sort((leftName, rightName) => {
+    return leftName.localeCompare(rightName);
+  });
+
+  for (const skillDomainName of sortedDomainNames) {
+    const relativeSurfacePath = GOVERNANCE_SURFACE_PATHS[skillDomainName];
+    const absoluteSurfacePath = join(REPOSITORY_ROOT, relativeSurfacePath);
+    const surfaceExists = existsSync(absoluteSurfacePath);
+    const trustTier = surfaceExists ? 'verified' : 'experimental';
+    const trustScore = surfaceExists ? 100 : 0;
 
-    if (typeof tierCounts[trustResult.tier] === 'number') {
-      tierCounts[trustResult.tier] += 1;
+    if (typeof tierCounts[trustTier] === 'number') {
+      tierCounts[trustTier] += 1;
     }
 
     trustRows.push({
       domain: skillDomainName,
-      tier: trustResult.tier,
-      score: trustResult.score,
+      tier: trustTier,
+      score: trustScore,
+      sourcePath: relativeSurfacePath,
     });
   }
 

package/scripts/llm-judge.mjs

@@ -53,9 +53,6 @@ const IS_DRY_RUN = process.argv.includes('--dry-run');
 const SHOULD_EMIT_MACHINE_REPORT = process.env.LLM_JUDGE_EMIT_JSON !== 'false';
 const MACHINE_REPORT_PATH = process.env.LLM_JUDGE_OUTPUT_PATH || DEFAULT_MACHINE_REPORT_PATH;
 
-/** @type {string[]} Source code file extensions to include in the diff */
-const SOURCE_CODE_EXTENSIONS = ['*.ts', '*.tsx', '*.js', '*.mjs', '*.cjs', '*.py', '*.go', '*.java', '*.cs', '*.rb', '*.php'];
-
 /** @type {Record<string, string>} */
 const SEVERITY_NORMALIZATION_TABLE = {
   critical: 'critical',
@@ -184,12 +181,12 @@ function collectPullRequestDiff() {
   console.log('  Source: local HEAD~1..HEAD fallback');
   try {
     return execSync('git diff HEAD~1 HEAD', execOptions);
-  } catch (err) {
+  } catch {
     try {
       // Initial commit has no parent — diff against empty tree
       const emptyTreeSha = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
       return execSync(`git diff "${emptyTreeSha}" HEAD`, execOptions);
-    } catch (e2) {
+    } catch {
       console.warn('  ⚠️   Unable to execute git diff. Defaulting to empty diff.');
       return '';
     }

package/scripts/mcp-server.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
 import { readFileSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
-import { dirname, resolve } from 'node:path';
+import { dirname, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
@@ -10,14 +11,19 @@ const REPOSITORY_ROOT = resolve(dirname(SCRIPT_FILE_PATH), '..');
 const PACKAGE_VERSION = JSON.parse(
   readFileSync(resolve(REPOSITORY_ROOT, 'package.json'), 'utf8')
 ).version;
+const STATE_DIRECTORY = resolve(REPOSITORY_ROOT, '.agent-context', 'state');
 const DEFAULT_PROTOCOL_VERSION = '2024-11-05';
+const DEFAULT_FETCH_TIMEOUT_MS = 15000;
+const DEFAULT_FETCH_MAX_CHARS = 6000;
+const MAX_FETCH_MAX_CHARS = 20000;
+const DEFAULT_TREND_WINDOW_DAYS = 90;
+const MAX_TREND_PACKAGES = 10;
 
 const TEST_SUITE_ARGS = {
-  full: ['--test', './tests/cli-smoke.test.mjs', './tests/llm-judge.test.mjs', './tests/enterprise-ops.test.mjs', './tests/skill-tier-gate.test.mjs'],
+  full: ['--test', './tests/cli-smoke.test.mjs', './tests/mcp-server.test.mjs', './tests/llm-judge.test.mjs', './tests/enterprise-ops.test.mjs'],
   cli: ['--test', './tests/cli-smoke.test.mjs'],
   enterprise: ['--test', './tests/enterprise-ops.test.mjs'],
   'llm-judge': ['--test', './tests/llm-judge.test.mjs'],
-  'skill-tier': ['--test', './tests/skill-tier-gate.test.mjs'],
 };
 
 const TOOL_DEFINITIONS = [
@@ -38,7 +44,7 @@ const TOOL_DEFINITIONS = [
       properties: {
         suite: {
           type: 'string',
-          enum: ['full', 'cli', 'enterprise', 'llm-judge', 'skill-tier'],
+          enum: ['full', 'cli', 'enterprise', 'llm-judge'],
           description: 'Target test suite. Defaults to full.',
         },
       },
@@ -63,6 +69,88 @@ const TOOL_DEFINITIONS = [
       additionalProperties: false,
     },
   },
+  {
+    name: 'research_fetch',
+    description: 'Fetch external documentation/news content and return query-focused excerpts with citation metadata.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: {
+          type: 'string',
+          description: 'Absolute HTTP/HTTPS URL to fetch.',
+        },
+        query: {
+          type: 'string',
+          description: 'Optional search query used to extract focused excerpts.',
+        },
+        maxChars: {
+          type: 'integer',
+          description: 'Maximum characters to return when query is not provided (default 6000, max 20000).',
+        },
+      },
+      required: ['url'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'trend_snapshot',
+    description: 'Generate ecosystem trend snapshot from npm registry metadata with source timestamps.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        packages: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Package names to inspect (max 10).',
+        },
+        windowDays: {
+          type: 'integer',
+          description: 'Release activity window in days (default 90).',
+        },
+      },
+      required: ['packages'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'state_read',
+    description: 'Read a file from .agent-context/state for cross-session continuity.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: 'Path relative to .agent-context/state (for example memory-continuity-benchmark.json).',
+        },
+      },
+      required: ['path'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'state_write',
+    description: 'Write a file under .agent-context/state for cross-session continuity updates.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: 'Path relative to .agent-context/state.',
+        },
+        content: {
+          type: 'string',
+          description: 'UTF-8 content to write.',
+        },
+        mode: {
+          type: 'string',
+          enum: ['overwrite', 'append'],
+          description: 'Write mode. Defaults to overwrite.',
+        },
+      },
+      required: ['path', 'content'],
+      additionalProperties: false,
+    },
+  },
 ];
 
 let incomingBuffer = Buffer.alloc(0);
@@ -117,6 +205,287 @@ function buildCommandOutput(commandLabel, commandArguments, exitCode, stdoutCont
   ].join('\n\n');
 }
 
+function buildJsonResult(payload, isError = false) {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(payload, null, 2),
+      },
+    ],
+    isError,
+  };
+}
+
+function normalizePlainText(rawText) {
+  return rawText
+    .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+    .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/&amp;/gi, '&')
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function extractQuerySnippets(textContent, queryText) {
+  const normalizedQuery = String(queryText || '').trim().toLowerCase();
+  if (!normalizedQuery) {
+    return [];
+  }
+
+  const normalizedContent = String(textContent || '');
+  const normalizedLowerContent = normalizedContent.toLowerCase();
+  const snippets = [];
+  let searchStartIndex = 0;
+
+  while (snippets.length < 5) {
+    const matchedIndex = normalizedLowerContent.indexOf(normalizedQuery, searchStartIndex);
+    if (matchedIndex === -1) {
+      break;
+    }
+
+    const contextRadius = 180;
+    const snippetStart = Math.max(0, matchedIndex - contextRadius);
+    const snippetEnd = Math.min(normalizedContent.length, matchedIndex + normalizedQuery.length + contextRadius);
+    const prefix = snippetStart > 0 ? '...' : '';
+    const suffix = snippetEnd < normalizedContent.length ? '...' : '';
+    snippets.push(`${prefix}${normalizedContent.slice(snippetStart, snippetEnd).trim()}${suffix}`);
+    searchStartIndex = matchedIndex + normalizedQuery.length;
+  }
+
+  return snippets;
+}
+
+async function fetchWithTimeout(targetUrl, timeoutMs) {
+  const fetchController = new AbortController();
+  const timeoutHandle = setTimeout(() => fetchController.abort(), timeoutMs);
+
+  try {
+    return await fetch(targetUrl, {
+      signal: fetchController.signal,
+      headers: {
+        'User-Agent': `agentic-senior-core/${PACKAGE_VERSION}`,
+      },
+    });
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+async function runResearchFetchTool(toolArguments = {}) {
+  const targetUrl = String(toolArguments.url || '').trim();
+  const queryText = typeof toolArguments.query === 'string' ? toolArguments.query.trim() : '';
+  const maxCharsInput = Number(toolArguments.maxChars);
+  const maxChars = Number.isFinite(maxCharsInput)
+    ? Math.max(200, Math.min(MAX_FETCH_MAX_CHARS, Math.floor(maxCharsInput)))
+    : DEFAULT_FETCH_MAX_CHARS;
+
+  if (!/^https?:\/\//i.test(targetUrl)) {
+    return buildJsonResult({
+      error: 'Invalid url. Provide absolute HTTP/HTTPS URL.',
+      input: targetUrl,
+    }, true);
+  }
+
+  try {
+    const startedAt = new Date().toISOString();
+    const fetchResponse = await fetchWithTimeout(targetUrl, DEFAULT_FETCH_TIMEOUT_MS);
+    const rawBody = await fetchResponse.text();
+    const plainTextBody = normalizePlainText(rawBody);
+    const querySnippets = queryText ? extractQuerySnippets(plainTextBody, queryText) : [];
+    const selectedContent = querySnippets.length > 0
+      ? querySnippets.join('\n\n')
+      : plainTextBody.slice(0, maxChars);
+
+    return buildJsonResult({
+      source: {
+        url: targetUrl,
+        status: fetchResponse.status,
+        ok: fetchResponse.ok,
+        fetchedAt: new Date().toISOString(),
+        requestedAt: startedAt,
+        contentType: fetchResponse.headers.get('content-type') || null,
+      },
+      query: queryText || null,
+      excerptCount: querySnippets.length,
+      truncated: !queryText && plainTextBody.length > selectedContent.length,
+      content: selectedContent,
+    }, !fetchResponse.ok);
+  } catch (error) {
+    return buildJsonResult({
+      error: error instanceof Error ? error.message : String(error),
+      source: targetUrl,
+    }, true);
+  }
+}
+
+async function runTrendSnapshotTool(toolArguments = {}) {
+  const packageInputs = Array.isArray(toolArguments.packages)
+    ? toolArguments.packages.filter((packageName) => typeof packageName === 'string' && packageName.trim().length > 0)
+    : [];
+  const packageNames = Array.from(new Set(packageInputs.map((packageName) => packageName.trim()))).slice(0, MAX_TREND_PACKAGES);
+  const windowDaysInput = Number(toolArguments.windowDays);
+  const windowDays = Number.isFinite(windowDaysInput)
+    ? Math.max(1, Math.min(3650, Math.floor(windowDaysInput)))
+    : DEFAULT_TREND_WINDOW_DAYS;
+
+  if (packageNames.length === 0) {
+    return buildJsonResult({
+      error: 'packages[] must include at least one package name.',
+    }, true);
+  }
+
+  const nowTimestamp = Date.now();
+  const windowStartTimestamp = nowTimestamp - (windowDays * 24 * 60 * 60 * 1000);
+  const packageReports = [];
+
+  for (const packageName of packageNames) {
+    const registryUrl = `https://registry.npmjs.org/${encodeURIComponent(packageName)}`;
+
+    try {
+      const response = await fetchWithTimeout(registryUrl, DEFAULT_FETCH_TIMEOUT_MS);
+      if (!response.ok) {
+        packageReports.push({
+          package: packageName,
+          source: registryUrl,
+          status: response.status,
+          error: `Registry request failed with HTTP ${response.status}`,
+        });
+        continue;
+      }
+
+      const registryPayload = await response.json();
+      const latestVersion = registryPayload?.['dist-tags']?.latest || null;
+      const releaseTimes = Object.entries(registryPayload?.time || {})
+        .filter(([versionName, publishedAt]) => {
+          if (versionName === 'created' || versionName === 'modified') {
+            return false;
+          }
+
+          return typeof publishedAt === 'string' && Number.isFinite(Date.parse(publishedAt));
+        })
+        .map(([versionName, publishedAt]) => ({
+          version: versionName,
+          publishedAt,
+          publishedAtMs: Date.parse(publishedAt),
+        }))
+        .sort((leftEntry, rightEntry) => rightEntry.publishedAtMs - leftEntry.publishedAtMs);
+
+      const releasesInWindow = releaseTimes.filter((releaseEntry) => releaseEntry.publishedAtMs >= windowStartTimestamp);
+      const latestPublishedAt = latestVersion && typeof registryPayload?.time?.[latestVersion] === 'string'
+        ? registryPayload.time[latestVersion]
+        : registryPayload?.time?.modified || null;
+
+      packageReports.push({
+        package: packageName,
+        source: registryUrl,
+        latestVersion,
+        latestPublishedAt,
+        releasesInWindow: releasesInWindow.length,
+        recentReleases: releasesInWindow.slice(0, 5).map((releaseEntry) => ({
+          version: releaseEntry.version,
+          publishedAt: releaseEntry.publishedAt,
+        })),
+      });
+    } catch (error) {
+      packageReports.push({
+        package: packageName,
+        source: registryUrl,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  const errorCount = packageReports.filter((packageReport) => typeof packageReport.error === 'string').length;
+
+  return buildJsonResult({
+    generatedAt: new Date().toISOString(),
+    windowDays,
+    packageCount: packageNames.length,
+    errorCount,
+    packages: packageReports,
+    citation: {
+      source: 'npm registry public API',
+      fetchedAt: new Date().toISOString(),
+    },
+  }, errorCount > 0);
+}
+
+function resolveStatePath(relativeStatePath) {
+  const normalizedRelativePath = String(relativeStatePath || '').replace(/\\/g, '/').replace(/^\/+/, '').trim();
+  if (!normalizedRelativePath) {
+    throw new Error('path is required and must be relative to .agent-context/state');
+  }
+
+  const resolvedStatePath = resolve(STATE_DIRECTORY, normalizedRelativePath);
+  const stateRootPrefix = `${STATE_DIRECTORY}${sep}`;
+  if (resolvedStatePath !== STATE_DIRECTORY && !resolvedStatePath.startsWith(stateRootPrefix)) {
+    throw new Error('path traversal is not allowed outside .agent-context/state');
+  }
+
+  return {
+    normalizedRelativePath,
+    resolvedStatePath,
+  };
+}
+
+async function runStateReadTool(toolArguments = {}) {
+  try {
+    const { normalizedRelativePath, resolvedStatePath } = resolveStatePath(toolArguments.path);
+    const fileContent = await readFile(resolvedStatePath, 'utf8');
+
+    return buildJsonResult({
+      path: normalizedRelativePath,
+      readAt: new Date().toISOString(),
+      bytes: Buffer.byteLength(fileContent, 'utf8'),
+      content: fileContent,
+    });
+  } catch (error) {
+    return buildJsonResult({
+      error: error instanceof Error ? error.message : String(error),
+      path: toolArguments.path || null,
+    }, true);
+  }
+}
+
+async function runStateWriteTool(toolArguments = {}) {
+  const writeMode = toolArguments.mode === 'append' ? 'append' : 'overwrite';
+  const contentToWrite = typeof toolArguments.content === 'string' ? toolArguments.content : '';
+
+  if (typeof toolArguments.content !== 'string') {
+    return buildJsonResult({
+      error: 'content must be a string.',
+    }, true);
+  }
+
+  try {
+    const { normalizedRelativePath, resolvedStatePath } = resolveStatePath(toolArguments.path);
+    await mkdir(dirname(resolvedStatePath), { recursive: true });
+
+    if (writeMode === 'append') {
+      await writeFile(resolvedStatePath, contentToWrite, { encoding: 'utf8', flag: 'a' });
+    } else {
+      await writeFile(resolvedStatePath, contentToWrite, 'utf8');
+    }
+
+    return buildJsonResult({
+      path: normalizedRelativePath,
+      wroteAt: new Date().toISOString(),
+      mode: writeMode,
+      bytesWritten: Buffer.byteLength(contentToWrite, 'utf8'),
+    });
+  } catch (error) {
+    return buildJsonResult({
+      error: error instanceof Error ? error.message : String(error),
+      path: toolArguments.path || null,
+      mode: writeMode,
+    }, true);
+  }
+}
+
 function runNodeCommand(commandLabel, commandArguments) {
   return new Promise((resolveResult) => {
     const childProcess = spawn(process.execPath, commandArguments, {
@@ -190,6 +559,22 @@ async function executeToolCall(toolName, toolArguments = {}) {
     return runNodeCommand('forbidden_content_check', ['./scripts/forbidden-content-check.mjs']);
   }
 
+  if (toolName === 'research_fetch') {
+    return runResearchFetchTool(toolArguments);
+  }
+
+  if (toolName === 'trend_snapshot') {
+    return runTrendSnapshotTool(toolArguments);
+  }
+
+  if (toolName === 'state_read') {
+    return runStateReadTool(toolArguments);
+  }
+
+  if (toolName === 'state_write') {
+    return runStateWriteTool(toolArguments);
+  }
+
   return {
     content: [
       {
@@ -274,7 +659,6 @@ function processIncomingBuffer() {
   
   // Try to parse as line-delimited JSON first (modern MCP standard)
   let parseMode = 'line-delimited';
-  let contentToProcess = fullContent;
   
   // Check if Content-Length header is present (LSP-style for backward compatibility)
   if (fullContent.includes('Content-Length:')) {