kushi-agents 6.1.2 → 6.2.0

package/plugin/runners/test/integration/migrate-to-v550.integration.test.mjs

@@ -0,0 +1,138 @@
+// plugin/runners/test/integration/migrate-to-v550.integration.test.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import YAML from 'yaml';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(HERE, '..', '..', '..', '..');
+const RUNNER = path.join(REPO_ROOT, 'plugin', 'runners', 'migrate-to-v550.mjs');
+
+async function makeV4Project({ withBoundaries = true } = {}) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-migrate-int-'));
+  const integrations = {
+    crm: { request_id: 'REQ-123' },
+    ado: { engagement_id: 100 },
+    sharepoint: { sites: ['https://example.sharepoint.com/sites/proj'] },
+  };
+  if (withBoundaries) {
+    // v4.x shape: boundaries: under integrations.yml with per-user fields mixed in.
+    integrations.boundaries = {
+      crm: { entity_uri: 'crm://...' },
+      email: { folders: ['Project Inbox'] },
+      teams: { chats: ['19:abc@thread.v2'] },
+      meetings: { joinUrls: [] },
+      onenote: { section_file_ids: ['sec-1'] },
+    };
+  }
+  await fs.writeFile(path.join(root, 'integrations.yml'), YAML.stringify(integrations));
+  return root;
+}
+
+function runMigrate(project, alias, extra = []) {
+  return spawnSync(process.execPath, [RUNNER,
+    '--project', project, '--alias', alias, ...extra,
+  ], { encoding: 'utf8' });
+}
+
+test('v4.x project: splits boundaries into per-user file and rewrites integrations.yml', async () => {
+  const p = await makeV4Project();
+  try {
+    const res = runMigrate(p, 'ushak');
+    assert.equal(res.status, 0, `stderr: ${res.stderr}`);
+    const r = JSON.parse(res.stdout.trim().split('\n').pop());
+    assert.equal(r.status, 'ok');
+    assert.equal(r.boundaries_split, true);
+    assert.equal(r.integrations_rewritten, true);
+    assert.equal(r.unchanged, false);
+
+    // integrations.yml no longer has boundaries: block; keeps shared keys.
+    const intAfter = YAML.parse(await fs.readFile(path.join(p, 'integrations.yml'), 'utf8'));
+    assert.equal(intAfter.boundaries, undefined);
+    assert.equal(intAfter.crm.request_id, 'REQ-123');
+    assert.equal(intAfter.ado.engagement_id, 100);
+    assert.deepEqual(intAfter.sharepoint.sites, ['https://example.sharepoint.com/sites/proj']);
+
+    // per-user boundaries.yml has the moved keys.
+    const bAfter = YAML.parse(await fs.readFile(path.join(p, 'Evidence', 'ushak', 'boundaries.yml'), 'utf8'));
+    assert.deepEqual(bAfter.email.folders, ['Project Inbox']);
+    assert.deepEqual(bAfter.teams.chats, ['19:abc@thread.v2']);
+    assert.deepEqual(bAfter.onenote.section_file_ids, ['sec-1']);
+    // crm.entity_uri is NOT moved (it's a shared key under boundaries → promoted to top)
+    assert.equal(bAfter.crm, undefined);
+  } finally { await fs.rm(p, { recursive: true, force: true }); }
+});
+
+test('scaffolds _shared/* and per-user dirs', async () => {
+  const p = await makeV4Project();
+  try {
+    runMigrate(p, 'ushak');
+    for (const d of ['crm', 'ado', 'sharepoint']) {
+      assert.ok((await fs.stat(path.join(p, 'Evidence', '_shared', d))).isDirectory(), `_shared/${d} must exist`);
+    }
+    for (const d of ['email', 'teams', 'meetings', 'onenote', 'sharepoint', 'crm-notes', 'ado-notes', '_deferred-retries', '_discovery', 'refresh-reports']) {
+      assert.ok((await fs.stat(path.join(p, 'Evidence', 'ushak', d))).isDirectory(), `Evidence/ushak/${d} must exist`);
+    }
+    assert.ok((await fs.stat(path.join(p, 'Evidence', 'ushak', '_ledger.yml'))).isFile());
+  } finally { await fs.rm(p, { recursive: true, force: true }); }
+});
+
+test('idempotent: second run reports unchanged: true', async () => {
+  const p = await makeV4Project();
+  try {
+    runMigrate(p, 'ushak');
+    const r = JSON.parse(runMigrate(p, 'ushak').stdout.trim().split('\n').pop());
+    assert.equal(r.unchanged, true);
+    assert.deepEqual(r.dirs_created, []);
+    assert.deepEqual(r.files_created, []);
+    assert.equal(r.boundaries_split, false);
+    assert.equal(r.integrations_rewritten, false);
+  } finally { await fs.rm(p, { recursive: true, force: true }); }
+});
+
+test('--dry-run does not write anything', async () => {
+  const p = await makeV4Project();
+  try {
+    const res = runMigrate(p, 'ushak', ['--dry-run']);
+    const r = JSON.parse(res.stdout.trim().split('\n').pop());
+    assert.equal(r.dry_run, true);
+    // Reports planned changes
+    assert.ok(r.boundaries_split || r.integrations_rewritten || r.dirs_created.length > 0);
+    // But disk is untouched
+    assert.equal((await fs.readdir(p)).includes('Evidence'), false, 'Evidence/ must not exist after --dry-run');
+    const intAfter = YAML.parse(await fs.readFile(path.join(p, 'integrations.yml'), 'utf8'));
+    assert.ok(intAfter.boundaries, 'integrations.yml must be untouched');
+  } finally { await fs.rm(p, { recursive: true, force: true }); }
+});
+
+test('v5.5.0-shape project (no boundaries: block): only scaffolds missing dirs', async () => {
+  const p = await makeV4Project({ withBoundaries: false });
+  try {
+    const r = JSON.parse(runMigrate(p, 'ushak').stdout.trim().split('\n').pop());
+    assert.equal(r.boundaries_split, false);
+    assert.equal(r.integrations_rewritten, false);
+    // dirs were scaffolded
+    assert.ok(r.dirs_created.length > 0);
+    // boundaries.yml stub written
+    const bAfter = YAML.parse(await fs.readFile(path.join(p, 'Evidence', 'ushak', 'boundaries.yml'), 'utf8'));
+    assert.deepEqual(bAfter.email.folders, []);
+  } finally { await fs.rm(p, { recursive: true, force: true }); }
+});
+
+test('missing --project exits 2', () => {
+  const res = spawnSync(process.execPath, [RUNNER], { encoding: 'utf8' });
+  assert.equal(res.status, 2);
+});
+
+test('non-existent project reports error and exits 1', async () => {
+  const res = runMigrate(path.join(os.tmpdir(), 'definitely-not-a-real-project-xyz'), 'ushak');
+  assert.equal(res.status, 1);
+  const r = JSON.parse(res.stdout.trim().split('\n').pop());
+  assert.equal(r.status, 'partial');
+  assert.equal(r.errors[0].signature, 'project-missing');
+});

package/plugin/runners/test/integration/pull-email.integration.test.mjs

@@ -0,0 +1,149 @@
+// plugin/runners/test/integration/pull-email.integration.test.mjs
+
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import YAML from 'yaml';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(HERE, '..', '..', '..', '..');
+const RUNNER = path.join(REPO_ROOT, 'plugin', 'runners', 'pull-email.mjs');
+const FIXTURE = path.join(HERE, '..', 'fixtures', 'email-abn-amro.json');
+
+let projectRoot;
+
+before(async () => {
+  projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-email-int-'));
+  await fs.mkdir(path.join(projectRoot, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot, 'integrations.yml'), YAML.stringify({}));
+});
+after(async () => { await fs.rm(projectRoot, { recursive: true, force: true }); });
+
+function runRunner(extra = []) {
+  return spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak',
+    '--entity', '23. ABN AMRO',
+    '--week', '2026-05-25', '--fixture', FIXTURE,
+    ...extra,
+  ], { encoding: 'utf8' });
+}
+
+test('captures only messages within the ISO week window', () => {
+  const res = runRunner();
+  assert.equal(res.status, 0, `stderr: ${res.stderr}`);
+  const result = JSON.parse(res.stdout.trim().split('\n').pop());
+  assert.equal(result.status, 'captured');
+  assert.equal(result.items_pulled, 2);
+});
+
+test('writes per-week directory under sanitized folder name', async () => {
+  const dir = path.join(projectRoot, 'Evidence', 'ushak', 'email', '23. ABN AMRO', '2026-05-25');
+  const msgs = YAML.parse(await fs.readFile(path.join(dir, 'messages.yml'), 'utf8'));
+  assert.equal(msgs.length, 2);
+  const md = await fs.readFile(path.join(dir, 'index.md'), 'utf8');
+  assert.match(md, /Kickoff agenda/);
+  assert.match(md, /Architecture review notes/);
+});
+
+test('ledger entry captured with folder metadata', async () => {
+  const ledger = YAML.parse(await fs.readFile(path.join(projectRoot, 'Evidence', 'ushak', '_ledger.yml'), 'utf8'));
+  const cell = ledger.entries['email::23. ABN AMRO::2026-05-25'];
+  assert.ok(cell);
+  assert.equal(cell.last_status, 'captured');
+  assert.equal(cell.items_pulled, 2);
+  assert.equal(cell.folder_id, 'AAMkAGI=');
+});
+
+test('folder not found → status failed (exit 0, recorded in ledger)', async () => {
+  const res = spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak',
+    '--entity', 'NoSuchFolder', '--week', '2026-05-25', '--fixture', FIXTURE,
+  ], { encoding: 'utf8' });
+  assert.equal(res.status, 0);
+  const r = JSON.parse(res.stdout.trim().split('\n').pop());
+  assert.equal(r.status, 'failed');
+  assert.equal(r.errors[0].signature, 'folder-not-found');
+});
+
+test('dry-run does not write files', async () => {
+  const projectRoot2 = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-email-dry-'));
+  await fs.mkdir(path.join(projectRoot2, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot2, 'integrations.yml'), YAML.stringify({}));
+  try {
+    const res = spawnSync(process.execPath, [RUNNER,
+      '--project', projectRoot2, '--alias', 'ushak',
+      '--entity', '23. ABN AMRO', '--week', '2026-05-25', '--fixture', FIXTURE, '--dry-run',
+    ], { encoding: 'utf8' });
+    assert.equal(res.status, 0);
+    const r = JSON.parse(res.stdout.trim().split('\n').pop());
+    assert.deepEqual(r.files_written, []);
+    let exists = true;
+    try { await fs.access(path.join(projectRoot2, 'Evidence', 'ushak', 'email')); } catch { exists = false; }
+    assert.equal(exists, false);
+  } finally {
+    await fs.rm(projectRoot2, { recursive: true, force: true });
+  }
+});
+
+test('missing --entity exits 2', () => {
+  const res = spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak', '--fixture', FIXTURE,
+  ], { encoding: 'utf8' });
+  assert.equal(res.status, 2);
+});
+
+test('v5.6.0: non-retryable error emits a learning candidate file', async () => {
+  const projectRoot3 = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-email-novel-'));
+  await fs.mkdir(path.join(projectRoot3, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot3, 'integrations.yml'), YAML.stringify({}));
+  const NOVEL_FIXTURE = path.join(HERE, '..', 'fixtures', 'email-novel-error.json');
+  try {
+    const res = spawnSync(process.execPath, [RUNNER,
+      '--project', projectRoot3, '--alias', 'ushak',
+      '--entity', '23. ABN AMRO', '--week', '2026-05-25', '--fixture', NOVEL_FIXTURE,
+    ], { encoding: 'utf8' });
+    assert.equal(res.status, 0, `stderr: ${res.stderr}`);
+    const r = JSON.parse(res.stdout.trim().split('\n').pop());
+    assert.equal(r.status, 'failed');
+    const candDir = path.join(projectRoot3, 'Evidence', '_learnings-candidates');
+    const entries = await fs.readdir(candDir);
+    const mdFiles = entries.filter(f => f.endsWith('.md'));
+    assert.equal(mdFiles.length, 1, `expected exactly one candidate, got: ${entries.join(', ')}`);
+    const body = await fs.readFile(path.join(candDir, mdFiles[0]), 'utf8');
+    assert.match(body, /fetch-failed/);
+    assert.match(body, /unexpected null/);
+    // Re-run within window — should not duplicate.
+    spawnSync(process.execPath, [RUNNER,
+      '--project', projectRoot3, '--alias', 'ushak',
+      '--entity', '23. ABN AMRO', '--week', '2026-05-25', '--fixture', NOVEL_FIXTURE,
+    ], { encoding: 'utf8' });
+    const entries2 = await fs.readdir(candDir);
+    const mdFiles2 = entries2.filter(f => f.endsWith('.md'));
+    assert.equal(mdFiles2.length, 1, 'dedup should prevent a 2nd file within 7d');
+  } finally {
+    await fs.rm(projectRoot3, { recursive: true, force: true });
+  }
+});
+
+test('v5.6.0: user-side error does NOT emit a learning candidate', async () => {
+  const projectRoot4 = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-email-userside-'));
+  await fs.mkdir(path.join(projectRoot4, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot4, 'integrations.yml'), YAML.stringify({}));
+  try {
+    const res = spawnSync(process.execPath, [RUNNER,
+      '--project', projectRoot4, '--alias', 'ushak',
+      '--entity', 'NoSuchFolder', '--week', '2026-05-25', '--fixture', FIXTURE,
+    ], { encoding: 'utf8' });
+    assert.equal(res.status, 0);
+    let exists = true;
+    try { await fs.access(path.join(projectRoot4, 'Evidence', '_learnings-candidates')); }
+    catch { exists = false; }
+    assert.equal(exists, false, 'folder-not-found should never trigger candidate emission');
+  } finally {
+    await fs.rm(projectRoot4, { recursive: true, force: true });
+  }
+});

package/plugin/runners/test/integration/pull-meetings.integration.test.mjs

@@ -0,0 +1,92 @@
+// plugin/runners/test/integration/pull-meetings.integration.test.mjs
+
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import YAML from 'yaml';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(HERE, '..', '..', '..', '..');
+const RUNNER = path.join(REPO_ROOT, 'plugin', 'runners', 'pull-meetings.mjs');
+const FIXTURE_OK = path.join(HERE, '..', 'fixtures', 'meetings-abn-amro.json');
+const FIXTURE_BU = path.join(HERE, '..', 'fixtures', 'meetings-body-unavailable.json');
+const JOIN_URL_OK = 'https://teams.microsoft.com/meet/31827546911768?p=YOgZHuaffeF0MGBCNt';
+const JOIN_URL_BU = 'https://teams.microsoft.com/meet/26457824867211?p=zdSjg6cqHoHPA8Hx11';
+
+let projectRoot;
+
+before(async () => {
+  projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-meet-int-'));
+  await fs.mkdir(path.join(projectRoot, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot, 'integrations.yml'), YAML.stringify({}));
+});
+after(async () => { await fs.rm(projectRoot, { recursive: true, force: true }); });
+
+test('captures meeting + transcript verbatim', () => {
+  const res = spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak',
+    '--entity', JOIN_URL_OK, '--week', '2026-05-25', '--fixture', FIXTURE_OK,
+  ], { encoding: 'utf8' });
+  assert.equal(res.status, 0, `stderr: ${res.stderr}`);
+  const r = JSON.parse(res.stdout.trim().split('\n').pop());
+  assert.equal(r.status, 'captured');
+  assert.equal(r.items_pulled, 1);
+  assert.ok(r.transcript_chars > 0);
+});
+
+test('transcript written verbatim to verbatim/transcript.txt', async () => {
+  // Find the meetings directory (only one)
+  const meetDir = path.join(projectRoot, 'Evidence', 'ushak', 'meetings');
+  const entries = await fs.readdir(meetDir);
+  assert.equal(entries.length, 1);
+  const tx = await fs.readFile(path.join(meetDir, entries[0], 'verbatim', 'transcript.txt'), 'utf8');
+  assert.match(tx, /WEBVTT/);
+  assert.match(tx, /Architecture diagram is ready for review/);
+});
+
+test('body-unavailable → defers (4h marker) and writes meeting.yml only', async () => {
+  const projectRoot2 = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-meet-bu-'));
+  await fs.mkdir(path.join(projectRoot2, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot2, 'integrations.yml'), YAML.stringify({}));
+  try {
+    const res = spawnSync(process.execPath, [RUNNER,
+      '--project', projectRoot2, '--alias', 'ushak',
+      '--entity', JOIN_URL_BU, '--week', '2026-05-25', '--fixture', FIXTURE_BU,
+    ], { encoding: 'utf8' });
+    assert.equal(res.status, 0, `stderr: ${res.stderr}`);
+    const r = JSON.parse(res.stdout.trim().split('\n').pop());
+    assert.equal(r.status, 'body-unavailable');
+    assert.equal(r.errors[0].signature, 'body-unavailable');
+    assert.equal(r.errors[0].retry_after_min, 240);
+    // deferred-retries directory has an entry
+    const deferredDir = path.join(projectRoot2, 'Evidence', 'ushak', '_deferred-retries', 'meetings');
+    const files = await fs.readdir(deferredDir);
+    assert.ok(files.length >= 1);
+    // No transcript file written
+    const meetDir = path.join(projectRoot2, 'Evidence', 'ushak', 'meetings');
+    const entries = await fs.readdir(meetDir);
+    let txExists = true;
+    try { await fs.access(path.join(meetDir, entries[0], 'verbatim', 'transcript.txt')); } catch { txExists = false; }
+    assert.equal(txExists, false);
+  } finally { await fs.rm(projectRoot2, { recursive: true, force: true }); }
+});
+
+test('ledger reflects captured state with transcript_chars', async () => {
+  const ledger = YAML.parse(await fs.readFile(path.join(projectRoot, 'Evidence', 'ushak', '_ledger.yml'), 'utf8'));
+  const cell = ledger.entries[`meetings::${JOIN_URL_OK}::2026-05-25`];
+  assert.ok(cell);
+  assert.equal(cell.last_status, 'captured');
+  assert.equal(cell.transcript_available, true);
+  assert.ok(cell.transcript_chars > 0);
+});
+
+test('missing --entity exits 2', () => {
+  const res = spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak', '--fixture', FIXTURE_OK,
+  ], { encoding: 'utf8' });
+  assert.equal(res.status, 2);
+});

package/plugin/runners/test/integration/pull-onenote.integration.test.mjs

@@ -0,0 +1,86 @@
+// plugin/runners/test/integration/pull-onenote.integration.test.mjs
+
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import YAML from 'yaml';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(HERE, '..', '..', '..', '..');
+const RUNNER = path.join(REPO_ROOT, 'plugin', 'runners', 'pull-onenote.mjs');
+const FIXTURE_OK = path.join(HERE, '..', 'fixtures', 'onenote-abn-amro.json');
+const FIXTURE_PARTIAL = path.join(HERE, '..', 'fixtures', 'onenote-partial.json');
+const SECTION_ID = '015a0ac9-58f4-4f34-98b3-a60075b36627';
+
+let projectRoot;
+
+before(async () => {
+  projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-on-int-'));
+  await fs.mkdir(path.join(projectRoot, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot, 'integrations.yml'), YAML.stringify({}));
+});
+after(async () => { await fs.rm(projectRoot, { recursive: true, force: true }); });
+
+test('captures all pages within the week, writes one HTML file per page', () => {
+  const res = spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak',
+    '--entity', SECTION_ID, '--week', '2026-05-25', '--fixture', FIXTURE_OK,
+  ], { encoding: 'utf8' });
+  assert.equal(res.status, 0, `stderr: ${res.stderr}`);
+  const r = JSON.parse(res.stdout.trim().split('\n').pop());
+  assert.equal(r.status, 'captured');
+  assert.equal(r.pages_enumerated, 2);   // p1 + p2 (p3 is stale)
+  assert.equal(r.items_pulled, 2);
+});
+
+test('per-page HTML written verbatim under content/<id>.html', async () => {
+  const dir = path.join(projectRoot, 'Evidence', 'ushak', 'onenote', SECTION_ID, '2026-05-25', 'content');
+  const p1 = await fs.readFile(path.join(dir, 'p1.html'), 'utf8');
+  const p2 = await fs.readFile(path.join(dir, 'p2.html'), 'utf8');
+  assert.match(p1, /Kickoff/);
+  assert.match(p2, /Three-tier/);
+});
+
+test('partial: body-unavailable pages NOT enqueued in deferred-retries', async () => {
+  const projectRoot2 = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-on-part-'));
+  await fs.mkdir(path.join(projectRoot2, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot2, 'integrations.yml'), YAML.stringify({}));
+  try {
+    const res = spawnSync(process.execPath, [RUNNER,
+      '--project', projectRoot2, '--alias', 'ushak',
+      '--entity', SECTION_ID, '--week', '2026-05-25', '--fixture', FIXTURE_PARTIAL,
+    ], { encoding: 'utf8' });
+    assert.equal(res.status, 0, `stderr: ${res.stderr}`);
+    const r = JSON.parse(res.stdout.trim().split('\n').pop());
+    assert.equal(r.status, 'partial');
+    assert.equal(r.items_pulled, 1);
+    assert.deepEqual(r.body_unavailable, ['p2']);
+    // Confirm OneNote is forbidden from enqueueing body-unavailable (lib/deferred.mjs throws)
+    let deferredCount = 0;
+    try {
+      const files = await fs.readdir(path.join(projectRoot2, 'Evidence', 'ushak', '_deferred-retries', 'onenote'));
+      deferredCount = files.length;
+    } catch { deferredCount = 0; }
+    assert.equal(deferredCount, 0);
+  } finally { await fs.rm(projectRoot2, { recursive: true, force: true }); }
+});
+
+test('ledger captures pages_enumerated and section_file_id', async () => {
+  const ledger = YAML.parse(await fs.readFile(path.join(projectRoot, 'Evidence', 'ushak', '_ledger.yml'), 'utf8'));
+  const cell = ledger.entries[`onenote::${SECTION_ID}::2026-05-25`];
+  assert.ok(cell);
+  assert.equal(cell.last_status, 'captured');
+  assert.equal(cell.pages_enumerated, 2);
+  assert.equal(cell.section_file_id, SECTION_ID);
+});
+
+test('missing --entity exits 2', () => {
+  const res = spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak', '--fixture', FIXTURE_OK,
+  ], { encoding: 'utf8' });
+  assert.equal(res.status, 2);
+});

package/plugin/runners/test/integration/pull-sharepoint.integration.test.mjs

@@ -0,0 +1,93 @@
+// plugin/runners/test/integration/pull-sharepoint.integration.test.mjs
+
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import YAML from 'yaml';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(HERE, '..', '..', '..', '..');
+const RUNNER = path.join(REPO_ROOT, 'plugin', 'runners', 'pull-sharepoint.mjs');
+const FIXTURE = path.join(HERE, '..', 'fixtures', 'sharepoint-abn-amro.json');
+const SITE_OK = 'https://abnamro.sharepoint.com/sites/TeamAlfred';
+const SITE_BAD = 'https://contoso-evil.sharepoint.com/sites/X';
+
+let projectRoot;
+
+before(async () => {
+  projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-sp-int-'));
+  await fs.mkdir(path.join(projectRoot, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot, 'integrations.yml'), YAML.stringify({}));
+});
+after(async () => { await fs.rm(projectRoot, { recursive: true, force: true }); });
+
+test('captures items within ISO week — no bundling (one file per item)', async () => {
+  const res = spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak',
+    '--entity', SITE_OK, '--week', '2026-05-25',
+    '--allowed-tenants', 'abnamro.sharepoint.com',
+    '--fixture', FIXTURE,
+  ], { encoding: 'utf8' });
+  assert.equal(res.status, 0, `stderr: ${res.stderr}`);
+  const r = JSON.parse(res.stdout.trim().split('\n').pop());
+  assert.equal(r.status, 'captured');
+  assert.equal(r.items_pulled, 2);
+  // No bundle file like items.yml — only one-file-per-item under items/
+  const dir = path.join(projectRoot, 'Evidence', '_shared', 'sharepoint', r.site_hash, '2026-05-25');
+  const itemFiles = await fs.readdir(path.join(dir, 'items'));
+  assert.equal(itemFiles.length, 2);
+  for (const f of itemFiles) assert.ok(f.endsWith('.yml'));
+});
+
+test('cross-tenant site blocked → status failed', async () => {
+  const projectRoot2 = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-sp-xtenant-'));
+  await fs.mkdir(path.join(projectRoot2, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot2, 'integrations.yml'), YAML.stringify({}));
+  try {
+    const res = spawnSync(process.execPath, [RUNNER,
+      '--project', projectRoot2, '--alias', 'ushak',
+      '--entity', SITE_BAD, '--week', '2026-05-25',
+      '--allowed-tenants', 'abnamro.sharepoint.com,microsoft.sharepoint.com',
+      '--fixture', FIXTURE,
+    ], { encoding: 'utf8' });
+    assert.equal(res.status, 0);
+    const r = JSON.parse(res.stdout.trim().split('\n').pop());
+    assert.equal(r.status, 'failed');
+    assert.equal(r.errors[0].signature, 'cross-tenant-blocked');
+    // No items written
+    let exists = true;
+    try { await fs.access(path.join(projectRoot2, 'Evidence', '_shared', 'sharepoint')); } catch { exists = false; }
+    assert.equal(exists, false);
+  } finally { await fs.rm(projectRoot2, { recursive: true, force: true }); }
+});
+
+test('item files have correct content', async () => {
+  const r = JSON.parse(spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak',
+    '--entity', SITE_OK, '--week', '2026-05-25',
+    '--allowed-tenants', 'abnamro.sharepoint.com',
+    '--fixture', FIXTURE,
+  ], { encoding: 'utf8' }).stdout.trim().split('\n').pop());
+  const dir = path.join(projectRoot, 'Evidence', '_shared', 'sharepoint', r.site_hash, '2026-05-25', 'items');
+  const it = YAML.parse(await fs.readFile(path.join(dir, '01ABC.yml'), 'utf8'));
+  assert.equal(it.name, 'Architecture.pptx');
+});
+
+test('ledger entry uses raw site url as cell key', async () => {
+  const ledger = YAML.parse(await fs.readFile(path.join(projectRoot, 'Evidence', 'ushak', '_ledger.yml'), 'utf8'));
+  const cell = ledger.entries[`sharepoint::${SITE_OK}::2026-05-25`];
+  assert.ok(cell);
+  assert.equal(cell.last_status, 'captured');
+  assert.equal(cell.items_pulled, 2);
+});
+
+test('missing --entity exits 2', () => {
+  const res = spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak', '--fixture', FIXTURE,
+  ], { encoding: 'utf8' });
+  assert.equal(res.status, 2);
+});

package/plugin/runners/test/integration/pull-teams.integration.test.mjs

@@ -0,0 +1,91 @@
+// plugin/runners/test/integration/pull-teams.integration.test.mjs
+
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import YAML from 'yaml';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(HERE, '..', '..', '..', '..');
+const RUNNER = path.join(REPO_ROOT, 'plugin', 'runners', 'pull-teams.mjs');
+const FIXTURE = path.join(HERE, '..', 'fixtures', 'teams-abn-amro.json');
+const CHAT_ID = '19:e17bf64ba941442590dae0824cc4784c@thread.v2';
+
+let projectRoot;
+
+before(async () => {
+  projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-teams-int-'));
+  await fs.mkdir(path.join(projectRoot, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot, 'integrations.yml'), YAML.stringify({}));
+});
+after(async () => { await fs.rm(projectRoot, { recursive: true, force: true }); });
+
+function runRunner(entity, extra = []) {
+  return spawnSync(process.execPath, [RUNNER,
+    '--project', projectRoot, '--alias', 'ushak',
+    '--entity', entity,
+    '--week', '2026-05-25', '--fixture', FIXTURE,
+    ...extra,
+  ], { encoding: 'utf8' });
+}
+
+test('captures only messages within the ISO week window', () => {
+  const res = runRunner(CHAT_ID);
+  assert.equal(res.status, 0, `stderr: ${res.stderr}`);
+  const r = JSON.parse(res.stdout.trim().split('\n').pop());
+  assert.equal(r.status, 'captured');
+  assert.equal(r.items_pulled, 3);
+  assert.ok(r.chat_hash && r.chat_hash.length === 12);
+});
+
+test('uses shortHash for directory (unsafe chat id chars sanitized)', async () => {
+  const r = JSON.parse(runRunner(CHAT_ID).stdout.trim().split('\n').pop());
+  const dir = path.join(projectRoot, 'Evidence', 'ushak', 'teams', r.chat_hash, '2026-05-25');
+  const msgs = YAML.parse(await fs.readFile(path.join(dir, 'messages.yml'), 'utf8'));
+  assert.equal(msgs.length, 3);
+  const chat = YAML.parse(await fs.readFile(path.join(dir, 'chat.yml'), 'utf8'));
+  assert.equal(chat.chat_id, CHAT_ID);
+});
+
+test('ledger entry retains raw chat id as cell key', async () => {
+  const ledger = YAML.parse(await fs.readFile(path.join(projectRoot, 'Evidence', 'ushak', '_ledger.yml'), 'utf8'));
+  const cell = ledger.entries[`teams::${CHAT_ID}::2026-05-25`];
+  assert.ok(cell);
+  assert.equal(cell.last_status, 'captured');
+  assert.equal(cell.items_pulled, 3);
+});
+
+test('empty chat returns no-activity', () => {
+  const res = runRunner('19:empty@thread.v2');
+  assert.equal(res.status, 0);
+  const r = JSON.parse(res.stdout.trim().split('\n').pop());
+  assert.equal(r.status, 'no-activity');
+  assert.equal(r.items_pulled, 0);
+  assert.deepEqual(r.files_written, []);
+});
+
+test('index.md preview strips HTML', async () => {
+  const r = JSON.parse(runRunner(CHAT_ID).stdout.trim().split('\n').pop());
+  const md = await fs.readFile(path.join(projectRoot, 'Evidence', 'ushak', 'teams', r.chat_hash, '2026-05-25', 'index.md'), 'utf8');
+  assert.match(md, /Status update/);
+  assert.doesNotMatch(md, /<p>/);
+});
+
+test('dry-run writes nothing', async () => {
+  const projectRoot2 = await fs.mkdtemp(path.join(os.tmpdir(), 'kushi-teams-dry-'));
+  await fs.mkdir(path.join(projectRoot2, 'Evidence', 'ushak'), { recursive: true });
+  await fs.writeFile(path.join(projectRoot2, 'integrations.yml'), YAML.stringify({}));
+  try {
+    const res = spawnSync(process.execPath, [RUNNER,
+      '--project', projectRoot2, '--alias', 'ushak',
+      '--entity', CHAT_ID, '--week', '2026-05-25', '--fixture', FIXTURE, '--dry-run',
+    ], { encoding: 'utf8' });
+    assert.equal(res.status, 0);
+    const r = JSON.parse(res.stdout.trim().split('\n').pop());
+    assert.deepEqual(r.files_written, []);
+  } finally { await fs.rm(projectRoot2, { recursive: true, force: true }); }
+});

package/plugin/runners/test/unit/runlog.test.mjs

@@ -45,7 +45,7 @@ test('writeRefreshReport writes timestamped markdown file', async () => {
     details: { sources: ['email'], count: 1 },
   });
   const content = await fs.readFile(r.path, 'utf8');
-  assert.match(content, /^# refresh —/);
+  assert.match(content, /^# Refresh Report —/);
   assert.match(content, /all good/);
   assert.match(content, /sources:/);
 });