@ludi-uni/ludi-agent-kit 0.1.0

package/tests/fixtures/math-repo/README.md

@@ -0,0 +1,3 @@
+# fixture-math-repo
+Deliberately broken fixture for the ludi-agent-kit pipeline E2E. `average()` divides by `length + 1`.
+Do not fix in place; the E2E copies this directory to a temp location before running.

package/tests/fixtures/math-repo/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "fixture-math-repo",
+  "private": true,
+  "type": "module",
+  "scripts": { "test": "node --test test/math.test.js" }
+}
+

package/tests/fixtures/math-repo/src/math.js

@@ -0,0 +1,11 @@
+// Tiny fixture for math helpers; average() divides by length + 1 on purpose.
+export function sum(values) {
+  let total = 0;
+  for (const v of values) total += v;
+  return total;
+}
+
+export function average(values) {
+  if (values.length === 0) return 0;
+  return sum(values) / (values.length + 1);
+}

package/tests/fixtures/math-repo/test/math.test.js

@@ -0,0 +1,7 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { sum, average } from '../src/math.js';
+
+test('sum adds numbers', () => assert.equal(sum([1, 2, 3]), 6));
+test('average of [2, 4] is 3', () => assert.equal(average([2, 4]), 3));
+test('average of empty list is 0', () => assert.equal(average([]), 0));

package/tests/fixtures/observe/announcements.json

@@ -0,0 +1,8 @@
+{
+  "$comment": "Fixture: provider announcements for the observation layer (Phase 4). Fictional ids.",
+  "announcements": [
+    { "provider": "qoder", "model": "Qwen3.8-Flash", "type": "free-campaign-ended", "asOf": "2026-03-01T00:00:00Z", "label": "Qoder pricing page", "url": "https://example.invalid/qoder-pricing" },
+    { "provider": "openai-codex", "model": "gpt-5.6-luna", "type": "price-changed", "inputPricePer1M": 0.35, "outputPricePer1M": 1.4, "asOf": "2026-03-02T00:00:00Z", "label": "provider price list", "trust": "provider_api" },
+    { "provider": "newp", "model": "Nova-1", "type": "model-added", "contextK": 512, "vision": true, "asOf": "2026-03-03T00:00:00Z", "label": "provider changelog" }
+  ]
+}

package/tests/fixtures/orch-concurrent-child.mjs

@@ -0,0 +1,44 @@
+// Separate process for the concurrent-writer E2E. Not part of node --test.
+//   node tests/fixtures/orch-concurrent-child.mjs <db> <label> <tasks> <delayMs> [throwAt]
+// Runs `tasks` sequential scout tasks against the shared store, each taking `delayMs`
+// so two processes overlap their writes. With `throwAt` the project-store hook throws
+// after that task (an exception the main loop does NOT swallow) to exercise
+// exception-safe termination.
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadRouting } from '../../lib/routing.mjs';
+import { loadAgents } from '../../lib/agents.mjs';
+import { DEFAULT_POLICY } from '../../lib/orchestrator/policy.mjs';
+import { openStore } from '../../lib/orchestrator/store.mjs';
+import { orchestrate } from '../../lib/orchestrator/orchestrator.mjs';
+
+const kit = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+const routing = loadRouting(join(kit, 'routing/routing.json'));
+const { agents } = loadAgents(join(kit, 'agents'), routing);
+const REG = { version: 1, backends: {
+  local: { provider: 'pl', model: 'ml', thinking: 'off' },
+  cheap: { provider: 'pc', model: 'mc', thinking: 'low' },
+  sol: { provider: 'ps', model: 'ms', thinking: 'high' },
+  codex: { provider: 'px', model: 'mx', thinking: 'high' },
+} };
+const [storePath, label, tasksArg, delayArg, throwAt] = process.argv.slice(2);
+const n = Number(tasksArg ?? 3), delayMs = Number(delayArg ?? 50);
+const plan = Array.from({ length: n }, (_, i) => ({ id: `t${i + 1}`, title: `${label} ${i + 1}`, goal: `g${i + 1}`, agent: 'scout', dependencies: i ? [`t${i}`] : [], acceptance: ['done'] }));
+const completed = task => ({ ok: true, structured: true, result: { status: 'completed', summary: `${label} did ${task.id}`, artifacts: [], verification: [], acceptance: [{ id: 'A1', met: true, evidence: 'observed' }], remainingIssues: [], decisions: [], newTasks: [] } });
+
+const session = openStore(storePath);
+let exitCode = 0;
+try {
+  const result = await orchestrate({
+    request: `${label} request`, plan, agents, routing, registry: REG, policy: DEFAULT_POLICY, session,
+    runner: { async run(task) { await new Promise(r => setTimeout(r, delayMs)); return completed(task); } },
+    projectStore: { name: 'inject', async onPlan() {}, async onFinal() {}, async onTaskUpdate(task) { if (throwAt && task.id === throwAt) throw new Error(`${label} injected failure at ${task.id}`); } },
+  });
+  console.log(JSON.stringify({ label, runId: result.runId, runStatus: result.runStatus, status: result.status, tasks: result.tasks.map(t => t.status) }));
+} catch (e) {
+  console.log(JSON.stringify({ label, error: e.message, runId: e.runId ?? null, persisted: e.persisted ?? null }));
+  exitCode = 3;
+} finally {
+  try { session.close(); } catch { /* ignore */ }
+}
+process.exit(exitCode);

package/tests/fixtures/orch-persist-child.mjs

@@ -0,0 +1,61 @@
+// Separate process for the persistent-orchestration restart test. Not part of node --test.
+//   node tests/fixtures/orch-persist-child.mjs start <db>
+//   node tests/fixtures/orch-persist-child.mjs resume <db> <runId> [decisionId]
+//   node tests/fixtures/orch-persist-child.mjs crash <db> <marker>
+import { writeFileSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadRouting } from '../../lib/routing.mjs';
+import { loadAgents } from '../../lib/agents.mjs';
+import { DEFAULT_POLICY } from '../../lib/orchestrator/policy.mjs';
+import { openStore } from '../../lib/orchestrator/store.mjs';
+import { orchestrate } from '../../lib/orchestrator/orchestrator.mjs';
+
+const kit = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+const routing = loadRouting(join(kit, 'routing/routing.json'));
+const { agents } = loadAgents(join(kit, 'agents'), routing);
+const REG = { version: 1, backends: {
+  local: { provider: 'pl', model: 'ml', thinking: 'off' },
+  cheap: { provider: 'pc', model: 'mc', thinking: 'low' },
+  sol: { provider: 'ps', model: 'ms', thinking: 'high' },
+  astra: { provider: 'pa', model: 'ma', thinking: 'medium', vision: true },
+  codex: { provider: 'px', model: 'mx', thinking: 'high' },
+} };
+const phase = process.argv[2];
+const storePath = process.argv[3];
+const spec = (id, agent, dependencies = []) => ({ id, title: `task ${id}`, goal: `goal ${id}`, agent, dependencies, acceptance: ['done'] });
+const completed = task => ({ ok: true, structured: true, result: { status: 'completed', summary: `did ${task.id}`, artifacts: [], verification: [], acceptance: [{ id: 'A1', met: true, evidence: 'observed' }], remainingIssues: [], decisions: [], newTasks: [] } });
+const ask = { key: 'keep', question: 'Keep the existing approach?', flags: ['user_value_judgement'], options: [{ id: 'yes', summary: 'existing approach' }, { id: 'no', summary: 'new approach' }] };
+const blocked = () => ({ ok: true, structured: true, result: { status: 'blocked', summary: 'need a choice', artifacts: [], verification: [], acceptance: [], remainingIssues: [], decisions: [ask], newTasks: [] } });
+
+const session = openStore(storePath);
+try {
+  if (phase === 'start') {
+    const result = await orchestrate({
+      request: 'continue the work', plan: [spec('t1', 'scout'), spec('t2', 'coder', ['t1']), spec('t3', 'reviewer', ['t2'])],
+      agents, routing, registry: REG, policy: DEFAULT_POLICY, session,
+      runner: { async run(task) { return task.id === 't2' && !(task.decisions ?? []).length ? blocked() : completed(task); } },
+    });
+    console.log(JSON.stringify({ runId: result.runId, decisionId: result.escalations[0]?.id, runStatus: result.runStatus, tasks: result.tasks.map(t => ({ id: t.id, status: t.status, attempts: t.attempts })) }));
+  } else if (phase === 'resume') {
+    const calls = [];
+    const decisionId = process.argv[5];
+    const answers = decisionId && decisionId !== '-' ? [{ decisionId, answer: 'yes' }] : [];
+    const result = await orchestrate({
+      request: '', resumeRunId: process.argv[4], answers, agents, routing, registry: REG, policy: DEFAULT_POLICY, session,
+      runner: { async run(task) { calls.push({ id: task.id, attempt: task.attempts }); return completed(task); } },
+    });
+    console.log(JSON.stringify({ status: result.status, runStatus: result.runStatus, calls, tasks: result.tasks.map(t => ({ id: t.id, status: t.status, attempts: t.attempts })) }));
+  } else if (phase === 'crash') {
+    const marker = process.argv[4];
+    await orchestrate({
+      request: 'crash me', plan: [spec('t1', 'scout')], agents, routing, registry: REG, policy: DEFAULT_POLICY, session,
+      runner: { async run(task) { writeFileSync(marker, JSON.stringify({ id: task.id, attempts: task.attempts, status: task.status })); process.exit(99); } },
+    });
+  } else {
+    console.error(`unknown phase ${phase}`);
+    process.exit(2);
+  }
+} finally {
+  try { session.close(); } catch { /* process.exit skips this */ }
+}

package/tests/job.test.mjs

@@ -0,0 +1,230 @@
+// Phase 5: maintenance job — quiet-by-default, severity, notification dedupe,
+// lock/concurrency, failure semantics, run budget, command sink. Cases A–M.
+// Everything runs against a temp outDir; real config files are never touched.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  runMaintenanceJob, acquireLock, releaseLock, shouldNotify, notificationHash,
+  classifyRun, buildNotification, sinks, atomicWriteJson, loadRunState,
+} from '../lib/job.mjs';
+import { DEFAULT_POLICY } from '../lib/maintenance-exec.mjs';
+import { loadRouting } from '../lib/routing.mjs';
+import { loadAgents } from '../lib/agents.mjs';
+import { mergeRegistries } from '../lib/registry.mjs';
+
+const kit = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const routing = loadRouting(join(kit, 'routing/routing.json'));
+const { agents } = loadAgents(join(kit, 'agents'), routing);
+const tmp = () => mkdtempSync(join(tmpdir(), 'job-'));
+
+const CAT = {
+  version: 1, updatedAt: '2026-03-01',
+  models: [
+    { provider: 'qoder', model: 'Qwen3.8-Flash', status: 'free-campaign', cost: { free: true }, postCampaignCost: { usdPerMInput: 0.3, usdPerMOutput: 1.2 }, contextK: 256, vision: false, toolUse: 'good', location: 'cloud', scores: { coding: 62, reasoning: 55, speed: 85 } },
+    { provider: 'cloudp', model: 'cheap-ok', status: 'active', cost: { usdPerMInput: 0.2, usdPerMOutput: 0.8 }, contextK: 256, vision: false, toolUse: 'good', location: 'cloud', scores: { coding: 68, reasoning: 62, speed: 75 } },
+    { provider: 'cloudp', model: 'pro-strong', status: 'active', cost: { usdPerMInput: 5, usdPerMOutput: 20 }, contextK: 400, vision: false, toolUse: 'good', location: 'cloud', scores: { coding: 90, reasoning: 88, speed: 60 } },
+  ],
+};
+const CAT_PLUS_VISION = structuredClone(CAT);
+CAT_PLUS_VISION.models.push({ provider: 'cloudp', model: 'vis-ok', status: 'active', cost: { usdPerMInput: 2, usdPerMOutput: 8 }, contextK: 400, vision: true, toolUse: 'good', location: 'cloud', scores: { coding: 80, reasoning: 82, speed: 55 } });
+const REG = mergeRegistries(null, { version: 1, backends: { qoder: { provider: 'qoder', model: 'Qwen3.8-Flash' }, sol: { provider: 'cloudp', model: 'pro-strong' }, astra: { provider: 'cloudp', model: 'vis-ok' } } });
+const base = dir => ({ outDir: dir, adapterDir: join(kit, 'adapters/pi'), kit, catalog: CAT_PLUS_VISION, routing, registry: REG, agents, policy: DEFAULT_POLICY });
+const manualObs = (dir, observations) => { const p = join(dir, 'obs.json'); writeFileSync(p, JSON.stringify({ version: 1, observations })); return p; };
+const OBS = (provider, model, changes, over = {}) => ({ provider, model, observedAt: '2026-03-05T00:00:00Z', source: { type: 'manual', trust: 'manual_verified' }, changes, confidence: 0.9, ...over });
+
+// --- A: no change -> quiet ---------------------------------------------------
+test('A: no observations -> quiet exit, no notification', async () => {
+  const dir = tmp();
+  const run = await runMaintenanceJob(base(dir));
+  assert.equal(run.status, 'ok');
+  assert.equal(run.quiet, true);
+  assert.equal(run.notification, undefined);
+  assert.ok(existsSync(join(dir, 'model-maintenance.lastrun.json'))); // run log kept
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- B: duplicates only -> quiet ---------------------------------------------
+test('B: duplicate observations only -> quiet', async () => {
+  const dir = tmp();
+  const input = manualObs(dir, [OBS('cloudp', 'cheap-ok', { inputPricePer1M: 0.2 })]);
+  await runMaintenanceJob({ ...base(dir), source: 'manual', input });
+  // second run, same observation -> duplicate
+  const run = await runMaintenanceJob({ ...base(dir), source: 'manual', input });
+  assert.equal(run.ingest.duplicates, 1);
+  assert.equal(run.quiet, true);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- C: new model, no routing impact -> info ----------------------------------
+test('C: new model observed -> info notification', async () => {
+  const dir = tmp();
+  const input = manualObs(dir, [OBS('newp', 'Nova-1', { status: 'active', contextK: 512 })]);
+  const run = await runMaintenanceJob({ ...base(dir), source: 'manual', input });
+  assert.equal(run.quiet, false);
+  assert.equal(run.notification.severity, 'info');
+  assert.equal(run.notification.sent, true);
+  assert.equal(run.notification.requiresApproval, true);
+  assert.ok(existsSync(join(dir, 'model-maintenance.notification.json')));
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- D: free end affecting both cheap-code and orchestration -> urgent --------
+test('D: free campaign end affecting multiple capabilities -> urgent notification', async () => {
+  const dir = tmp();
+  // qoder backend (cheap-code primary) bound to a weak model whose campaign ends -> preview proposes a switch
+  const cat = structuredClone(CAT_PLUS_VISION);
+  cat.models[0].scores = { coding: 30, reasoning: 25, speed: 85 };
+  const input = manualObs(dir, [
+    OBS('qoder', 'Qwen3.8-Flash', { free: false, inputPricePer1M: 0.3, outputPricePer1M: 1.2 }),
+    OBS('qoder', 'Qwen3.8-Flash', { status: 'active' }),
+  ]);
+  const run = await runMaintenanceJob({ ...base(dir), catalog: cat, source: 'manual', input });
+  assert.equal(run.notification?.severity, 'urgent');
+  assert.ok(run.notification.routingImpact.length >= 1);
+  assert.ok(run.notification.routingImpact.some(c => c.includes('orchestrator')));
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- E: current model confirmed unavailable -> urgent --------------------------
+test('E: current model removed via high-trust source -> urgent notification', async () => {
+  const dir = tmp();
+  const input = manualObs(dir, [OBS('qoder', 'Qwen3.8-Flash', { status: 'removed' }, { source: { type: 'api', trust: 'provider_api' } })]);
+  const run = await runMaintenanceJob({ ...base(dir), source: 'manual', input });
+  assert.equal(run.notification?.severity, 'urgent');
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- F: observer failure -> unknown, never urgent ------------------------------
+test('F: probe failure alone -> quiet, not urgent', async () => {
+  const dir = tmp();
+  const run = await runMaintenanceJob({ ...base(dir), checkPi: true, listing: false }); // explicit probe failure
+  assert.equal(run.ingest.probeFailed, true);
+  assert.equal(run.quiet, true);
+  assert.equal(run.notification, undefined);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- G: identical notification re-run -> dedupe --------------------------------
+test('G: same notification content on re-run -> not resent', async () => {
+  const dir = tmp();
+  const input = manualObs(dir, [OBS('newp', 'Nova-1', { status: 'active' })]);
+  const r1 = await runMaintenanceJob({ ...base(dir), source: 'manual', input });
+  assert.equal(r1.notification.sent, true);
+  // re-ingest is a duplicate, but the stored observation still produces the same diff
+  const r2 = await runMaintenanceJob(base(dir));
+  assert.equal(r2.notification?.sent, false);
+  assert.match(r2.notification.dedupeReason, /already sent/);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- H: same event, severity rises -> re-notify --------------------------------
+test('H: severity escalation re-notifies despite same payload', async () => {
+  const dir = tmp();
+  const n1 = buildNotification({ severity: 'info', reasons: ['new model'], proposal: { additions: [{ model: 'newp/Nova-1' }] }, preview: null, runId: 'r1', proposalPath: 'p', previewPath: 'v' });
+  const state = { lastNotificationHash: notificationHash(n1), lastSeverity: 'info' };
+  const n2 = { ...n1, severity: 'action' }; // same content, higher severity
+  const d = shouldNotify(state, n2);
+  assert.equal(d.notify, true);
+  assert.match(d.reason, /severity rose/);
+});
+
+// --- I: budget exceeded -> no premium, deterministic, budgetLimited ------------
+test('I: over-budget run skips invocations, continues deterministically', async () => {
+  const dir = tmp();
+  const policy = structuredClone(DEFAULT_POLICY);
+  policy.budget = { maxEstimatedCostPerRunUsd: 0.0001, maxPremiumInvocationsPerRun: 0, maxTotalInvocationsPerRun: 0 };
+  const cat = structuredClone(CAT_PLUS_VISION);
+  cat.models[0].scores = { coding: 30, reasoning: 25, speed: 85 };
+  const input = manualObs(dir, [OBS('qoder', 'Qwen3.8-Flash', { free: false, inputPricePer1M: 0.3, outputPricePer1M: 1.2 })]);
+  let invoked = 0;
+  const run = await runMaintenanceJob({
+    ...base(dir), catalog: cat, source: 'manual', input, live: true, policy,
+    invoke: async () => { invoked++; return { ok: true, text: '{"decision":"keep","confidence":0.9,"reasoningSummary":"x"}', durationMs: 1 }; },
+  });
+  assert.equal(invoked, 0);
+  assert.equal(run.budgetLimited, true);
+  assert.ok(run.notification.budgetLimited === true || run.quiet === true);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- J: concurrent runs -> one executes, artifacts intact -----------------------
+test('J: second concurrent run is skipped by the lock', async () => {
+  const dir = tmp();
+  const lock = acquireLock(join(dir, 'model-maintenance.lock'));
+  assert.equal(lock.acquired, true);
+  const run = await runMaintenanceJob(base(dir));
+  assert.equal(run.status, 'skipped-locked');
+  releaseLock(lock);
+  const run2 = await runMaintenanceJob(base(dir));
+  assert.equal(run2.status, 'ok');
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- K: stale lock -> recovery -------------------------------------------------
+test('K: stale lock is recovered', async () => {
+  const dir = tmp();
+  const lockPath = join(dir, 'model-maintenance.lock');
+  writeFileSync(lockPath, JSON.stringify({ pid: 999999, at: '2020-01-01T00:00:00Z' }));
+  // age the file beyond the TTL
+  const old = new Date(Date.now() - 60 * 60 * 1000);
+  const { utimesSync } = await import('node:fs');
+  utimesSync(lockPath, old, old);
+  const run = await runMaintenanceJob(base(dir));
+  assert.equal(run.status, 'ok');
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- L: no notify-command -> no external execution ------------------------------
+test('L: without --notify-command no external command runs', async () => {
+  const dir = tmp();
+  const input = manualObs(dir, [OBS('newp', 'Nova-1', { status: 'active' })]);
+  const run = await runMaintenanceJob({ ...base(dir), source: 'manual', input });
+  assert.equal(run.notification.sent, true);
+  assert.ok(!run.notification.sinks.some(s => s.sink === 'command'));
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// --- M: notify-command receives JSON on stdin, failure audited ------------------
+test('M: notify-command gets notification JSON on stdin; failure is audited', async () => {
+  const dir = tmp();
+  const capture = join(dir, 'captured.json');
+  const cmd = `node -e "let s='';process.stdin.on('data',d=>s+=d).on('end',()=>require('fs').writeFileSync('${capture.replace(/\\/g, '\\\\')}',s))"`;
+  const input = manualObs(dir, [OBS('newp', 'Nova-1', { status: 'active' })]);
+  const run = await runMaintenanceJob({ ...base(dir), source: 'manual', input, notifyCommand: cmd });
+  const cmdSink = run.notification.sinks.find(s => s.sink === 'command');
+  assert.equal(cmdSink.ok, true);
+  const sent = JSON.parse(readFileSync(capture, 'utf8'));
+  assert.equal(sent.severity, 'info');
+  assert.equal(sent.requiresApproval, true);
+  // failing command -> audited, job still ok
+  const dir2 = tmp();
+  const input2 = manualObs(dir2, [OBS('newp', 'Nova-2', { status: 'active' })]);
+  const run2 = await runMaintenanceJob({ ...base(dir2), source: 'manual', input: input2, notifyCommand: 'node -e "process.exit(3)"' });
+  const bad = run2.notification.sinks.find(s => s.sink === 'command');
+  assert.equal(bad.ok, false);
+  assert.equal(bad.exitCode, 3);
+  assert.equal(run2.status, 'ok');
+  rmSync(dir, { recursive: true, force: true });
+  rmSync(dir2, { recursive: true, force: true });
+});
+
+// --- supporting ----------------------------------------------------------------
+test('classifyRun quiet reasons and severity ordering', () => {
+  const empty = () => ({ stored: [], duplicates: [], stale: [], invalid: [] });
+  assert.equal(classifyRun({ ingest: empty(), diff: { diffs: [] }, proposal: {}, preview: null }).meaningful, false);
+  const dup = empty(); dup.duplicates = [{}];
+  assert.equal(classifyRun({ ingest: dup, diff: { diffs: [] }, proposal: {}, preview: null }).quietReason, 'duplicates only');
+});
+
+test('state persists lastSuccessfulRunAt and proposal hash', async () => {
+  const dir = tmp();
+  await runMaintenanceJob(base(dir));
+  const state = loadRunState(join(dir, 'model-maintenance.state.json'));
+  assert.ok(state.lastSuccessfulRunAt);
+  assert.ok(state.lastProposalHash);
+  rmSync(dir, { recursive: true, force: true });
+});

package/tests/kit.test.mjs

@@ -0,0 +1,79 @@
+// Whole-kit structural checks: validate.mjs passes, agents are capability-bound, no hardcoded
+// user paths, no secrets, adapter boundary respected.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { resolve, dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { validateKit } from '../scripts/validate.mjs';
+import { loadAgents, parseFrontmatter, validateAgent } from '../lib/agents.mjs';
+import { loadRouting } from '../lib/routing.mjs';
+
+const kit = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const SKIP_DIRS = new Set(['.git', '.orchestration', 'node_modules', 'out']);
+const TEXT = /\.(md|mjs|js|json|ps1|py|yaml|yml|txt|gitignore|gitattributes)$/;
+
+function* walk(dir) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const p = join(dir, entry.name);
+    if (entry.isDirectory()) yield* walk(p);
+    else yield p;
+  }
+}
+const files = [...walk(kit)].filter(f => TEXT.test(f) || !f.includes('.'));
+
+test('validate.mjs passes for the shipped kit', () => {
+  const report = validateKit(kit);
+  assert.deepEqual(report.errors, []);
+  assert.equal(report.result, 'PASS');
+  assert.deepEqual(report.summary.agents.sort(), ['browser->browser', 'coder->strong-code', 'orchestrator->orchestration', 'reviewer->deep-review', 'scout->cheap-code', 'tester->cheap-code', 'visual->vision-reasoning']);
+});
+
+test('exactly the seven thin agents exist and none pins a model/provider', () => {
+  const routing = loadRouting(join(kit, 'routing/routing.json'));
+  const { agents, errors } = loadAgents(join(kit, 'agents'), routing);
+  assert.deepEqual(errors, []);
+  assert.deepEqual(agents.map(a => a.meta.name).sort(), ['browser', 'coder', 'orchestrator', 'reviewer', 'scout', 'tester', 'visual']);
+  const bad = parseFrontmatter('---\nname: x\ndescription: d\ncapability: strong-code\nmodel: gpt-something\n---\nbody');
+  assert.ok(validateAgent(bad, routing).some(e => e.includes('must not pin a model')));
+});
+
+test('no fixed Windows user-profile paths are hardcoded', () => {
+  const offenders = [];
+  for (const f of files) {
+    const text = readFileSync(f, 'utf8');
+    if (/[A-Za-z]:\\Users\\(?!someone\\)[A-Za-z0-9_.-]+/.test(text) || /\/Users\/(?!someone\/)[A-Za-z0-9_.-]+\//.test(text)) offenders.push(relative(kit, f));
+  }
+  assert.deepEqual(offenders, []);
+});
+
+test('no API keys / tokens / private keys in tracked-shape files', () => {
+  const pattern = /(gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|sk-[A-Za-z0-9_-]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|-----BEGIN (?:RSA |OPENSSH |EC )?PRIVATE KEY-----)/;
+  const offenders = files.filter(f => pattern.test(readFileSync(f, 'utf8'))).map(f => relative(kit, f));
+  assert.deepEqual(offenders, []);
+});
+
+test('.gitignore excludes secrets, generated output and media', () => {
+  const ignore = readFileSync(join(kit, '.gitignore'), 'utf8');
+  for (const needle of ['auth.json', '.env', '*.key', 'adapters/pi/out/', 'models.local.json', '*.png', '*.mp4']) assert.ok(ignore.includes(needle), needle);
+});
+
+test('provider/model names live only in adapters (common layer stays neutral)', () => {
+  const pi = JSON.parse(readFileSync(join(kit, 'adapters/pi/models.json'), 'utf8'));
+  const concrete = Object.values(pi.backends).flatMap(b => [b.provider, b.model]).filter(v => v && !v.startsWith('TODO'));
+  const common = files.filter(f => /[\\/](lib|routing|agents|rules|context-pack|orchestration)[\\/]/.test(f));
+  for (const f of common) {
+    const text = readFileSync(f, 'utf8');
+    for (const name of concrete) assert.ok(!text.includes(name), `${relative(kit, f)} mentions concrete "${name}"`);
+  }
+});
+
+test('copied skills keep valid frontmatter and visual-verification has no Codex home dependency', () => {
+  const skill = readFileSync(join(kit, 'skills/visual-verification/SKILL.md'), 'utf8');
+  assert.ok(!/CODEX_HOME/.test(skill));
+  assert.match(skill, /^---\r?\nname: visual-verification/);
+  for (const name of ['scripts/common.ps1', 'scripts/screenshot.ps1', 'scripts/desktop-screenshot.ps1', 'scripts/winapp-common.ps1']) {
+    assert.ok(statSync(join(kit, 'skills/visual-verification', name)).isFile(), name);
+  }
+});

package/tests/language-policy.test.mjs

@@ -0,0 +1,93 @@
+// Language policy: Japanese is the default for user-facing output across all agents,
+// applied once at the shared prompt layer — never per-provider, never per-agent-file.
+// Schema keys/enums stay English; explicit user language requests override.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { LANGUAGE_POLICY, withLanguagePolicy } from '../lib/language-policy.mjs';
+import { loadAgents } from '../lib/agents.mjs';
+import { loadRouting } from '../lib/routing.mjs';
+import { buildTaskContract } from '../lib/orchestrator/contract.mjs';
+import { scoutPrompt, coderPrompt } from '../lib/pipeline.mjs';
+import { formatReport } from '../lib/orchestrator/orchestrator.mjs';
+import { parseStructuredResult } from '../lib/orchestrator/runner.mjs';
+
+const kit = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const routing = loadRouting(join(kit, 'routing/routing.json'));
+const { agents } = loadAgents(join(kit, 'agents'), routing);
+const names = agents.map(a => a.meta.name);
+
+// --- policy presence ----------------------------------------------------------
+test('every agent system prompt carries the shared Japanese-default language policy', () => {
+  for (const a of agents) {
+    assert.ok(a.body.includes('Default response language: Japanese'), `${a.meta.name} missing language policy`);
+    assert.ok(a.body.includes('Japanese'), a.meta.name);
+  }
+  // the seven required agents are all covered
+  for (const n of ['scout', 'coder', 'tester', 'reviewer', 'browser', 'orchestrator', 'visual']) {
+    assert.ok(names.includes(n), `agent ${n} loaded`);
+  }
+});
+
+test('policy is applied once at the shared layer, not duplicated per agent file', () => {
+  // the raw agent .md files do NOT contain the policy — it is injected by loadAgents
+  for (const a of agents) {
+    const raw = readFileSync(join(kit, 'agents', a.file), 'utf8');
+    assert.ok(!raw.includes('Default response language'), `${a.file} hardcodes the policy`);
+  }
+});
+
+// --- structured output: keys/enums stay English, values Japanese ----------------
+test('structured result: schema keys/enums stay English, natural-language value is Japanese', () => {
+  const text = '```json\n{"status":"completed","summary":"主要なエントリーポイントは src/main.ts です。","acceptance":[{"id":"A1","met":true,"evidence":"testを実行して確認"}]}\n```';
+  const p = parseStructuredResult(text);
+  assert.equal(p.structured, true);
+  assert.equal(p.result.status, 'completed'); // enum not translated
+  assert.match(p.result.summary, /エントリーポイント/); // value is Japanese
+});
+
+test('result contract instructs Japanese values with English keys/enums', () => {
+  const c = buildTaskContract({ id: 't', title: 'x', goal: 'y', acceptance: ['done'] }, {});
+  assert.match(c, /LANGUAGE/);
+  assert.match(c, /Japanese/);
+  assert.match(c, /never translate/i);
+});
+
+// --- prompts --------------------------------------------------------------------
+test('scout and coder prompts carry the Japanese instruction', () => {
+  const survey = { files: [], inline: [] };
+  assert.match(scoutPrompt({ task: 'x', survey }), /Japanese/);
+  const pack = { task: 't', goal: 'g', constraints: [], relevant_files: [], expected_output: 'x' };
+  assert.match(coderPrompt({ pack, repoRoot: kit }), /Japanese/);
+});
+
+// --- orchestrator report --------------------------------------------------------
+test('orchestrator final report is Japanese', () => {
+  const report = formatReport({ status: 'completed', runId: 'r1', runStatus: 'completed', rounds: 1, tasks: [{ id: 't1', title: 'task', status: 'completed', result: { summary: 'done' } }], autoDecisions: [], unresolved: [], escalations: [], errors: [], limitsHit: [] });
+  assert.match(report, /状態:/);
+  assert.match(report, /完了:/);
+  assert.match(report, /未解決:/);
+  assert.match(report, /ユーザー判断が必要:/);
+});
+
+// --- explicit language override -------------------------------------------------
+test('explicit user language request overrides the Japanese default', () => {
+  // the policy itself states the override — it is a default, not a mandate
+  assert.match(LANGUAGE_POLICY, /Unless the user explicitly requests another language/);
+  assert.match(LANGUAGE_POLICY, /explicitly requests/);
+});
+
+// --- provider independence ------------------------------------------------------
+test('language policy is provider-agnostic (single shared layer)', () => {
+  // withLanguagePolicy wraps any body the same way regardless of which provider
+  // the resolved model belongs to — no provider branching anywhere.
+  const wrapped = withLanguagePolicy('# Agent\nDo work.');
+  assert.ok(wrapped.endsWith(LANGUAGE_POLICY));
+  assert.ok(wrapped.startsWith('# Agent'));
+  // no provider names anywhere in the policy
+  for (const p of ['qoder', 'devin', 'openai', 'freetoken', 'codex']) {
+    assert.ok(!LANGUAGE_POLICY.toLowerCase().includes(p), `policy mentions provider ${p}`);
+  }
+});

package/tests/loop-guard.test.mjs

@@ -0,0 +1,60 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import guard from '../adapters/pi/loop-guard/index.js';
+
+function harness(model = { provider: 'example', id: 'example-model' }) {
+  const handlers = {}, messages = [];
+  let aborts = 0;
+  const ctx = { model, hasUI: false, abort: () => { aborts++; } };
+  guard({ on: (event, fn) => { handlers[event] = fn; }, sendMessage: message => messages.push(message) });
+  const result = (command, text = 'no matches', isError = false) => handlers.tool_result({
+    toolName: 'bash', input: { command }, content: [{ type: 'text', text }], isError,
+  }, ctx);
+  return { handlers, ctx, messages, result, aborts: () => aborts };
+}
+
+test('stops the observed A/B/C search cycle after third identical result', () => {
+  const h = harness();
+  for (let i = 0; i < 2; i++) for (const cmd of ['search A', 'search B', 'search C']) h.result(cmd);
+  assert.equal(h.aborts(), 0);
+  h.result('search A');
+  assert.equal(h.aborts(), 1);
+  assert.equal(h.messages.length, 1);
+  assert.equal(h.handlers.tool_call({ toolName: 'bash', input: { command: 'search D' } }, h.ctx).terminate, true);
+});
+test('changed results and different inputs are progress', () => {
+  const h = harness();
+  for (let i = 0; i < 15; i++) { h.result('status', String(i)); h.result(`query ${i}`); }
+  assert.equal(h.aborts(), 0);
+});
+test('an old repeated result outside the twelve-result window does not stop', () => {
+  const h = harness();
+  h.result('query'); h.result('query');
+  for (let i = 0; i < 12; i++) h.result(`other ${i}`);
+  h.result('query');
+  assert.equal(h.aborts(), 0);
+});
+test('manual input resets; automatic extension followup does not', () => {
+  const h = harness();
+  for (let i = 0; i < 3; i++) h.result('query');
+  h.handlers.input({ source: 'extension' }, h.ctx);
+  assert.equal(h.handlers.tool_call({}, h.ctx).block, true);
+  h.handlers.input({ source: 'rpc' }, h.ctx);
+  assert.equal(h.handlers.tool_call({}, h.ctx), undefined);
+  h.result('query');
+  assert.equal(h.aborts(), 1);
+});
+test('all providers/models receive instructions and loop protection', () => {
+  for (const model of [{provider:'p1',id:'m1'}, {provider:'p2',id:'m2'}]) {
+    const h = harness(model);
+    for (let i = 0; i < 5; i++) h.result('query');
+    assert.equal(h.aborts(), 1);
+    assert.match(h.handlers.before_agent_start({systemPrompt:'original'}, h.ctx).systemPrompt, /Progress rule/);
+  }
+});
+test('repeated errors also stop; existing system prompt is preserved', () => {
+  const h = harness();
+  assert.match(h.handlers.before_agent_start({systemPrompt:'original'}, h.ctx).systemPrompt, /^original/);
+  for (let i = 0; i < 3; i++) h.result('query', 'failure', true);
+  assert.equal(h.aborts(), 1);
+});