@jrpool/kilotest 46.1.2 → 47.0.1

package/{indexBalances.test.js → indexBalances.test.ts}

@@ -1,13 +1,13 @@
 /*
-  indexBalances.test.js
+  indexBalances.test.ts
   Tests for checkBalancesForAlerts in index.js, which requires balance-related
   env vars to be set before index.js is loaded.
 */
 
 // ENVIRONMENT (must be set before requiring index.js)
 
-const path = require('node:path');
-const fixtureDBDir = path.join(__dirname, 'test', 'fixtures', 'db');
+import path from 'node:path';
+import {fixtureDBDir} from './test/dbFixture.ts';
 
 process.env.DB_DIR = fixtureDBDir;
 process.env.AUTH_CODE = 'test-auth-code';
@@ -19,16 +19,16 @@ process.env.AI_SERVICE0_BALANCE_THRESHOLD = '50';
 process.env.AI_MODEL0_INPUT_PRICE = '0.001';
 process.env.AI_MODEL0_OUTPUT_PRICE = '0.002';
 
-const {test, before, after} = require('node:test');
-const assert = require('node:assert/strict');
-const http = require('node:http');
-const fs = require('node:fs/promises');
-const {requestHandler} = require('./index');
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import fs from 'node:fs/promises';
+import {requestHandler} from './index.ts';
 
 // CONSTANTS
 
 const port = 3994;
-const balancePath = path.join(__dirname, 'ai0Balance.json');
+const balancePath = path.join(import.meta.dirname, 'ai0Balance.json');
 const jobID = '990101T0001-bal';
 const reportPath = path.join(fixtureDBDir, 'reports', `${jobID}.json`);
 const claimedDir = path.join(fixtureDBDir, 'jobs', 'claimed');
@@ -36,18 +36,22 @@ const jobPath = path.join(claimedDir, `${jobID}.json`);
 
 // SETUP AND TEARDOWN
 
-let server;
-let originalBalance;
+let server: http.Server;
+let originalBalance: any;
 
 before(async () => {
   originalBalance = await fs.readFile(balancePath, 'utf8').catch(() => null);
+  // Create the job directories, which are not tracked by git and may not exist on a fresh checkout.
+  for (const sub of ['claimed', 'queue', 'failed']) {
+    await fs.mkdir(path.join(fixtureDBDir, 'jobs', sub), {recursive: true});
+  }
   server = http.createServer(requestHandler);
-  await new Promise(resolve => server.listen(port, () => resolve()));
+  await new Promise<void>(resolve => server.listen(port, () => resolve()));
 });
 
 after(async () => {
   server.closeAllConnections?.();
-  await new Promise(resolve => {
+  await new Promise<void>(resolve => {
     const timer = setTimeout(() => {
       server.closeAllConnections?.();
       resolve();
@@ -70,7 +74,7 @@ after(async () => {
 
 // HELPERS
 
-const request = (method, requestPath, body = null, headers = {}) => new Promise((resolve, reject) => {
+const request = (method: string, requestPath: string, body: any = null, headers: any = {}): Promise<any> => new Promise((resolve, reject) => {
   const options = {method, host: 'localhost', port, path: requestPath, headers: {...headers}};
   let bodyData = '';
   if (body) {
@@ -79,7 +83,7 @@ const request = (method, requestPath, body = null, headers = {}) => new Promise(
     options.headers['content-length'] = Buffer.byteLength(bodyData);
   }
   const req = http.request(options, response => {
-    const chunks = [];
+    const chunks: Buffer[] = [];
     response.on('data', chunk => chunks.push(chunk));
     response.on('end', () => {
       resolve({statusCode: response.statusCode, headers: response.headers, body: Buffer.concat(chunks).toString()});
@@ -89,7 +93,7 @@ const request = (method, requestPath, body = null, headers = {}) => new Promise(
   req.end(bodyData || '');
 });
 
-const jsonBody = res => {
+const jsonBody = (res: any) => {
   try {
     return JSON.parse(res.body);
   }
@@ -98,7 +102,7 @@ const jsonBody = res => {
   }
 };
 
-const submitReport = async (acts, balanceFileContent) => {
+const submitReport = async (acts: any, balanceFileContent: any) => {
   if (balanceFileContent !== undefined) {
     if (balanceFileContent === null) {
       await fs.unlink(balancePath).catch(() => {});

package/{indexServe.test.js → indexServe.test.ts}

@@ -1,27 +1,27 @@
 /*
-  indexServe.test.js
+  indexServe.test.ts
   Tests for the serve function in index.js, which starts the HTTP or HTTPS
   server. The serve function is exported for testing.
 */
 
 // ENVIRONMENT (must be set before requiring index.js)
 
-const path = require('node:path');
-const fixtureDBDir = path.join(__dirname, 'test', 'fixtures', 'db');
+import path from 'node:path';
+import {fixtureDBDir} from './test/dbFixture.ts';
 
 process.env.DB_DIR = fixtureDBDir;
 process.env.AUTH_CODE = 'test-auth-code';
 process.env.TESTARO_WORKERS = '{}';
 
-const {test} = require('node:test');
-const assert = require('node:assert/strict');
-const http = require('node:http');
-const fs = require('node:fs/promises');
-const {serve} = require('./index');
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import fs from 'node:fs/promises';
+import {serve} from './index.ts';
 
 // HELPER
 
-const closeServer = server => new Promise(resolve => {
+const closeServer = (server: any) => new Promise<void>(resolve => {
   if (!server) {
     resolve();
     return;

package/linkValidation.test.ts

@@ -0,0 +1,190 @@
+// Link validation test: ensures all internal href attributes point to valid paths
+
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const projectRoot = import.meta.dirname;
+
+// Collect all valid paths (both static and route patterns)
+const validPathPatterns = new Set<string>();
+const validPathsExact = new Set<string>();
+
+// Add exact paths and static files
+const staticFiles = [
+  '/index.html',
+  '/style.css',
+  '/favicon.ico',
+  '/openapi.yaml',
+  '/openapi.json',
+  '/capability.md',
+  '/robots.txt',
+  '/sitemap.xml',
+  '/llms.txt',
+  '/llms-full.txt',
+  '/mcp'
+];
+
+staticFiles.forEach(p => validPathsExact.add(p));
+
+// Add pattern-based routes
+validPathPatterns.add('*.html*');
+validPathPatterns.add('/api/*');
+validPathPatterns.add('/fullReport.json/*');
+validPathPatterns.add('/tutorialWeb/images/*');
+validPathPatterns.add('/tutorialAI/images/*');
+
+// Specific page routes (those that end in .html)
+const htmlRoutes = [
+  '/tutorialWeb.html',
+  '/tutorialAI.html',
+  '/tutorialWebComment.html',
+  '/tutorialAIComment.html',
+  '/listReports.html',
+  '/listTopIssues.html',
+  '/listIssues.html',
+  '/listDiagnoses.html',
+  '/listViolators.html',
+  '/listRules.html',
+  '/manage.html',
+  '/requestTest.html',
+  '/requestTestForm.html',
+  '/requestRetest.html',
+  '/requestRetestForm.html',
+  '/reannotate.html',
+  '/reannotateForm.html',
+  '/hideReportForm.html',
+  '/unhideReportForm.html',
+  '/expungeReportsForm.html',
+  '/pruneReportsForm.html',
+  '/rewindReportsForm.html',
+  '/renewWCAG.html',
+  '/renewWCAGForm.html',
+  '/enqueue.html',
+  '/enqueueForm.html',
+  '/manage.html'
+];
+
+htmlRoutes.forEach(p => validPathsExact.add(p));
+
+// Add root path
+validPathsExact.add('/');
+
+const isValidPath = (href: string): boolean => {
+  // Absolute URLs and email links are not internal paths
+  if (href.includes('://') || href.startsWith('mailto:') || href.startsWith('#')) {
+    return true;
+  }
+
+  // Exact match
+  if (validPathsExact.has(href)) {
+    return true;
+  }
+
+  // Pattern match
+  for (const pattern of validPathPatterns) {
+    const regexPattern = '^' + pattern.replace(/\*/g, '.*') + '$';
+    if (new RegExp(regexPattern).test(href)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+// Find all HTML files in the project (excluding generated/build directories)
+const findHtmlFiles = (dir: string): string[] => {
+  const files: string[] = [];
+  const entries = fs.readdirSync(dir, {withFileTypes: true});
+  const ignoredDirs = new Set(['node_modules', 'coverage', '.git', '.github', 'dist', 'build']);
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.name.startsWith('.') || ignoredDirs.has(entry.name)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      files.push(...findHtmlFiles(fullPath));
+    } else if (entry.name.endsWith('.html')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+};
+
+const htmlFiles = findHtmlFiles(projectRoot);
+
+test('All internal links in HTML files point to valid paths', () => {
+  const brokenLinks: Array<{file: string; href: string; type: string}> = [];
+
+  for (const htmlFile of htmlFiles) {
+    const content = fs.readFileSync(htmlFile, 'utf-8');
+    const relativePath = path.relative(projectRoot, htmlFile);
+
+    // Find all href attributes
+    const hrefRegex = /href=["']([^"']+)["']/g;
+    let match: RegExpExecArray | null;
+    while ((match = hrefRegex.exec(content)) !== null) {
+      const href = match[1];
+      if (href && !isValidPath(href)) {
+        brokenLinks.push({
+          file: relativePath,
+          href,
+          type: 'href'
+        });
+      }
+    }
+
+    // Find all src attributes (images, scripts, etc.)
+    const srcRegex = /src=["']([^"']+)["']/g;
+    while ((match = srcRegex.exec(content)) !== null) {
+      const src = match[1];
+      if (src && !src.includes('://') && !isValidPath(src)) {
+        brokenLinks.push({
+          file: relativePath,
+          href: src,
+          type: 'src'
+        });
+      }
+    }
+
+    // Find all fetch paths (JavaScript: fetch('/path', ...))
+    const fetchRegex = /fetch\s*\(\s*["']([^"']+)["']/g;
+    while ((match = fetchRegex.exec(content)) !== null) {
+      const fetchPath = match[1];
+      if (fetchPath && !fetchPath.includes('://') && !isValidPath(fetchPath)) {
+        brokenLinks.push({
+          file: relativePath,
+          href: fetchPath,
+          type: 'fetch'
+        });
+      }
+    }
+  }
+
+  if (brokenLinks.length > 0) {
+    const message = brokenLinks
+      .map(link => `${link.file}: ${link.type}="${link.href}" (invalid path)`)
+      .join('\n');
+    assert.fail(`Found ${brokenLinks.length} broken links:\n${message}`);
+  }
+});
+
+test('Internal links in index.html resolve to expected paths', () => {
+  const expectedLinks = [
+    '/tutorialWeb.html',
+    '/tutorialAI.html',
+    '/listReports.html',
+    '/listTopIssues.html',
+    '/manage.html',
+    '/mcp',
+    '/capability.md',
+    '/openapi.yaml'
+  ];
+
+  for (const expectedHref of expectedLinks) {
+    assert.ok(isValidPath(expectedHref), `Expected path ${expectedHref} should be valid`);
+  }
+});

package/{mcp.test.js → mcp.test.ts}

@@ -1,20 +1,19 @@
 /*
-  mcp.test.js
+  mcp.test.ts
   Tests for mcp.js, covering tool registration and handler behavior.
 */
 
 // IMPORTS
 
-const {test} = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const http = require('node:http');
-const {mcpPath, createMCPServer} = require('./mcp');
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import {mcpPath, createMCPServer, handleMCP} from './mcp.ts';
 
 // CONSTANTS
 
 // Set DB_DIR to the fixture database for all tests.
-process.env.DB_DIR = path.join(__dirname, 'test', 'fixtures', 'db');
+process.env.DB_DIR = (await import('./test/dbFixture.ts')).fixtureDBDir;
 
 // TESTS
 
@@ -24,7 +23,7 @@ test('mcpPath is /mcp', () => {
 
 test('createMCPServer registers all 8 tools', () => {
   const server = createMCPServer();
-  const toolNames = Object.keys(server._registeredTools);
+  const toolNames = Object.keys((server as any)._registeredTools);
   assert.equal(toolNames.length, 8);
   assert.deepEqual(toolNames, [
     'listReports',
@@ -40,8 +39,8 @@ test('createMCPServer registers all 8 tools', () => {
 
 test('each tool has a description and a handler function', () => {
   const server = createMCPServer();
-  const tools = server._registeredTools;
-  for (const [name, tool] of Object.entries(tools)) {
+  const tools = (server as any)._registeredTools;
+  for (const [name, tool] of Object.entries(tools) as [string, any][]) {
     assert.ok(tool.description, `${name} has a description`);
     assert.equal(typeof tool.handler, 'function', `${name} has a handler function`);
   }
@@ -49,7 +48,7 @@ test('each tool has a description and a handler function', () => {
 
 test('listReports handler returns content and structuredContent', async () => {
   const server = createMCPServer();
-  const result = await server._registeredTools.listReports.handler({});
+  const result = await (server as any)._registeredTools.listReports.handler({});
   assert.ok(result.content);
   assert.equal(result.content[0].type, 'text');
   assert.ok(result.structuredContent);
@@ -57,7 +56,7 @@ test('listReports handler returns content and structuredContent', async () => {
 
 test('listIssues handler returns content and structuredContent for a valid report', async () => {
   const server = createMCPServer();
-  const result = await server._registeredTools.listIssues.handler({
+  const result = await (server as any)._registeredTools.listIssues.handler({
     timeStamp: '260101T0000',
     jobID: 'mix'
   });
@@ -68,7 +67,7 @@ test('listIssues handler returns content and structuredContent for a valid repor
 
 test('listViolators handler returns content and structuredContent for a valid issue', async () => {
   const server = createMCPServer();
-  const result = await server._registeredTools.listViolators.handler({
+  const result = await (server as any)._registeredTools.listViolators.handler({
     issueID: 'linkNoText',
     timeStamp: '260101T0000',
     jobID: 'mix'
@@ -80,7 +79,7 @@ test('listViolators handler returns content and structuredContent for a valid is
 
 test('listDiagnoses handler returns content and structuredContent for a valid diagnosis', async () => {
   const server = createMCPServer();
-  const result = await server._registeredTools.listDiagnoses.handler({
+  const result = await (server as any)._registeredTools.listDiagnoses.handler({
     catalogIndex: '0',
     issueID: 'linkNoText',
     timeStamp: '260101T0000',
@@ -93,7 +92,7 @@ test('listDiagnoses handler returns content and structuredContent for a valid di
 
 test('getReport handler returns content and structuredContent for a valid report', async () => {
   const server = createMCPServer();
-  const result = await server._registeredTools.getReport.handler({
+  const result = await (server as any)._registeredTools.getReport.handler({
     timeStamp: '260101T0000',
     jobID: 'mix'
   });
@@ -104,7 +103,7 @@ test('getReport handler returns content and structuredContent for a valid report
 
 test('requestTest handler returns content and structuredContent', async () => {
   const server = createMCPServer();
-  const result = await server._registeredTools.requestTest.handler({
+  const result = await (server as any)._registeredTools.requestTest.handler({
     description: 'Test Page',
     URL: 'https://example.com/test',
     reason: 'Because accessibility matters'
@@ -116,7 +115,7 @@ test('requestTest handler returns content and structuredContent', async () => {
 
 test('requestRetest handler returns content and structuredContent for a valid report', async () => {
   const server = createMCPServer();
-  const result = await server._registeredTools.requestRetest.handler({
+  const result = await (server as any)._registeredTools.requestRetest.handler({
     timeStamp: '260101T0000',
     jobID: 'mix',
     reason: 'Because the report is obsolete'
@@ -128,7 +127,7 @@ test('requestRetest handler returns content and structuredContent for a valid re
 
 test('requestFeature handler returns content and structuredContent', async () => {
   const server = createMCPServer();
-  const result = await server._registeredTools.requestFeature.handler({
+  const result = await (server as any)._registeredTools.requestFeature.handler({
     feature: 'A new feature idea'
   });
   assert.ok(result.content);
@@ -138,7 +137,7 @@ test('requestFeature handler returns content and structuredContent', async () =>
 
 test('listIssues handler returns an error for a nonexistent report', async () => {
   const server = createMCPServer();
-  const result = await server._registeredTools.listIssues.handler({
+  const result = await (server as any)._registeredTools.listIssues.handler({
     timeStamp: '990101T0000',
     jobID: 'xxx'
   });
@@ -148,7 +147,7 @@ test('listIssues handler returns an error for a nonexistent report', async () =>
 
 test('listViolators handler returns an error for an unknown issue', async () => {
   const server = createMCPServer();
-  const result = await server._registeredTools.listViolators.handler({
+  const result = await (server as any)._registeredTools.listViolators.handler({
     issueID: 'nonexistentIssue',
     timeStamp: '260101T0000',
     jobID: 'mix'
@@ -160,7 +159,7 @@ test('listViolators handler returns an error for an unknown issue', async () =>
 // INTEGRATION TESTS FOR handleMCP
 
 // Helper: sends a single MCP JSON-RPC request to a local server and returns the parsed SSE response.
-const sendMCPRequest = (port, method, params, id) => new Promise((resolve, reject) => {
+const sendMCPRequest = (port: number, method: string, params: any, id: any): Promise<any> => new Promise((resolve, reject) => {
   const body = JSON.stringify({jsonrpc: '2.0', method, params, id});
   const req = http.request({
     port,
@@ -186,7 +185,7 @@ const sendMCPRequest = (port, method, params, id) => new Promise((resolve, rejec
 });
 
 // Helper: parses the JSON-RPC result from an SSE response body.
-const parseSSEResult = body => {
+const parseSSEResult = (body: string) => {
   const jsonLine = body.split('\n').find(line => line.startsWith('data: '));
   if (!jsonLine) {
     throw new Error('No data line in SSE response');
@@ -195,14 +194,13 @@ const parseSSEResult = body => {
 };
 
 // Helper: starts a local HTTP server with handleMCP and returns it.
-const startMCPServer = () => new Promise(resolve => {
-  const {handleMCP} = require('./mcp');
+const startMCPServer = (): Promise<any> => new Promise(resolve => {
   const server = http.createServer((req, res) => handleMCP(req, res));
   server.listen(0, () => resolve(server));
 });
 
 // Helper: closes a server with a timeout fallback.
-const closeMCPServer = server => new Promise(resolve => {
+const closeMCPServer = (server: any) => new Promise<void>(resolve => {
   if (!server) {
     resolve();
     return;
@@ -244,7 +242,7 @@ test('handleMCP lists all 8 tools via tools/list', async () => {
     const res = await sendMCPRequest(port, 'tools/list', {}, 2);
     assert.equal(res.statusCode, 200);
     const result = parseSSEResult(res.body);
-    const toolNames = result.result.tools.map(t => t.name);
+    const toolNames = result.result.tools.map((t: any) => t.name);
     assert.equal(toolNames.length, 8);
     assert.deepEqual(toolNames, [
       'listReports',
@@ -279,3 +277,32 @@ test('handleMCP executes listReports tool via tools/call', async () => {
     await closeMCPServer(server);
   }
 });
+
+test('handleMCP rejects a GET request with a 405 JSON-RPC error', async () => {
+  const server = await startMCPServer();
+  try {
+    const port = server.address().port;
+    const res = await new Promise<any>((resolve, reject) => {
+      const req = http.request({
+        port,
+        method: 'GET',
+        path: '/mcp',
+        headers: {accept: 'application/json, text/event-stream'}
+      }, response => {
+        let data = '';
+        response.on('data', chunk => {
+          data += chunk;
+        });
+        response.on('end', () => resolve({statusCode: response.statusCode, body: data}));
+      });
+      req.on('error', reject);
+      req.end();
+    });
+    assert.equal(res.statusCode, 405);
+    const message = JSON.parse(res.body);
+    assert.equal(message.error.code, -32000);
+  }
+  finally {
+    await closeMCPServer(server);
+  }
+});

package/{mcp.js → mcp.ts}

@@ -1,25 +1,24 @@
 /*
-  mcp.js
+  mcp.ts
   Handles MCP (Model Context Protocol) requests for Kilotest tools.
 */
 
 // IMPORTS
 
-const {McpServer} = require('@modelcontextprotocol/sdk/server/mcp.js');
-const {StreamableHTTPServerTransport} = require(
-  '@modelcontextprotocol/sdk/server/streamableHttp.js'
-);
-const getReportAPI = require('./api/getReport');
-const listReportsAPI = require('./api/listReports');
-const listIssuesAPI = require('./api/listIssues');
-const listViolatorsAPI = require('./api/listViolators');
-const listDiagnosesAPI = require('./api/listDiagnoses');
-const requestTestAPI = require('./api/requestTest');
-const requestRetestAPI = require('./api/requestRetest');
-const requestFeatureAPI = require('./api/requestFeature');
-const {version} = require('./api/version');
+import type {IncomingMessage, ServerResponse} from 'node:http';
+import {McpServer} from '@modelcontextprotocol/sdk/server/mcp.js';
+import {StreamableHTTPServerTransport} from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import * as getReportAPI from './api/getReport.ts';
+import * as listReportsAPI from './api/listReports.ts';
+import * as listIssuesAPI from './api/listIssues.ts';
+import * as listViolatorsAPI from './api/listViolators.ts';
+import * as listDiagnosesAPI from './api/listDiagnoses.ts';
+import * as requestTestAPI from './api/requestTest.ts';
+import * as requestRetestAPI from './api/requestRetest.ts';
+import * as requestFeatureAPI from './api/requestFeature.ts';
+import {version} from './api/version.ts';
 
-const {
+import {
   getReportSchema,
   listIssuesSchema,
   listViolatorsSchema,
@@ -35,16 +34,16 @@ const {
   requestTestResponseSchema,
   requestRetestResponseSchema,
   requestFeatureResponseSchema
-} = require('./api/schemas');
+} from './api/schemas.ts';
 
 // CONSTANTS
 
-exports.mcpPath = '/mcp';
+export const mcpPath = '/mcp';
 
 // FUNCTIONS
 
 // Creates and returns an McpServer with Kilotest tools registered.
-exports.createMCPServer = () => {
+export const createMCPServer = (): McpServer => {
   const server = new McpServer({
     name: 'Kilotest',
     version,
@@ -208,9 +207,19 @@ exports.createMCPServer = () => {
   return server;
 };
 // Handles an MCP request.
-exports.handleMCP = async (request, response) => {
+export const handleMCP = async (request: IncomingMessage, response: ServerResponse): Promise<void> => {
+  // If the request is not a POST request: reject it, because this stateless server has no sessions for GET-opened SSE streams or DELETE requests to act on, and leaving such streams open would leak resources.
+  if (request.method !== 'POST') {
+    response.writeHead(405, {allow: 'POST', 'content-type': 'application/json'});
+    response.end(JSON.stringify({
+      jsonrpc: '2.0',
+      error: {code: -32000, message: 'Method Not Allowed: only POST requests are accepted'},
+      id: null
+    }));
+    return;
+  }
   const transport = new StreamableHTTPServerTransport({sessionIdGenerator: undefined});
-  const server = exports.createMCPServer();
+  const server = createMCPServer();
   await server.connect(transport);
   await transport.handleRequest(request, response);
 };

package/memory/MEMORY.md

@@ -0,0 +1,7 @@
+# Kilotest Memory Index
+
+This directory holds persistent context files for the Kilotest project. Each file captures a decision, profile, or plan that should inform future work on this codebase.
+
+## Index
+
+- [user_maintainer_context.md](user_maintainer_context.md) — user: Maintainer is 84 years old, sole contributor, prioritizes legibility for future maintainers over short-term velocity

package/memory/user_maintainer_context.md

@@ -0,0 +1,24 @@
+---
+type: user
+name: Kilotest maintainer profile
+description: Maintainer is the sole contributor until now and assigns a high probability to maintainership passing to others within 3 years, so prioritizes legibility for future maintainers.
+---
+
+# Kilotest maintaitenance strategy
+
+## Primary goal
+
+Make the codebase forkable and maintainable by future discoverers who have no prior knowledge of the project. Legibility for a cold reader outweighs any speed or terseness optimization.
+
+## Working style
+
+- Major refactorings for architectural improvement are acceptable.
+- Responsibility can be shared between the maintainer and AI agents, with ultimate maintainer responsibility.
+- Delegation of discretion to AI agents is expected to increase gradually as its benefits are demonstrted.
+- Correctness should be promoted by a combination of:
+  - Type constraints
+  - Comprehensive tests
+  - Nonduplication of code
+  - Separation of concerns
+  - Focused purposes of functions and modules
+  - Thorough documentation