chapterhouse 0.9.1 → 0.10.0

package/dist/store/repositories/memory.js

@@ -0,0 +1,281 @@
+export const MEMORY_SCOPE_SEEDS = [
+    {
+        slug: "global",
+        title: "Global",
+        description: "Cross-cutting facts that apply everywhere",
+        keywords: ["everywhere", "general"],
+    },
+    {
+        slug: "chapterhouse",
+        title: "Chapterhouse",
+        description: "Chapterhouse codebase, conventions, decisions, gotchas",
+        keywords: ["chapterhouse", "this repo", "this project", "the daemon"],
+    },
+];
+const CHAPTERHOUSE_WIKI_INDEX_SOURCE = "wiki:pages/projects/chapterhouse/index.md";
+const CHAPTERHOUSE_WIKI_HOT_TIER_REASON = "P6 PR1 wiki migration hot-tier candidate";
+const CHAPTERHOUSE_WIKI_DECISION_HOT_TIER_REASON = "P6 PR2 wiki migration hot-tier candidate";
+const CHAPTERHOUSE_PROJECT_ENTITY_SEED = {
+    name: "Chapterhouse",
+    kind: "project",
+    summary: "Always-on team-level AI assistant daemon that orchestrates specialist subagents and maintains a persistent knowledge wiki.",
+};
+const CHAPTERHOUSE_WIKI_OBSERVATION_SEEDS = [
+    {
+        content: "Chapterhouse architecture: Node.js daemon, web UI, per-conversation sessions, specialist agents, modular skills, MCP servers, local markdown wiki, project-rules prompt injection, and background workers with SSE event streaming.",
+        tier: "warm",
+    },
+    {
+        content: "Chapterhouse source lives at bketelsen/chapterhouse with local checkout ~/projects/chapterhouse; engineering plans are in docs/plans/ and product specs are in docs/prd/.",
+        tier: "warm",
+    },
+    {
+        content: "Background agent completions arrive as automatic system notifications; after spawning a background agent, end the turn and wait instead of polling read_agent, sleeping, or re-checking list_agents.",
+        tier: "hot",
+    },
+    {
+        content: "Use the default Chapterhouse chat for research and general questions; move code changes against a specific project into that project's chat session.",
+        tier: "warm",
+    },
+    {
+        content: "Squad manages Chapterhouse's own development workflow.",
+        tier: "warm",
+    },
+    {
+        content: "Chapterhouse uses frequent semver patch releases published to npm via the Publish to npm GitHub Actions workflow on tag push; never publish manually.",
+        tier: "hot",
+    },
+    {
+        content: "Agent-memory P1 shipped on 2026-05-13 as Chapterhouse v0.4.0 across 7 PRs: #215 through #225.",
+        tier: "warm",
+    },
+    {
+        content: "The v0.3.2 per-session orchestrator was confirmed under real concurrent load on 2026-05-08, enabling concurrent sessions without cross-blocking.",
+        tier: "hot",
+    },
+];
+const CHAPTERHOUSE_WIKI_DECISION_SEEDS = [
+    {
+        title: "Standardize API validation and JSON errors around `src/api/errors.ts`",
+        rationale: "Keep one 400/403/404/500 contract across routes instead of ad hoc parsing and responses; `src/api/errors.ts`, `src/api/server.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Run in standalone mode when neither Entra nor an API token is configured",
+        rationale: "Disable auth checks and team sync together so local single-user startup still works; `src/config.ts`, `src/api/auth.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Use bearer auth for SSE and serialize wiki writes",
+        rationale: "`/stream` no longer accepts query tokens, and wiki mutations go through `withWikiWrite()`; `web/src/stream.ts`, `src/wiki/lock.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Default production to least privilege",
+        rationale: "Run as a non-root container, validate env early, and keep CORS and security headers tight in production; `Dockerfile`, `deploy/deploy.sh`, `src/config.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Keep chat state session-scoped by `sessionKey`",
+        rationale: "Conversation history, SSE routing, and frontend buffers stay isolated per session instead of bleeding across chats; `src/store/db.ts`, `web/src/store.ts`.",
+        decidedAt: "2026-05-07",
+        tier: "warm",
+    },
+    {
+        title: "Preserve the 3-layer daemon timing contract",
+        rationale: "Orchestrator timeout must stay below daemon shutdown grace, which must stay below systemd `TimeoutStopSec`; `README.md`, `src/daemon.ts`, `src/daemon-install.ts`.",
+        decidedAt: "2026-05-08",
+        tier: "hot",
+    },
+    {
+        title: "Start WorkIQ MCP auto-install at daemon startup",
+        rationale: "Write the MCP entry before the SDK client starts so new sessions see it immediately; issue #33, PR #78.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Use per-session orchestrators instead of a global queue",
+        rationale: "`SessionManager` and `SessionRegistry` keep independent queues so one chat cannot block another; issue #74, `src/copilot/session-manager.ts`.",
+        decidedAt: "2026-05-08",
+        tier: "hot",
+    },
+    {
+        title: "Make wiki path hierarchy the primary navigation model",
+        rationale: "`path` drives the tree and breadcrumbs, while `section` remains secondary metadata; `web/src/wiki/index.ts`, `web/src/routes/Wiki.tsx`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Route wiki breadcrumbs through `selected` state",
+        rationale: "Breadcrumb clicks use the same route-state flow as the sidebar so navigation stays predictable; `web/src/components/wiki/WikiBreadcrumbs.tsx`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Derive wiki page scope from configured team paths",
+        rationale: "The API returns `scope` and the UI shows personal/team indicators without adding new persisted metadata; `src/api/server.ts`, `web/src/components/wiki/WikiScopeIndicator.tsx`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Sort sidebar recents by actual project activity",
+        rationale: "`last_used_at` replaces registration time so recent projects reflect chat usage rather than signup order; issue #26, PR #30.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Preload `CHAPTERHOUSE_DISABLE_DOTENV=1` for Node tests",
+        rationale: "Tests must not inherit developer-local env files before config singletons initialize; `src/test/setup-env.ts`, `src/config.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Test API routes through a spawned server process",
+        rationale: "Real HTTP coverage catches auth, config preload, error middleware, and wiki I/O behavior that an unexported in-process app would miss; `src/api/server.test.ts`.",
+        decidedAt: "2026-05-06",
+        tier: "warm",
+    },
+    {
+        title: "Centralize frontend API Zod schemas in `web/src/api-schemas.ts`",
+        rationale: "Keep one audit surface for the browser-to-daemon contract and require validated JSON reads; issue #40, PR #63.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Make frontend test isolation an infrastructure concern",
+        rationale: "Vitest globals, `test-setup.ts`, and MSW own cleanup so tests do not hand-roll it; issue #43, PR #62.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Clean `dist/` before `npm test`",
+        rationale: "Remove stale compiled artifacts so deleted tests cannot linger in the Node test run; `package.json`.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Adopt `pino` as the backend logger",
+        rationale: "Use `childLogger()` everywhere and keep chat content at `debug`, not `info`; issue #13, PR #28.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Keep daemon control as a thin CLI over `src/daemon-install.ts`",
+        rationale: "Generate service artifacts in one module and support launchd and systemd user services without a separate control layer; issue #14, PR #24.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Default publish workflows to Node 24+",
+        rationale: "npm Trusted Publishing depends on npm 11.5.1+, which Node 22 does not provide; `.github/workflows/npm-publish.yml`.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Make `chapterhouse update` registry-aware",
+        rationale: "Registry installs update via npm, while legacy git installs keep the older pull-and-rebuild path; issue #31, PR #32.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Keep markdownlint pragmatic rather than maximalist",
+        rationale: "Disable MD060, ignore `.github/agents/**`, and suppress MD041 only where template UX requires it; `.markdownlint-cli2.jsonc`.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Enforce issue-closing references in feature and fix PRs",
+        rationale: "PR bodies must include `Closes #N`, `Fixes #N`, or `Resolves #N`, with a documented `no-issue` bypass; PR #60, `.github/workflows/lint-pr-closes.yml`.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+    {
+        title: "Use Conventional Commits for commits and PR titles",
+        rationale: "Keep repo history machine-readable and enforce it with commitlint, husky, and PR-title linting; `commitlint.config.js`, `.github/workflows/lint-pr-title.yml`.",
+        decidedAt: "2026-05-08",
+        tier: "warm",
+    },
+];
+export function seedChapterhouseWikiIndexMemory(database) {
+    database.transaction(() => {
+        const chapterhouseScope = database.prepare(`
+      SELECT id
+      FROM mem_scopes
+      WHERE slug = 'chapterhouse'
+    `).get();
+        if (!chapterhouseScope) {
+            throw new Error("Cannot seed Chapterhouse wiki memory because scope 'chapterhouse' does not exist.");
+        }
+        database.prepare(`
+      INSERT INTO mem_entities (scope_id, kind, name, summary, tier, confidence, created_at, updated_at)
+      VALUES (?, ?, ?, ?, 'warm', 1.0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+      ON CONFLICT(scope_id, kind, name) DO UPDATE SET
+        summary = excluded.summary,
+        updated_at = CURRENT_TIMESTAMP
+    `).run(chapterhouseScope.id, CHAPTERHOUSE_PROJECT_ENTITY_SEED.kind, CHAPTERHOUSE_PROJECT_ENTITY_SEED.name, CHAPTERHOUSE_PROJECT_ENTITY_SEED.summary);
+        const chapterhouseEntity = database.prepare(`
+      SELECT id
+      FROM mem_entities
+      WHERE scope_id = ? AND kind = ? AND name = ?
+    `).get(chapterhouseScope.id, CHAPTERHOUSE_PROJECT_ENTITY_SEED.kind, CHAPTERHOUSE_PROJECT_ENTITY_SEED.name);
+        if (!chapterhouseEntity) {
+            throw new Error("Cannot seed Chapterhouse wiki observations because the Chapterhouse entity was not created.");
+        }
+        const insertObservation = database.prepare(`
+      INSERT INTO mem_observations (
+        scope_id, entity_id, content, source, tier, confidence, tier_pinned_at, tier_reason, created_at
+      )
+      SELECT ?, ?, ?, ?, ?, 1.0,
+        CASE WHEN ? = 'hot' THEN CURRENT_TIMESTAMP ELSE NULL END,
+        CASE WHEN ? = 'hot' THEN ? ELSE NULL END,
+        CURRENT_TIMESTAMP
+      WHERE NOT EXISTS (
+        SELECT 1 FROM mem_observations WHERE scope_id = ? AND content = ?
+      )
+    `);
+        const updateObservation = database.prepare(`
+      UPDATE mem_observations
+      SET entity_id = ?,
+        source = ?,
+        tier = CASE WHEN ? = 'hot' THEN 'hot' ELSE tier END,
+        tier_pinned_at = CASE WHEN ? = 'hot' THEN COALESCE(tier_pinned_at, CURRENT_TIMESTAMP) ELSE tier_pinned_at END,
+        tier_reason = CASE WHEN ? = 'hot' THEN ? ELSE tier_reason END
+      WHERE scope_id = ? AND content = ?
+    `);
+        for (const observation of CHAPTERHOUSE_WIKI_OBSERVATION_SEEDS) {
+            insertObservation.run(chapterhouseScope.id, chapterhouseEntity.id, observation.content, CHAPTERHOUSE_WIKI_INDEX_SOURCE, observation.tier, observation.tier, observation.tier, CHAPTERHOUSE_WIKI_HOT_TIER_REASON, chapterhouseScope.id, observation.content);
+            updateObservation.run(chapterhouseEntity.id, CHAPTERHOUSE_WIKI_INDEX_SOURCE, observation.tier, observation.tier, observation.tier, CHAPTERHOUSE_WIKI_HOT_TIER_REASON, chapterhouseScope.id, observation.content);
+        }
+        const insertDecision = database.prepare(`
+      INSERT INTO mem_decisions (
+        scope_id, entity_id, title, rationale, decided_at, tier, tier_pinned_at, tier_reason, created_at
+      )
+      SELECT ?, ?, ?, ?, ?, ?,
+        CASE WHEN ? = 'hot' THEN CURRENT_TIMESTAMP ELSE NULL END,
+        CASE WHEN ? = 'hot' THEN ? ELSE NULL END,
+        CURRENT_TIMESTAMP
+      WHERE NOT EXISTS (
+        SELECT 1 FROM mem_decisions WHERE scope_id = ? AND title = ?
+      )
+    `);
+        const updateDecision = database.prepare(`
+      UPDATE mem_decisions
+      SET entity_id = ?,
+        rationale = ?,
+        decided_at = ?,
+        tier = ?,
+        tier_pinned_at = CASE WHEN ? = 'hot' THEN COALESCE(tier_pinned_at, CURRENT_TIMESTAMP) ELSE NULL END,
+        tier_reason = CASE WHEN ? = 'hot' THEN ? ELSE NULL END
+      WHERE scope_id = ? AND title = ?
+    `);
+        for (const decision of CHAPTERHOUSE_WIKI_DECISION_SEEDS) {
+            insertDecision.run(chapterhouseScope.id, chapterhouseEntity.id, decision.title, decision.rationale, decision.decidedAt, decision.tier, decision.tier, decision.tier, CHAPTERHOUSE_WIKI_DECISION_HOT_TIER_REASON, chapterhouseScope.id, decision.title);
+            updateDecision.run(chapterhouseEntity.id, decision.rationale, decision.decidedAt, decision.tier, decision.tier, decision.tier, CHAPTERHOUSE_WIKI_DECISION_HOT_TIER_REASON, chapterhouseScope.id, decision.title);
+        }
+    })();
+}
+//# sourceMappingURL=memory.js.map

package/dist/store/repositories/okr.js

@@ -0,0 +1,3 @@
+export {};
+// OKR/ADO persistence currently uses wiki-backed modules; no store-level OKR repository functions are defined yet.
+//# sourceMappingURL=okr.js.map

package/dist/store/repositories/projects.js

@@ -0,0 +1,5 @@
+import { getDb } from "../connection.js";
+export function touchProjectsRepository() {
+    getDb().prepare("SELECT 1").get();
+}
+//# sourceMappingURL=projects.js.map

package/dist/store/repositories/sessions.js

@@ -0,0 +1,284 @@
+import { getCurrentRunId, getDb } from "../connection.js";
+let logInsertCount = 0;
+const MAX_CONVERSATION_CONTENT_LENGTH = 10_000;
+export function resetSessionRepositoryForTests() {
+    logInsertCount = 0;
+}
+export function getState(key) {
+    const db = getDb();
+    const row = db.prepare(`SELECT value FROM max_state WHERE key = ?`).get(key);
+    return row?.value;
+}
+export function setState(key, value) {
+    const db = getDb();
+    db.prepare(`INSERT OR REPLACE INTO max_state (key, value) VALUES (?, ?)`).run(key, value);
+}
+/** Remove a key from persistent state. */
+export function deleteState(key) {
+    const db = getDb();
+    db.prepare(`DELETE FROM max_state WHERE key = ?`).run(key);
+}
+/** Log a conversation turn (user, assistant, or system). */
+export function logConversation(role, content, source, sessionKey = "default", metadata) {
+    const db = getDb();
+    db.prepare(`INSERT INTO conversation_log (role, content, source, session_key, turn_id, agent_slug, agent_display_name, run_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(role, content.slice(0, MAX_CONVERSATION_CONTENT_LENGTH), source, sessionKey, metadata?.turnId ?? null, metadata?.agentSlug ?? null, metadata?.agentDisplayName ?? null, getCurrentRunId());
+    // Keep last 1000 entries to support context recovery after session loss
+    logInsertCount++;
+    if (logInsertCount % 50 === 0) {
+        db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 1000)`).run();
+    }
+}
+/** Retrieve a stored Copilot session by key. */
+export function getCopilotSession(sessionKey) {
+    const db = getDb();
+    const row = db
+        .prepare(`SELECT copilot_session_id, model FROM copilot_sessions WHERE session_key = ?`)
+        .get(sessionKey);
+    if (!row)
+        return undefined;
+    return { copilotSessionId: row.copilot_session_id, model: row.model ?? undefined };
+}
+/** Insert or update a Copilot session record. */
+export function upsertCopilotSession(sessionKey, mode, copilotSessionId, projectRoot, model) {
+    const db = getDb();
+    db.prepare(`INSERT INTO copilot_sessions (session_key, mode, project_root, copilot_session_id, model, updated_at)
+     VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(session_key) DO UPDATE SET
+       copilot_session_id = excluded.copilot_session_id,
+       model              = excluded.model,
+       project_root       = excluded.project_root,
+       updated_at         = CURRENT_TIMESTAMP`).run(sessionKey, mode, projectRoot ?? null, copilotSessionId, model ?? null);
+}
+/** Delete a stored Copilot session by key. */
+export function deleteCopilotSession(sessionKey) {
+    getDb().prepare(`DELETE FROM copilot_sessions WHERE session_key = ?`).run(sessionKey);
+}
+/**
+ * Return the session_key stored against a task, or 'default' if the column
+ * doesn't exist yet (Kaylee will add it in a follow-on phase).
+ */
+export function getTaskSessionKey(taskId) {
+    const db = getDb();
+    try {
+        const row = db
+            .prepare(`SELECT session_key FROM agent_tasks WHERE task_id = ?`)
+            .get(taskId);
+        return row?.session_key ?? "default";
+    }
+    catch {
+        return "default";
+    }
+}
+/**
+ * Return whether a batch of agent tasks has fully reached terminal completion.
+ *
+ * `completed` and `error` are terminal. Missing rows are treated as not-ready
+ * so callers do not open downstream barriers (for example, a Scribe merge pass)
+ * until every expected task has recorded a terminal state.
+ */
+export function getTaskBarrierStatus(taskIds) {
+    const orderedTaskIds = Array.from(new Set(taskIds.filter((taskId) => taskId.trim().length > 0)));
+    if (orderedTaskIds.length === 0) {
+        return {
+            ready: true,
+            pendingTaskIds: [],
+            missingTaskIds: [],
+            statuses: [],
+        };
+    }
+    const db = getDb();
+    const placeholders = orderedTaskIds.map(() => "?").join(", ");
+    const rows = db.prepare(`SELECT task_id, status FROM agent_tasks WHERE task_id IN (${placeholders})`).all(...orderedTaskIds);
+    const statusByTaskId = new Map(rows.map((row) => [row.task_id, row.status ?? "missing"]));
+    const statuses = orderedTaskIds.map((taskId) => ({
+        taskId,
+        status: statusByTaskId.get(taskId) ?? "missing",
+    }));
+    const missingTaskIds = statuses.filter((entry) => entry.status === "missing").map((entry) => entry.taskId);
+    const pendingTaskIds = statuses
+        .filter((entry) => entry.status !== "completed" && entry.status !== "error")
+        .map((entry) => entry.taskId);
+    return {
+        ready: pendingTaskIds.length === 0,
+        pendingTaskIds,
+        missingTaskIds,
+        statuses,
+    };
+}
+/**
+ * Poll `getTaskBarrierStatus` until all tasks are terminal or the timeout
+ * is reached.
+ *
+ * On VS Code, all subagents in a single coordinator turn run concurrently,
+ * so Scribe cannot rely on siblings being complete at the instant it starts.
+ * This function lets Scribe (or any downstream pass) wait until every
+ * sibling has written its `.squad/decisions/inbox/` file and reached a
+ * terminal state before proceeding with the merge.
+ *
+ * Returns the last observed `TaskBarrierStatus`. Callers must check
+ * `.ready` — a `false` result means the timeout was reached with at least
+ * one task still pending.
+ */
+export async function pollTaskBarrierStatus(taskIds, options) {
+    const intervalMs = options?.intervalMs ?? 500;
+    const timeoutMs = options?.timeoutMs ?? 30_000;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        const status = getTaskBarrierStatus(taskIds);
+        if (status.ready)
+            return status;
+        if (Date.now() >= deadline)
+            return status;
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}
+/**
+ * Get recent conversation history formatted for injection into system message.
+ *
+ * When `sessionKey` is provided, only rows belonging to that session are
+ * returned — useful for per-session isolation that must not bleed context
+ * from other sessions. When omitted, rows from all sessions are returned
+ * (legacy behavior for callers that don't care about session isolation).
+ */
+export function getRecentConversation(limit, sessionKey) {
+    const db = getDb();
+    const effectiveLimit = limit ?? 20;
+    const rows = sessionKey
+        ? db.prepare(`SELECT role, content, source, ts FROM conversation_log WHERE session_key = ? ORDER BY id DESC LIMIT ?`).all(sessionKey, effectiveLimit)
+        : db.prepare(`SELECT role, content, source, ts FROM conversation_log ORDER BY id DESC LIMIT ?`).all(effectiveLimit);
+    if (rows.length === 0)
+        return "";
+    // Reverse so oldest is first (chronological order)
+    rows.reverse();
+    return rows.map((r) => {
+        const tag = r.role === "user" ? `[${r.source}] User`
+            : r.role === "system" ? `[${r.source}] System`
+                : r.role === "agent_completion" ? `[${r.source}] Agent completion`
+                    : "Chapterhouse";
+        // Truncate long messages to keep context manageable
+        const content = r.content.length > 1500 ? r.content.slice(0, 1500) + "…" : r.content;
+        return `${tag}: ${content}`;
+    }).join("\n\n");
+}
+const MAX_SESSION_MESSAGES_LIMIT = 500;
+const DEFAULT_SESSION_MESSAGES_LIMIT = 100;
+/**
+ * Normalize a SQLite CURRENT_TIMESTAMP string to a proper ISO-8601 UTC string.
+ *
+ * SQLite stores CURRENT_TIMESTAMP as "YYYY-MM-DD HH:MM:SS" — no timezone
+ * marker, space separator. Browsers that receive this bare string may parse it
+ * as *local* time instead of UTC, shifting every displayed timestamp by the
+ * user's UTC offset. This helper appends the `Z` suffix (and replaces the space
+ * separator with `T`) so that `new Date(ts)` always parses as UTC.
+ *
+ * - Already-ISO strings (containing `T`) are returned unchanged (idempotent).
+ * - Strings with a `T` but no `Z` are left as-is; they are already ISO format
+ *   and the caller is responsible for any timezone semantics (we do not blindly
+ *   append `Z` and risk double-shifting a value that might already be local).
+ * - Falsy / empty input is returned as an empty string rather than throwing.
+ */
+export function normalizeSqliteTsToIso(ts) {
+    if (!ts)
+        return "";
+    if (ts.includes("T"))
+        return ts;
+    return ts.replace(" ", "T") + "Z";
+}
+/**
+ * Return conversation_log rows for a specific session as structured JSON,
+ * suitable for seeding the frontend Zustand store on mount.
+ *
+ * Unlike `getRecentConversation()`, this returns structured objects (not a
+ * formatted string) and omits internal system messages. Synthetic background
+ * completion notices are included and mapped to assistant-style turns so reload
+ * matches the live chat rendering path.
+ */
+export function getSessionMessages(sessionKey, limit, options = {}) {
+    const db = getDb();
+    const effectiveLimit = Math.min(limit ?? DEFAULT_SESSION_MESSAGES_LIMIT, MAX_SESSION_MESSAGES_LIMIT);
+    const includeHistorical = options.includeHistorical ?? false;
+    const runId = options.runId ?? getCurrentRunId();
+    const rows = includeHistorical
+        ? db
+            .prepare(`SELECT id, role, content, ts, turn_id, agent_slug, agent_display_name FROM conversation_log
+         WHERE session_key = ? AND role IN ('user', 'assistant', 'agent_completion')
+         ORDER BY id DESC LIMIT ?`)
+            .all(sessionKey, effectiveLimit)
+        : db
+            .prepare(`SELECT id, role, content, ts, turn_id, agent_slug, agent_display_name FROM conversation_log
+         WHERE session_key = ? AND run_id = ? AND role IN ('user', 'assistant', 'agent_completion')
+         ORDER BY id DESC LIMIT ?`)
+            .all(sessionKey, runId, effectiveLimit);
+    // Reverse so oldest is first (chronological order for the UI)
+    rows.reverse();
+    return rows.map((r) => {
+        const message = {
+            id: r.id,
+            role: r.role === "agent_completion" ? "assistant" : r.role,
+            content: r.content,
+            ts: normalizeSqliteTsToIso(r.ts),
+            turn_id: r.turn_id,
+        };
+        if (r.turn_id)
+            message.turnId = r.turn_id;
+        if (r.agent_slug)
+            message.agentSlug = r.agent_slug;
+        if (r.agent_display_name)
+            message.agentDisplayName = r.agent_display_name;
+        return message;
+    });
+}
+/**
+ * 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, text = null, status = null) {
+    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, text, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(taskId, seq, ts, kind, toolName, summary, text, status);
+            return { id: Number(info.lastInsertRowid), taskId, seq, ts, kind, toolName, summary, text, status };
+        })();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function appendTaskOutputDeltaEvent(taskId, text) {
+    return appendTaskEvent(taskId, "output_delta", null, null, text, null);
+}
+export function appendTaskStatusEvent(taskId, status, summary = null) {
+    return appendTaskEvent(taskId, "task_status", null, summary, null, status);
+}
+export function updateTaskResult(taskId, status, result) {
+    const db = getDb();
+    db.prepare(`UPDATE agent_tasks SET status = ?, result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(status, result ? result.slice(0, 10000) : null, taskId);
+}
+/**
+ * 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, text, status
+     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,
+        text: r.text,
+        status: r.status,
+    }));
+}
+//# sourceMappingURL=sessions.js.map

package/dist/store/repositories/wiki.js

@@ -0,0 +1,60 @@
+import { ensureWikiStructure, listPages, readPage } from "../../wiki/fs.js";
+import { parseWikiFrontmatter } from "../../wiki/frontmatter.js";
+const ACTION_LOG_PAGE_RE = /^pages\/_meta\/log(?:-\d{4})?\.md$/;
+const LEGACY_INDEX_PAGE = "pages/index.md";
+function isIgnoredWikiIndexPage(path) {
+    return path === LEGACY_INDEX_PAGE || ACTION_LOG_PAGE_RE.test(path);
+}
+function wikiBasenameTitle(path) {
+    const segs = path.split("/").filter(Boolean);
+    const file = segs[segs.length - 1] || path;
+    const base = file.replace(/\.md$/, "");
+    const titleBase = base === "index" && segs.length >= 2 ? segs[segs.length - 2] : base;
+    return titleBase.split(/[-_]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function summarizeWikiBody(body) {
+    for (const raw of body.split("\n")) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#") || line.startsWith("<!--")) {
+            continue;
+        }
+        const summary = line.replace(/^[-*]\s+/, "").replace(/_\(\d{4}-\d{2}-\d{2}\)_$/, "").trim();
+        if (summary) {
+            return summary.length > 160 ? `${summary.slice(0, 157)}…` : summary;
+        }
+    }
+    return "";
+}
+export function seedWikiPagesFromDisk(database) {
+    ensureWikiStructure();
+    const pages = listPages().filter((page) => !isIgnoredWikiIndexPage(page));
+    if (pages.length === 0) {
+        return;
+    }
+    const wikiPageCount = database.prepare(`SELECT COUNT(*) AS count FROM wiki_pages`).get().count;
+    if (wikiPageCount > 0) {
+        return;
+    }
+    const upsert = database.prepare(`
+    INSERT INTO wiki_pages (path, title, entity_type, tags, summary, last_updated)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(path) DO UPDATE SET
+      title = excluded.title,
+      entity_type = excluded.entity_type,
+      tags = excluded.tags,
+      summary = excluded.summary,
+      last_updated = excluded.last_updated,
+      version = wiki_pages.version + 1
+  `);
+    for (const page of pages) {
+        const content = readPage(page);
+        if (!content) {
+            continue;
+        }
+        const { parsed: fm, body } = parseWikiFrontmatter(content);
+        const summary = fm.summary?.trim() || summarizeWikiBody(body) || fm.title || wikiBasenameTitle(page);
+        const entityType = fm.metadata?.["entity_type"] ?? null;
+        upsert.run(page, fm.title ?? wikiBasenameTitle(page), entityType, JSON.stringify(fm.tags ?? []), summary, fm.updated ?? new Date().toISOString());
+    }
+}
+//# sourceMappingURL=wiki.js.map