razzou-harness 0.2.0 → 0.3.0

package/dist/ci/harness-ci.js

@@ -13,34 +13,50 @@ import { appendFileSync, existsSync, readdirSync, readFileSync, realpathSync, st
 import { join, relative } from 'node:path';
 import { parseArgs } from 'node:util';
 export function directoryReader(root) {
+    const isFile = (file) => existsSync(file) && statSync(file).isFile();
+    const git = (args) => spawnSync('git', ['-C', root, ...args], { encoding: 'utf8', maxBuffer: 1 << 30 });
     return {
         async read(path) {
             const file = join(root, path);
-            return existsSync(file) && statSync(file).isFile() ? readFileSync(file, 'utf8') : undefined;
+            return isFile(file) ? readFileSync(file, 'utf8') : undefined;
         },
         async list(folder) {
+            // In a work tree, git's view: what it ignores, such as node_modules, isn't in a checkout either.
+            if (git(['rev-parse', '--is-inside-work-tree']).stdout?.trim() === 'true') {
+                const listed = git(['ls-files', '-z', '--cached', '--others', '--exclude-standard', '--', folder || '.']);
+                if (listed.status !== 0)
+                    throw new Error(`git ls-files failed in ${root}: ${listed.stderr}`);
+                return listed.stdout.split('\0').filter((path) => path !== '' && isFile(join(root, path)));
+            }
             const start = join(root, folder);
             if (!existsSync(start))
                 return [];
             return readdirSync(start, { recursive: true, encoding: 'utf8' })
                 .map((entry) => join(start, entry))
-                .filter((file) => statSync(file).isFile() && !relative(root, file).startsWith('.git/'))
+                .filter((file) => isFile(file) && !relative(root, file).startsWith('.git/'))
                 .map((file) => relative(root, file));
         },
     };
 }
-/** Paths no Plan or Fix PR may change, in every project. */
-export const ALWAYS_PROTECTED = ['harness/**', '.github/**', '.claude/**', 'CLAUDE.md', 'AGENTS.md', 'ARCHITECTURE.md', 'init.sh', '.npmrc'];
-/** Tool configs written as code: protected whole when they exist. */
+/**
+ * Paths no Plan or Fix PR may change, in every project. Claude Code reads CLAUDE.md,
+ * CLAUDE.local.md, AGENTS.md and `.claude/` in every folder, not only the root's; the
+ * root's CLAUDE.md and AGENTS.md are also named, so the lock lists them even when absent.
+ */
+export const ALWAYS_PROTECTED = [
+    'harness/**', '.github/**', 'CLAUDE.md', 'AGENTS.md', '**/.claude/**', '**/CLAUDE.md', '**/CLAUDE.local.md', '**/AGENTS.md',
+    'ARCHITECTURE.md', 'init.sh', '.npmrc',
+];
+/** Configs that decide what a tool or a test runner runs, written as code: protected whole when they exist. */
 const TOOL_FILES = [
-    'eslint.config.js', 'eslint.config.mjs', 'eslint.config.cjs', 'eslint.config.ts', '.eslintrc', '.eslintrc.js', '.eslintrc.cjs',
-    '.eslintrc.json', '.eslintrc.yml', '.eslintrc.yaml', 'vitest.config.ts', 'vitest.config.js', 'vitest.config.mjs', 'vitest.workspace.ts',
-    'jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'playwright.config.ts', 'playwright.config.js', 'biome.json', 'biome.jsonc',
-    '.prettierrc', '.prettierrc.json', '.prettierrc.js', 'prettier.config.js', 'prettier.config.mjs',
+    'eslint.config.*', '.eslintrc', '.eslintrc.*', 'biome.json', 'biome.jsonc', '.prettierrc', '.prettierrc.*', 'prettier.config.*',
+    'vitest.config.*', 'vitest.workspace.*', 'vite.config.*', 'jest.config.*', 'babel.config.*', '**/.babelrc', '**/.babelrc.*',
+    'playwright.config.*', '.mocharc.*', '**/pytest.ini', '**/.pytest.ini', '**/tox.ini', '**/conftest.py',
 ];
 /** JSON configs: protected by field, so ordinary changes stay possible. */
 const JSON_FIELDS = {
     'tsconfig.json': ['/compilerOptions/strict', '/compilerOptions/noImplicitAny', '/compilerOptions/skipLibCheck', '/exclude'],
+    'package.json': ['/jest', '/babel', '/mocha'],
 };
 /** The rules a tree's own `harness/config.json` and plans set. The base of a change decides them. */
 export async function protectionRules(tree) {
@@ -58,18 +74,65 @@ export async function protectionRules(tree) {
     for (const script of new Set(checks.flatMap((c) => npmScripts(c.run)))) {
         add('package.json', [`/scripts/${script}`, `/scripts/pre${script}`, `/scripts/post${script}`]);
     }
-    return { paths: [...ALWAYS_PROTECTED, ...TOOL_FILES, ...(config?.protect?.files ?? [])], fields };
+    return { paths: [...ALWAYS_PROTECTED, ...TOOL_FILES, ...(config?.protect?.files ?? [])].map(normalisePattern), fields };
 }
-/** npm scripts a command line runs: `npm run lint`, `npm test`, `npm start`. */
+/** npm's options that take the next word as their value. */
+const NPM_VALUE_OPTIONS = ['--prefix', '-C', '--workspace', '-w', '--userconfig', '--globalconfig', '--loglevel'];
+/** npm scripts a command line runs: `npm run lint`, `npm -s test`, `npm --prefix . start`, `node --run lint`. */
 export function npmScripts(command) {
     const scripts = [];
-    for (const match of command.matchAll(/\bnpm\s+(?:run(?:-script)?\s+([\w:.-]+)|(test|t|start|stop|restart)\b)/g)) {
-        scripts.push(match[1] ?? (match[2] === 't' ? 'test' : match[2]));
+    const words = command.split(/[\s;&|()<>'"`]+/);
+    // The next word that isn't one of npm's options, or an option's value.
+    const next = (i) => {
+        while (words[++i]?.startsWith('-'))
+            if (NPM_VALUE_OPTIONS.includes(words[i]))
+                i++;
+        return i;
+    };
+    for (let i = 0; i < words.length; i++) {
+        if (words[i] === 'node' && words[i + 1] === '--run' && words[i + 2])
+            scripts.push(words[i + 2]);
+        if (words[i] === 'node' && words[i + 1]?.startsWith('--run='))
+            scripts.push(words[i + 1].slice('--run='.length));
+        if (words[i] !== 'npm')
+            continue;
+        const at = next(i);
+        if (words[at] === 'run' || words[at] === 'run-script') {
+            const script = words[next(at)];
+            if (script)
+                scripts.push(script);
+        }
+        else if (words[at] === 'test' || words[at] === 't')
+            scripts.push('test');
+        else if (words[at] === 'start' || words[at] === 'stop' || words[at] === 'restart')
+            scripts.push(words[at]);
     }
     return scripts;
 }
+/** A pattern as written in a config: `./x` is `x`, and `dir/` is `dir/**`. */
+function normalisePattern(pattern) {
+    const path = pattern.replace(/^(?:\.?\/)+/, '');
+    // Trailing slashes are counted by hand: /\/+$/ takes quadratic time on a run of slashes before the end.
+    let end = path.length;
+    while (end > 0 && path[end - 1] === '/')
+        end--;
+    return end === path.length ? path : `${path.slice(0, end)}/**`;
+}
+/** Each pattern's regular expression, made once. */
+const compiled = new Map();
+// Whether a path matches a protected pattern: `*` and `?` within a segment, `**` across
+// segments. `**/x` is x in any folder, the root included; `dir/**` is dir and all it holds.
 export function matches(path, pattern) {
-    return pattern.endsWith('/**') ? path.startsWith(pattern.slice(0, -2)) : path === pattern;
+    let regexp = compiled.get(pattern);
+    if (!regexp) {
+        const source = normalisePattern(pattern).replace(/(^|\/)\*\*(\/|$)|\*|\?|[.+^${}()|[\]\\]/g, (token, before, after) => {
+            if (before === undefined)
+                return token === '*' ? '[^/]*' : token === '?' ? '[^/]' : `\\${token}`;
+            return before && after ? '/(?:.*/)?' : before ? '(?:/.*)?' : after ? '(?:.*/)?' : '.*';
+        });
+        compiled.set(pattern, (regexp = new RegExp(`^${source}$`, 's')));
+    }
+    return regexp.test(path);
 }
 /**
  * What an Arch PR may change (§11.3): the design, shared knowledge, what agents and tools
@@ -104,15 +167,25 @@ export async function protectedChanges(base, head, changedPaths, options) {
     }
     return problems;
 }
-/** Packages in package-lock.json that don't come from the public npm registry. */
-export async function lockfileProblems(tree) {
-    const lock = parseJson(await tree.read('package-lock.json'));
+/**
+ * Packages in the head's package-lock.json that don't come from the public npm registry, and
+ * links to a local folder that the base's doesn't have as they are: workspaces already on
+ * the base keep working, and a new link comes through an Arch PR.
+ */
+export async function lockfileProblems(base, head) {
+    const packages = async (tree) => parseJson(await tree.read('package-lock.json'))?.packages ?? {};
+    const [before, after] = [await packages(base), await packages(head)];
     const problems = [];
-    for (const [name, entry] of Object.entries(lock?.packages ?? {})) {
-        if (name === '' || entry.link || entry.resolved === undefined)
+    for (const [name, entry] of Object.entries(after)) {
+        if (name === '')
             continue;
-        if (!entry.resolved.startsWith('https://registry.npmjs.org/'))
+        if (entry.link) {
+            if (before[name]?.link !== true || before[name].resolved !== entry.resolved)
+                problems.push(`${name} links to ${entry.resolved}, which the base branch doesn't`);
+        }
+        else if (entry.resolved !== undefined && !entry.resolved.startsWith('https://registry.npmjs.org/')) {
             problems.push(`${name} resolves from ${entry.resolved}`);
+        }
     }
     return problems;
 }
@@ -120,10 +193,15 @@ export async function lockfileProblems(tree) {
 export async function computeLock(tree) {
     const rules = await protectionRules(tree);
     const files = new Set();
+    let all;
     for (const pattern of rules.paths) {
-        if (pattern.endsWith('/**'))
-            for (const file of await tree.list(pattern.slice(0, -3)))
-                files.add(file);
+        if (/[*?]/.test(pattern)) {
+            // A glob is matched against every file of the tree, listed once.
+            all ??= await tree.list('');
+            for (const file of all)
+                if (matches(file, pattern))
+                    files.add(file);
+        }
         else if ((await tree.read(pattern)) !== undefined || ALWAYS_PROTECTED.includes(pattern))
             files.add(pattern);
     }
@@ -133,7 +211,7 @@ export async function computeLock(tree) {
         const text = await tree.read(path);
         entries.push({ path, sha256: text === undefined ? 'absent' : sha256(text) });
     }
-    for (const [file, pointers] of Object.entries(rules.fields).sort(([a], [b]) => a.localeCompare(b))) {
+    for (const [file, pointers] of Object.entries(rules.fields).sort(([a], [b]) => a.localeCompare(b, 'en'))) {
         const text = await tree.read(file);
         entries.push({ path: file, fields: Object.fromEntries(pointers.map((pointer) => [pointer, fieldHash(text, pointer)])) });
     }
@@ -210,10 +288,12 @@ async function planKindProblems(input, config) {
     if (tag && tag !== kind)
         problems.push(`the title says -${tag}-, but ${module}/${plan} is a ${kind} plan on the base branch: its features' kinds decide`);
     if (kind === 'CODE' && config?.terraform && typeof config.terraform === 'object') {
-        const dir = (config.terraform.dir || 'iac').replace(/\/+$/, '');
-        const touched = input.changedPaths.filter((p) => p === dir || p.startsWith(`${dir}/`));
+        // Terraform at the root, `.` or empty, is every .tf or .tf.json file.
+        const dir = (config.terraform.dir ?? 'iac').replace(/^(?:\.?\/)+/, '').replace(/\/+$/, '');
+        const root = dir === '' || dir === '.';
+        const touched = input.changedPaths.filter((p) => (root ? /\.tf(?:\.json)?$/.test(p) : p === dir || p.startsWith(`${dir}/`)));
         if (touched.length > 0)
-            problems.push(`a CODE plan may not change ${dir}/: infrastructure gets plans of its own (v3 §3.1); changed: ${touched.join(', ')}`);
+            problems.push(`a CODE plan may not change ${root ? 'Terraform files' : `${dir}/`}: infrastructure gets plans of its own (v3 §3.1); changed: ${touched.join(', ')}`);
     }
     return problems;
 }
@@ -228,13 +308,14 @@ export async function verify(input) {
         for (const change of await protectedChanges(input.base, input.head, input.changedPaths, { progress: 'append' })) {
             problems.push(`changes a protected file: ${change}`);
         }
-        for (const problem of await lockfileProblems(input.head))
+        for (const problem of await lockfileProblems(input.base, input.head))
             problems.push(`package-lock.json: ${problem}`);
     }
     if (kind === 'Plan')
         problems.push(...(await planKindProblems(input, config)));
     if (kind === 'Arch') {
-        const rules = await protectionRules(input.head);
+        // The base's rules, as for every PR: what its head protects opens nothing to the PR itself.
+        const rules = await protectionRules(input.base);
         for (const path of input.changedPaths.filter((p) => !archMayChange(p, rules))) {
             problems.push(`an Arch PR may not change ${path}: only the design, shared knowledge and tool configs`);
         }
@@ -298,9 +379,10 @@ export function resolvePointer(value, pointer) {
     }
     return current;
 }
+/** JSON with object keys sorted at every level. The order is English's, whatever the machine's locale, so CI and the owner's machine agree. */
 function canonicalJson(value) {
     return JSON.stringify(value, (_key, v) => v && typeof v === 'object' && !Array.isArray(v)
-        ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b)))
+        ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b, 'en')))
         : v);
 }
 /** JSON, or JSON with comments and trailing commas as tsconfig allows. Undefined if absent or unreadable. */
@@ -361,13 +443,14 @@ async function main() {
     };
     switch (positionals[0]) {
         case 'verify': {
-            const diff = spawnSync('git', ['-C', values.head, 'diff', '--name-only', '--no-renames', `${values['base-sha']}...${values['head-sha']}`], { encoding: 'utf8' });
+            // NUL-separated: otherwise git quotes a path with unusual bytes, and no pattern matches the quoted form.
+            const diff = spawnSync('git', ['-C', values.head, 'diff', '-z', '--name-only', '--no-renames', `${values['base-sha']}...${values['head-sha']}`], { encoding: 'utf8', maxBuffer: 1 << 30 });
             if (diff.status !== 0)
                 throw new Error(`git diff failed: ${diff.stderr}`);
             const problems = await verify({
                 base: directoryReader(values.base),
                 head: directoryReader(values.head),
-                changedPaths: diff.stdout.split('\n').filter(Boolean),
+                changedPaths: diff.stdout.split('\0').filter(Boolean),
                 author: values.author,
                 branch: values.branch,
                 title: values.title ?? '',

package/dist/cli.js

@@ -5,7 +5,7 @@ import { join, resolve } from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
 import { computeLock, directoryReader } from './ci/harness-ci.js';
-import { isAlive, packageRoot, readDaemonInfo, runDaemon, version } from './daemon/main.js';
+import { isRunning, packageRoot, runDaemon, runningDaemon, version } from './daemon/main.js';
 import { ConfigSchema, requiredChecks } from './design/schemas.js';
 import { loadAppCredentials } from './github/app.js';
 import { applyRepositoryRules, checkApp, createApp, installCi } from './github/setup.js';
@@ -94,21 +94,30 @@ async function main() {
             if (!argument) {
                 const file = join(harnessDir, 'state.json');
                 const state = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : undefined;
-                console.log(state?.mode ?? 'manual');
+                const pendingFile = join(harnessDir, 'setup.json');
+                const pending = existsSync(pendingFile) ? JSON.parse(readFileSync(pendingFile, 'utf8')).mode : undefined;
+                console.log(`${state?.mode ?? 'manual'}${pending && pending !== (state?.mode ?? 'manual') ? `, and ${pending} once the daemon starts` : ''}`);
                 return;
             }
             if (argument !== 'manual' && argument !== 'swarm')
                 throw new Error('usage: harness mode [manual|swarm]');
-            const result = await ownerAction(harnessDir, '/api/mode', { mode: argument });
+            const running = runningDaemon(harnessDir) !== undefined;
+            if (running && (await ownerAction(harnessDir, '/api/mode', { mode: argument }, `already ${argument}`)).error)
+                return;
             // GitHub's rules on main differ per mode, and only the owner's gh may change them (v3 §2.1): done here, in the same command.
             const repo = projectConfig(projectDir)?.project.repo;
-            if (result.error || !repo)
-                return;
-            try {
-                await applyRules(projectDir, harnessDir, repo, argument);
+            if (repo) {
+                try {
+                    await applyRules(projectDir, harnessDir, repo, argument);
+                }
+                catch (error) {
+                    console.log(`GitHub's rules on main were not changed: ${error.message}\nRun \`harness github-setup --repo ${repo}\` with gh logged in as an admin of the repository.`);
+                }
             }
-            catch (error) {
-                console.log(`GitHub's rules on main were not changed: ${error.message}\nRun \`harness github-setup --repo ${repo}\` with gh logged in as an admin of the repository.`);
+            if (!running) {
+                // The daemon is down: the switch waits for it in .harness/setup.json (v4 §5).
+                recordForDaemon(harnessDir, { mode: argument });
+                console.log(`${argument}: the daemon switches when it starts (harness up).`);
             }
             return;
         }
@@ -118,16 +127,12 @@ async function main() {
             if ((budgets.ownerHours === undefined && budgets.agentHours === undefined) || [budgets.ownerHours, budgets.agentHours].some((h) => h !== undefined && (!Number.isFinite(h) || h <= 0))) {
                 throw new Error('usage: harness budget --owner-hours <n> | --agent-hours <n>, with positive numbers');
             }
-            const info = readDaemonInfo(harnessDir);
-            if (info && isAlive(info.pid))
-                return void (await ownerAction(harnessDir, '/api/budgets', budgets));
-            // The daemon is down: the hours wait for it in .harness/setup.json (v4 §5).
+            if (runningDaemon(harnessDir))
+                return void (await ownerAction(harnessDir, '/api/budgets', budgets, 'already set'));
+            // The daemon is down: the hours wait for it in .harness/setup.json (v4 §5), and replace any it has, as they would if it ran.
             if (budgets.agentHours !== undefined)
                 throw new Error('the agent-hours threshold needs the daemon running: `harness up`');
-            const file = join(harnessDir, 'setup.json');
-            const pending = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {};
-            mkdirSync(harnessDir, { recursive: true });
-            writeFileSync(file, `${JSON.stringify({ ...pending, ownerHours: budgets.ownerHours }, null, 2)}\n`);
+            recordForDaemon(harnessDir, { ownerHours: budgets.ownerHours, ownerHoursFrom: 'budget' });
             console.log(`${budgets.ownerHours} hours of your time: the daemon records it when it starts (harness up).`);
             return;
         }
@@ -226,8 +231,13 @@ async function main() {
         case 'version':
             console.log(version);
             return;
-        default:
+        case 'help':
+        case undefined:
             console.log(HELP);
+            return;
+        default:
+            console.error(`unknown command: ${command}\n\n${HELP}`);
+            process.exitCode = 1;
     }
 }
 async function ask(question) {
@@ -239,6 +249,13 @@ async function ask(question) {
         rl.close();
     }
 }
+/** Records what the daemon takes from .harness/setup.json when it starts, while it is down (v4 §5). */
+function recordForDaemon(harnessDir, values) {
+    const file = join(harnessDir, 'setup.json');
+    const pending = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {};
+    mkdirSync(harnessDir, { recursive: true });
+    writeFileSync(file, `${JSON.stringify({ ...pending, ...values }, null, 2)}\n`);
+}
 /** The project's configuration, when the directory has one. */
 function projectConfig(projectDir) {
     const configFile = join(projectDir, 'harness', 'config.json');
@@ -309,21 +326,21 @@ async function runDoctor(projectDir, values) {
         process.exitCode = 1;
 }
 async function down(harnessDir) {
-    const info = readDaemonInfo(harnessDir);
-    if (!info || !isAlive(info.pid))
+    const info = runningDaemon(harnessDir);
+    if (!info)
         return console.log('no daemon is running');
     process.kill(info.pid, 'SIGTERM');
-    for (let i = 0; i < 50 && isAlive(info.pid); i++)
+    for (let i = 0; i < 50 && isRunning(info); i++)
         await sleep(200);
-    console.log(isAlive(info.pid) ? `pid ${info.pid} is still stopping` : 'stopped');
+    console.log(isRunning(info) ? `pid ${info.pid} is still stopping` : 'stopped');
 }
 function status(harnessDir) {
     const file = join(harnessDir, 'state.json');
     if (!existsSync(file))
         return console.log('no state yet: run `harness up` first');
     const state = JSON.parse(readFileSync(file, 'utf8'));
-    const info = readDaemonInfo(harnessDir);
-    console.log(info && isAlive(info.pid) ? `daemon: running, http://127.0.0.1:${info.port}` : 'daemon: stopped');
+    const info = runningDaemon(harnessDir);
+    console.log(info ? `daemon: running, http://127.0.0.1:${info.port}` : 'daemon: stopped');
     console.log(`pipeline: ${state.pipeline.paused ? `paused (${state.pipeline.paused.reason})` : 'running'}`);
     for (const [key, plan] of Object.entries(state.plans)) {
         console.log(`\n${key}  ${plan.status}  ${plan.branch} @ ${plan.head.slice(0, 8)}`);
@@ -346,17 +363,30 @@ function status(harnessDir) {
     if (open.length > 0)
         console.log('\nAnswer with: harness answer <request-id> <text>');
 }
-async function ownerAction(harnessDir, path, body) {
-    const info = readDaemonInfo(harnessDir);
-    if (!info || !isAlive(info.pid))
+/**
+ * An owner action, through the running daemon. When the daemon refuses it, the command
+ * fails; `unchanged` is what to say instead when it was already so, such as a mode.
+ */
+async function ownerAction(harnessDir, path, body, unchanged) {
+    const info = runningDaemon(harnessDir);
+    if (!info)
         throw new Error('no daemon is running');
     const response = await fetch(`http://127.0.0.1:${info.port}${path}`, {
         method: 'POST',
         headers: { authorization: `Bearer ${info.token}`, 'content-type': 'application/json' },
         body: JSON.stringify(body),
     });
+    if (!response.ok)
+        throw new Error(`the daemon answered ${response.status}: ${(await response.text()).trim()}`);
     const result = (await response.json());
-    console.log(result.done ? 'done' : result.error ?? 'nothing to do');
+    if (result.done)
+        console.log('done');
+    else if (unchanged !== undefined && result.error === undefined)
+        console.log(unchanged);
+    else {
+        console.error(result.error ?? 'nothing to do');
+        process.exitCode = 1;
+    }
     return result;
 }
 /** The Architect's terminal, attached in this one. Detaching leaves the Architect running. */
@@ -372,8 +402,8 @@ function attach(harnessDir, module) {
     spawnSync('openshell', ['sandbox', 'connect', sandbox], { stdio: 'inherit' });
 }
 async function listActions(harnessDir) {
-    const info = readDaemonInfo(harnessDir);
-    if (!info || !isAlive(info.pid))
+    const info = runningDaemon(harnessDir);
+    if (!info)
         throw new Error('no daemon is running');
     const response = await fetch(`http://127.0.0.1:${info.port}/api/state`, { headers: { authorization: `Bearer ${info.token}` } });
     const { state, design } = (await response.json());

package/dist/daemon/architects.js

@@ -226,6 +226,8 @@ export class Architects {
             o.record({ type: 'ARCH_PR_CLOSED', payload: { module: module.module } });
             return;
         }
+        // In Swarm, main's rules require the reviewers' statuses: an Arch PR, which the owner reviews, gets them as "not reviewed".
+        await o.markUnreviewed(pr.head, 'an Arch PR, which the owner reviews and merges');
         if (module.design.ciNoted === pr.head)
             return;
         const required = requiredChecks(o.design.config);

package/dist/daemon/channel.js

@@ -57,8 +57,14 @@ export class AgentChannel {
     receive(line) {
         if (line.trim() === '')
             return;
-        if (line.length > MAX_LINE)
+        if (line.length > MAX_LINE) {
+            // Not parsed, but its id is near the start: the agent hears why, instead of waiting out its call.
+            const id = /"id"\s*:\s*"([A-Za-z0-9-]{1,64})"/.exec(line.slice(0, 300))?.[1];
+            if (id && !this.replied.has(id)) {
+                void this.reply(id, false, `the request is too large: ${line.length} characters, where the limit is ${MAX_LINE}`).catch(() => { });
+            }
             return this.options.onInvalid(`a request of ${line.length} characters (the limit is ${MAX_LINE})`);
+        }
         let json;
         try {
             json = JSON.parse(line);

package/dist/daemon/design.js

@@ -18,7 +18,8 @@ export async function submitDesign(o, module, summary, head) {
     const tree = o.repo.treeReader(head);
     const changed = await o.repo.changedFiles(base, head);
     const problems = [];
-    const rules = await protectionRules(tree);
+    // Judged by the rules it starts from, as CI judges it: a design can't widen the protected set to change application code with it.
+    const rules = await protectionRules(o.repo.treeReader(base));
     for (const path of changed) {
         if (!archMayChange(path, rules))
             problems.push(`${path}: a design may change only harness/, shared knowledge, agents' instructions and tool configs`);
@@ -35,6 +36,20 @@ export async function submitDesign(o, module, summary, head) {
     }
     if (mine && mine.plans.length === 0)
         problems.push(`there is no plan: write harness/modules/${module.module}/plans/P1.json`);
+    // A feature is frozen with its plan once the plan is past its build: a change to it goes in a new plan.
+    const previous = await loadDesign(o.repo, base).catch(() => undefined);
+    for (const plan of previous?.modules.find((m) => m.id === module.module)?.plans ?? []) {
+        const status = o.state.plans[`${module.module}/${plan.id}`]?.status;
+        if (status === undefined || status === 'active' || !mine)
+            continue;
+        const now = mine.plans.find((p) => p.id === plan.id);
+        for (const feature of plan.features) {
+            const after = now?.features.find((f) => f.id === feature.id);
+            if (!after || definitionHash(after) !== definitionHash(feature)) {
+                problems.push(`${plan.id}/${feature.id}: plan ${plan.id} is past its build (${status.replaceAll('_', ' ')}), so its features are frozen: put the change in a new plan`);
+            }
+        }
+    }
     if (!mine && problems.length === 0)
         problems.push(`there is no design for ${module.module}: write harness/modules/${module.module}/plans/P1.json`);
     for (const plan of mine?.plans ?? []) {
@@ -61,7 +76,6 @@ export async function submitDesign(o, module, summary, head) {
     if (problems.length > 0 || !mine)
         return { ok: false, problems };
     // The new checks, run once on the repository as it is: nothing is built yet, so they should fail.
-    const previous = await loadDesign(o.repo, base).catch(() => undefined);
     const known = new Set(previous?.modules.flatMap((m) => m.plans.flatMap((p) => p.features.map((f) => `${m.id}/${p.id}/${f.id}:${definitionHash(f)}`))) ?? []);
     const fresh = mine.plans.flatMap((p) => p.features.filter((f) => !known.has(`${module.module}/${p.id}/${f.id}:${definitionHash(f)}`)).flatMap((f) => preMerge(f.checks)));
     const results = fresh.length === 0 ? [] : await o.runChecksIn(sandboxName('chk', o.design.config.project.name, module.module, 'design'), architectRef(module.module), o.moduleDir(module.module), fresh);

package/dist/daemon/items.js

@@ -9,7 +9,8 @@ export function pendingItems(o, scope) {
     const others = [];
     for (const feature of Object.values(o.state.features).filter((f) => f.module === module && (only === undefined || f.plan === only))) {
         const last = feature.attempts.at(-1);
-        if (!last)
+        // A feature a design change dropped waits for nobody: an attempt under way stops (v3 §6.6).
+        if (!last || !o.featureDefinition(feature))
             continue;
         if (last.status === 'running') {
             for (const question of (last.questions ?? []).filter((q) => q.answer === undefined)) {
@@ -233,8 +234,10 @@ export function mailText(o, manager, mail) {
     ].join('\n');
 }
 export function attemptsLeft(o, feature) {
-    const hash = definitionHash(o.lookup(feature).feature);
-    return o.design.config.roles.developer.maxAttempts + feature.extraAttempts - countedAttempts(feature, hash);
+    const definition = o.featureDefinition(feature);
+    if (!definition)
+        return 0;
+    return o.design.config.roles.developer.maxAttempts + feature.extraAttempts - countedAttempts(feature, definitionHash(definition));
 }
 function questionsAsked(attempt) {
     const asked = attempt.questions ?? [];