chapterhouse 0.3.1 → 0.3.3

package/dist/squad/init.test.js

@@ -0,0 +1,351 @@
+/**
+ * src/squad/init.test.ts
+ *
+ * Tests for the Squad init scaffolding module.
+ *
+ * Coverage:
+ * - scaffoldSquad produces the expected .squad/ layout
+ * - isSquadInitialized correctly detects initialized/uninitialized dirs
+ * - Idempotence: scaffoldSquad returns null (does not clobber) on re-run
+ * - Dune universe character allocation
+ * - allocateCast uses the selected universe
+ * - resolveRoles clamps to valid presets
+ * - force flag overrides idempotence guard
+ */
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir as osTmpdir } from 'node:os';
+import test from 'node:test';
+import { scaffoldSquad, isSquadInitialized, allocateCast, resolveRoles, DUNE_CHARACTERS, UNIVERSE_CHARACTERS, DEFAULT_UNIVERSE, } from './init.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeTempDir() {
+    return mkdtempSync(join(osTmpdir(), 'ch-init-test-'));
+}
+function cleanup(dir) {
+    rmSync(dir, { recursive: true, force: true });
+}
+// ---------------------------------------------------------------------------
+// Unit tests — pure functions
+// ---------------------------------------------------------------------------
+test('DUNE_CHARACTERS has at least 5 entries', () => {
+    assert.ok(DUNE_CHARACTERS.length >= 5, `Expected ≥ 5 Dune characters, got ${DUNE_CHARACTERS.length}`);
+});
+test('UNIVERSE_CHARACTERS includes Dune', () => {
+    assert.ok('Dune' in UNIVERSE_CHARACTERS, 'UNIVERSE_CHARACTERS must include "Dune"');
+    assert.equal(UNIVERSE_CHARACTERS['Dune'], DUNE_CHARACTERS);
+});
+test('DEFAULT_UNIVERSE is Dune', () => {
+    assert.equal(DEFAULT_UNIVERSE, 'Dune');
+});
+test('resolveRoles(4) returns 4 roles', () => {
+    const roles = resolveRoles(4);
+    assert.equal(roles.length, 4);
+});
+test('resolveRoles(3) returns 3 roles', () => {
+    assert.equal(resolveRoles(3).length, 3);
+});
+test('resolveRoles(5) returns 5 roles', () => {
+    assert.equal(resolveRoles(5).length, 5);
+});
+test('resolveRoles clamps values below 3 to 3', () => {
+    assert.equal(resolveRoles(1).length, 3);
+});
+test('resolveRoles clamps values above 5 to 5', () => {
+    assert.equal(resolveRoles(10).length, 5);
+});
+test('allocateCast assigns Dune names in order', () => {
+    const roles = resolveRoles(4);
+    const cast = allocateCast(roles, 'Dune');
+    assert.equal(Object.keys(cast).length, 4);
+    // First role maps to first Dune character
+    const firstRoleSlug = roles[0].slug;
+    assert.equal(cast[firstRoleSlug], DUNE_CHARACTERS[0]);
+});
+test('allocateCast uses provided universe', () => {
+    const roles = resolveRoles(3);
+    const cast = allocateCast(roles, 'Firefly');
+    const firfly = UNIVERSE_CHARACTERS['Firefly'];
+    const firstRoleSlug = roles[0].slug;
+    assert.equal(cast[firstRoleSlug], firfly[0]);
+});
+test('allocateCast falls back to Dune for unknown universe', () => {
+    const roles = resolveRoles(3);
+    const cast = allocateCast(roles, 'UnknownUniverse');
+    const firstRoleSlug = roles[0].slug;
+    assert.equal(cast[firstRoleSlug], DUNE_CHARACTERS[0]);
+});
+// ---------------------------------------------------------------------------
+// isSquadInitialized
+// ---------------------------------------------------------------------------
+test('isSquadInitialized returns false for empty dir', () => {
+    const dir = makeTempDir();
+    try {
+        assert.equal(isSquadInitialized(dir), false);
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('isSquadInitialized returns false when team.md missing', () => {
+    const dir = makeTempDir();
+    try {
+        assert.equal(isSquadInitialized(dir), false);
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+// ---------------------------------------------------------------------------
+// scaffoldSquad integration
+// ---------------------------------------------------------------------------
+const BASE_CONFIG = {
+    projectName: 'TestApp',
+    stack: 'TypeScript, Node.js',
+    goal: 'A test application',
+    teamSize: 4,
+    universe: 'Dune',
+    humanName: 'Alice',
+};
+test('scaffoldSquad returns ScaffoldResult with 4 cast agents', () => {
+    const dir = makeTempDir();
+    try {
+        const result = scaffoldSquad(dir, BASE_CONFIG);
+        assert.ok(result !== null, 'scaffoldSquad should return a result');
+        assert.equal(result.agents.length, 4, 'Should cast 4 agents');
+        assert.equal(result.universe, 'Dune');
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates .squad directory', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        assert.ok(existsSync(join(dir, '.squad')), '.squad/ must exist');
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates team.md with ## Members section', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        const teamMd = readFileSync(join(dir, '.squad', 'team.md'), 'utf-8');
+        assert.ok(teamMd.includes('## Members'), 'team.md must contain ## Members');
+        assert.ok(teamMd.includes('Scribe'), 'team.md must list Scribe');
+        assert.ok(teamMd.includes('Ralph'), 'team.md must list Ralph');
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates team.md with project info', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        const teamMd = readFileSync(join(dir, '.squad', 'team.md'), 'utf-8');
+        assert.ok(teamMd.includes('TestApp'), 'team.md must contain project name');
+        assert.ok(teamMd.includes('Dune'), 'team.md must contain universe');
+        assert.ok(teamMd.includes('Alice'), 'team.md must contain human name');
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates routing.md', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        assert.ok(existsSync(join(dir, '.squad', 'routing.md')));
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates ceremonies.md', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        assert.ok(existsSync(join(dir, '.squad', 'ceremonies.md')));
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates decisions.md', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        assert.ok(existsSync(join(dir, '.squad', 'decisions.md')));
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates agent charter.md for each cast agent', () => {
+    const dir = makeTempDir();
+    try {
+        const result = scaffoldSquad(dir, BASE_CONFIG);
+        for (const agent of result.agents) {
+            const charterPath = join(dir, '.squad', 'agents', agent.slug, 'charter.md');
+            assert.ok(existsSync(charterPath), `charter.md missing for ${agent.slug}`);
+            const content = readFileSync(charterPath, 'utf-8');
+            assert.ok(content.includes(agent.castName), `charter should mention ${agent.castName}`);
+        }
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates agent history.md for each cast agent', () => {
+    const dir = makeTempDir();
+    try {
+        const result = scaffoldSquad(dir, BASE_CONFIG);
+        for (const agent of result.agents) {
+            const histPath = join(dir, '.squad', 'agents', agent.slug, 'history.md');
+            assert.ok(existsSync(histPath), `history.md missing for ${agent.slug}`);
+        }
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates scribe and ralph agent dirs', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        assert.ok(existsSync(join(dir, '.squad', 'agents', 'scribe', 'charter.md')));
+        assert.ok(existsSync(join(dir, '.squad', 'agents', 'ralph', 'charter.md')));
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates casting/policy.json', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        const policyPath = join(dir, '.squad', 'casting', 'policy.json');
+        assert.ok(existsSync(policyPath));
+        const policy = JSON.parse(readFileSync(policyPath, 'utf-8'));
+        assert.ok(Array.isArray(policy.allowlist_universes));
+        assert.ok(policy.allowlist_universes.includes('Dune'));
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates casting/registry.json with all agents', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        const reg = JSON.parse(readFileSync(join(dir, '.squad', 'casting', 'registry.json'), 'utf-8'));
+        assert.ok(reg.agents, 'registry must have agents key');
+        assert.ok('scribe' in reg.agents, 'scribe must be in registry');
+        assert.ok('ralph' in reg.agents, 'ralph must be in registry');
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates casting/history.json with assignment snapshot', () => {
+    const dir = makeTempDir();
+    try {
+        const result = scaffoldSquad(dir, BASE_CONFIG);
+        const hist = JSON.parse(readFileSync(join(dir, '.squad', 'casting', 'history.json'), 'utf-8'));
+        assert.ok(Array.isArray(hist.universe_usage_history));
+        assert.equal(hist.universe_usage_history[0].universe, 'Dune');
+        assert.ok(result.assignmentId in hist.assignment_cast_snapshots);
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates or updates .gitattributes', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        const ga = readFileSync(join(dir, '.gitattributes'), 'utf-8');
+        assert.ok(ga.includes('.squad/decisions.md merge=union'), '.gitattributes must include union merge for decisions.md');
+        assert.ok(ga.includes('.squad/agents/*/history.md merge=union'));
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad is idempotent — returns null on second call', () => {
+    const dir = makeTempDir();
+    try {
+        const first = scaffoldSquad(dir, BASE_CONFIG);
+        assert.ok(first !== null, 'first call should succeed');
+        const second = scaffoldSquad(dir, BASE_CONFIG);
+        assert.equal(second, null, 'second call should return null (idempotent)');
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad with force:true overwrites existing scaffold', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        const result = scaffoldSquad(dir, { ...BASE_CONFIG, projectName: 'Updated' }, { force: true });
+        assert.ok(result !== null, 'forced call should succeed');
+        const teamMd = readFileSync(join(dir, '.squad', 'team.md'), 'utf-8');
+        assert.ok(teamMd.includes('Updated'), 'team.md should reflect updated project name');
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('isSquadInitialized returns true after scaffoldSquad', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        assert.equal(isSquadInitialized(dir), true);
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad uses Dune names from the canonical pool', () => {
+    const dir = makeTempDir();
+    try {
+        const result = scaffoldSquad(dir, BASE_CONFIG);
+        for (const agent of result.agents) {
+            assert.ok(DUNE_CHARACTERS.includes(agent.castName), `${agent.castName} is not in the Dune character pool`);
+        }
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad uses Firefly names when universe is Firefly', () => {
+    const dir = makeTempDir();
+    try {
+        const result = scaffoldSquad(dir, { ...BASE_CONFIG, universe: 'Firefly' });
+        const fireflyPool = UNIVERSE_CHARACTERS['Firefly'];
+        for (const agent of result.agents) {
+            assert.ok(fireflyPool.includes(agent.castName), `${agent.castName} is not in the Firefly pool`);
+        }
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+test('scaffoldSquad creates decisions/inbox directory', () => {
+    const dir = makeTempDir();
+    try {
+        scaffoldSquad(dir, BASE_CONFIG);
+        assert.ok(existsSync(join(dir, '.squad', 'decisions', 'inbox')));
+    }
+    finally {
+        cleanup(dir);
+    }
+});
+//# sourceMappingURL=init.test.js.map

package/dist/squad/mirror.js

@@ -2,6 +2,8 @@ import { basename, join } from 'path';
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { readPage, writePage } from '../wiki/fs.js';
 import { ensureWikiStructure } from '../wiki/fs.js';
+import { childLogger } from '../util/logger.js';
+const log = childLogger('squad.mirror');
 /**
  * Returns the wiki-relative path for a project's squad decisions page.
  * e.g. "pages/projects/chapterhouse/decisions.md"
@@ -69,12 +71,12 @@ export async function syncDecisionsFileToWiki(projectRoot) {
         // Visibility check: warn if inbox has unmerged drops
         const inbox = await checkDecisionsInbox(projectRoot);
         if (inbox.count > 0) {
-            console.warn(`[squad] Project at ${projectRoot} has ${inbox.count} unmerged decision drops in inbox: ${inbox.files.join(', ')}. Run Scribe to merge.`);
+            log.warn({ projectRoot, count: inbox.count, files: inbox.files }, 'unmerged decision drops in inbox — run Scribe to merge');
         }
         return { entriesSynced, wikiPath };
     }
     catch (err) {
-        console.error('[squad] syncDecisionsFileToWiki failed (non-fatal):', err instanceof Error ? err.message : err);
+        log.error({ err: err instanceof Error ? err.message : err }, 'syncDecisionsFileToWiki failed (non-fatal)');
         return null;
     }
 }

package/dist/squad/mirror.scheduler.js

@@ -1,5 +1,7 @@
 import { getDb } from '../store/db.js';
 import { syncDecisionsFileToWiki } from './mirror.js';
+import { childLogger } from '../util/logger.js';
+const log = childLogger('squad.mirror-scheduler');
 export const DEFAULT_DECISIONS_SYNC_INTERVAL_MS = 300_000; // 5 minutes
 function readIntervalFromEnv() {
     const raw = process.env.CHAPTERHOUSE_DECISIONS_SYNC_INTERVAL_MS;
@@ -17,7 +19,7 @@ function defaultGetRegisteredProjectRoots() {
         return rows.map(r => r.project_root);
     }
     catch (err) {
-        console.error('[squad] DecisionsSyncScheduler: failed to query registered projects (non-fatal):', err instanceof Error ? err.message : err);
+        log.error({ err: err instanceof Error ? err.message : err }, 'failed to query registered projects (non-fatal)');
         return [];
     }
 }
@@ -38,12 +40,12 @@ export class DecisionsSyncScheduler {
     /** Start the periodic sync. No-op if intervalMs <= 0. */
     start() {
         if (this.intervalMs <= 0) {
-            console.log('[squad] DecisionsSyncScheduler: disabled (intervalMs <= 0)');
+            log.debug({ intervalMs: this.intervalMs }, 'disabled (intervalMs <= 0)');
             return;
         }
         if (this.handle !== undefined)
             return; // already running
-        console.log(`[squad] DecisionsSyncScheduler: starting, interval=${this.intervalMs}ms`);
+        log.info({ intervalMs: this.intervalMs }, 'starting');
         this.handle = this.setIntervalImpl(() => { void this.tick(); }, this.intervalMs);
         // Allow Node.js to exit even if the interval is still active
         this.handle?.unref?.();
@@ -53,24 +55,24 @@ export class DecisionsSyncScheduler {
         if (this.handle !== undefined) {
             this.clearIntervalImpl(this.handle);
             this.handle = undefined;
-            console.log('[squad] DecisionsSyncScheduler: stopped');
+            log.info('stopped');
         }
     }
     async tick() {
         const projects = this.getRegisteredProjectRoots();
         if (projects.length === 0)
             return;
-        console.log(`[squad] DecisionsSyncScheduler: syncing ${projects.length} project(s)`);
+        log.debug({ projects: projects.length }, 'syncing');
         for (const root of projects) {
             try {
                 const result = await this.syncFn(root);
                 if (result) {
-                    console.log(`[squad] DecisionsSyncScheduler: synced ${result.entriesSynced} entries for ${root}`);
+                    log.debug({ entriesSynced: result.entriesSynced, root }, 'synced');
                 }
             }
             catch (err) {
                 // syncDecisionsFileToWiki already swallows errors; belt-and-suspenders here
-                console.error(`[squad] DecisionsSyncScheduler: unexpected error for ${root}:`, err instanceof Error ? err.message : err);
+                log.error({ root, err: err instanceof Error ? err.message : err }, 'unexpected sync error (non-fatal)');
             }
         }
     }

package/dist/store/db.js

@@ -150,6 +150,24 @@ export function getDb() {
         if (!taskCols.some((c) => c.name === 'source')) {
             db.exec(`ALTER TABLE agent_tasks ADD COLUMN source TEXT NOT NULL DEFAULT 'adhoc'`);
         }
+        // agent_task_events: append-only per-task tool-call activity log for /workers streaming
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_task_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL REFERENCES agent_tasks(task_id) ON DELETE CASCADE,
+        seq INTEGER NOT NULL,
+        ts INTEGER NOT NULL,
+        kind TEXT NOT NULL CHECK(kind IN ('tool_start', 'tool_complete')),
+        tool_name TEXT,
+        summary TEXT
+      )
+    `);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_agent_task_events_task_id ON agent_task_events(task_id, seq)`);
+        // Migrate: add event_seq column to agent_tasks for monotonic event numbering
+        const taskColsNow = db.prepare(`PRAGMA table_info(agent_tasks)`).all();
+        if (!taskColsNow.some((c) => c.name === 'event_seq')) {
+            db.exec(`ALTER TABLE agent_tasks ADD COLUMN event_seq INTEGER NOT NULL DEFAULT 0`);
+        }
         // Migrate: add last_used_at column to project_squads (epoch ms, nullable)
         const projectCols = db.prepare(`PRAGMA table_info(project_squads)`).all();
         if (!projectCols.some((c) => c.name === 'last_used_at')) {
@@ -313,11 +331,46 @@ export function getSessionMessages(sessionKey, limit) {
         ts: r.ts,
     }));
 }
-// ---------------------------------------------------------------------------
-// SQLite memory functions removed — wiki is the single source of truth.
-// The memories table and FTS5 index are preserved in the schema for safety
-// (existing data is not deleted), but no code reads or writes to them.
-// ---------------------------------------------------------------------------
+/**
+ * Append one event to agent_task_events and return the new event.
+ * Uses a transaction so seq is monotonically incremented.
+ * Non-fatal: silently ignores DB errors (task may not exist yet due to race).
+ */
+export function appendTaskEvent(taskId, kind, toolName, summary) {
+    const db = getDb();
+    try {
+        return db.transaction(() => {
+            db.prepare(`UPDATE agent_tasks SET event_seq = event_seq + 1 WHERE task_id = ?`).run(taskId);
+            const row = db.prepare(`SELECT event_seq FROM agent_tasks WHERE task_id = ?`).get(taskId);
+            if (!row)
+                return undefined;
+            const seq = row.event_seq;
+            const ts = Date.now();
+            const info = db.prepare(`INSERT INTO agent_task_events (task_id, seq, ts, kind, tool_name, summary) VALUES (?, ?, ?, ?, ?, ?)`).run(taskId, seq, ts, kind, toolName, summary);
+            return { id: Number(info.lastInsertRowid), taskId, seq, ts, kind, toolName, summary };
+        })();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Return all events for a task ordered by seq ascending.
+ */
+export function getTaskEvents(taskId, afterSeq = 0) {
+    const db = getDb();
+    const rows = db.prepare(`SELECT id, task_id, seq, ts, kind, tool_name, summary
+     FROM agent_task_events WHERE task_id = ? AND seq > ? ORDER BY seq ASC`).all(taskId, afterSeq);
+    return rows.map((r) => ({
+        id: r.id,
+        taskId: r.task_id,
+        seq: r.seq,
+        ts: r.ts,
+        kind: r.kind,
+        toolName: r.tool_name,
+        summary: r.summary,
+    }));
+}
 export function bumpProjectLastUsed(projectRoot) {
     getDb()
         .prepare(`UPDATE project_squads SET last_used_at = ? WHERE project_root = ?`)

package/dist/store/db.test.js

@@ -211,4 +211,73 @@ test("bumpProjectLastUsed is a no-op for unknown project_root (no throw)", async
         dbModule.closeDb();
     }
 });
+// ---------------------------------------------------------------------------
+// #86: agent_task_events — appendTaskEvent and getTaskEvents
+// ---------------------------------------------------------------------------
+test("#86: appendTaskEvent inserts a row and getTaskEvents returns it ordered by seq", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        // Insert a parent task row
+        db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES ('task-sse-001', 'kaylee', 'Fix streaming', 'running')`).run();
+        const ev1 = dbModule.appendTaskEvent("task-sse-001", "tool_start", "bash", "npm run build");
+        assert.ok(ev1, "appendTaskEvent must return the inserted event");
+        assert.equal(ev1.kind, "tool_start");
+        assert.equal(ev1.toolName, "bash");
+        assert.equal(ev1.summary, "npm run build");
+        assert.equal(ev1.seq, 1);
+        const ev2 = dbModule.appendTaskEvent("task-sse-001", "tool_complete", null, "ok");
+        assert.ok(ev2, "second appendTaskEvent must return a second event");
+        assert.equal(ev2.seq, 2, "seq must be monotonically incremented");
+        assert.equal(ev2.kind, "tool_complete");
+        const events = dbModule.getTaskEvents("task-sse-001");
+        assert.equal(events.length, 2, "getTaskEvents must return 2 events");
+        assert.equal(events[0].seq, 1);
+        assert.equal(events[1].seq, 2);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#86: getTaskEvents with afterSeq filters earlier events", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES ('task-sse-002', 'wash', 'UI fix', 'running')`).run();
+        dbModule.appendTaskEvent("task-sse-002", "tool_start", "view", "/some/file");
+        dbModule.appendTaskEvent("task-sse-002", "tool_complete", null, "ok");
+        dbModule.appendTaskEvent("task-sse-002", "tool_start", "bash", "git push");
+        const all = dbModule.getTaskEvents("task-sse-002");
+        assert.equal(all.length, 3, "all 3 events expected");
+        const afterFirst = dbModule.getTaskEvents("task-sse-002", 1);
+        assert.equal(afterFirst.length, 2, "afterSeq=1 must return only events with seq > 1");
+        assert.equal(afterFirst[0].seq, 2);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#86: appendTaskEvent returns undefined (non-fatal) for unknown task_id", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        dbModule.getDb();
+        const result = dbModule.appendTaskEvent("no-such-task", "tool_start", "bash", "echo hi");
+        assert.equal(result, undefined, "appendTaskEvent must return undefined for unknown task_id");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#86: agent_task_events table exists in schema after getDb()", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        const tables = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table'`).all();
+        const tableNames = new Set(tables.map((r) => r.name));
+        assert.ok(tableNames.has("agent_task_events"), "agent_task_events table must exist");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 //# sourceMappingURL=db.test.js.map

package/dist/version.js

@@ -0,0 +1,7 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+export const CHAPTERHOUSE_VERSION = pkg.version;
+//# sourceMappingURL=version.js.map

package/dist/wiki/team-sync.js

@@ -4,6 +4,8 @@ import { config } from "../config.js";
 import { WIKI_DIR } from "../paths.js";
 import { assertPagePath, readPage, writePage, writeFileAtomic } from "./fs.js";
 import { addToIndex, buildIndexEntryForPage } from "./index-manager.js";
+import { childLogger } from "../util/logger.js";
+const log = childLogger("team-sync");
 export class TeamWikiSync {
     teamChapterhouseUrl;
     teamChapterhouseToken;
@@ -28,7 +30,7 @@ export class TeamWikiSync {
         this.cacheRoot = join(this.wikiDir, ".team-cache");
         this.manifestPath = join(this.cacheRoot, "manifest.json");
         this.fetchImpl = options.fetchImpl ?? fetch;
-        this.warn = options.warn ?? ((message) => console.warn(message));
+        this.warn = options.warn ?? ((message) => log.warn(message));
         this.now = options.now ?? (() => new Date());
     }
     isEnabled() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"
@@ -22,12 +22,12 @@
     "dev:server": "tsx --watch src/daemon.ts",
     "dev:web": "npm --prefix web run dev",
     "dev": "tsx --watch src/daemon.ts",
+    "lint:md": "markdownlint-cli2 'README.md' 'CHANGELOG.md' 'docs/**/*.md' '.github/**/*.md'",
     "release:check": "if [ -n \"$(git status --porcelain)\" ]; then echo '❌ Working tree is not clean. Stage or stash changes before running npm version.'; git status --short; exit 1; fi",
     "preversion": "npm run release:check",
     "prepare": "husky",
     "test": "npm run clean && npm run build:server && node --experimental-test-module-mocks --import ./dist/test/setup-env.js --test 'dist/**/*.test.js'",
-    "prepublishOnly": "npm run build",
-    "prepare": "husky"
+    "prepublishOnly": "npm run build"
   },
   "engines": {
     "node": ">=22.5.0"
@@ -74,6 +74,7 @@
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^25.6.0",
     "husky": "^9.1.7",
+    "markdownlint-cli2": "^0.22.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }