chapterhouse 0.1.5 → 0.2.0

package/dist/copilot/orchestrator.js

@@ -5,7 +5,7 @@ import { config, DEFAULT_MODEL } from "../config.js";
 import { loadMcpConfig } from "./mcp-config.js";
 import { getSkillDirectories } from "./skills.js";
 import { resetClient } from "./client.js";
-import { logConversation, getState, setState, deleteState, getCopilotSession, upsertCopilotSession, getTaskSessionKey, getDb } from "../store/db.js";
+import { logConversation, getState, setState, deleteState, getCopilotSession, upsertCopilotSession, getTaskSessionKey, getDb, bumpProjectLastUsed } from "../store/db.js";
 import { maybeWriteEpisode } from "./episode-writer.js";
 import { getWikiSummary } from "../wiki/context.js";
 import { SESSIONS_DIR } from "../paths.js";
@@ -13,6 +13,8 @@ import { resolveModel } from "./router.js";
 import { loadAgents, ensureDefaultAgents, clearActiveTasks, getAgentRegistry, setActiveAgent, parseAtMention, buildAgentRoster, getActiveTasks, } from "./agents.js";
 import { normalizeProjectPath, setChannelProject } from "../squad/context.js";
 import { getSquadCoordinatorSystemMessage } from "../squad/charter.js";
+import { childLogger } from "../util/logger.js";
+const log = childLogger("orchestrator");
 /**
  * Permission handler for the orchestrator session.
  * Approves all tool requests so @chapterhouse has full access to all tools.
@@ -160,9 +162,9 @@ async function ensureClient() {
         return copilotClient;
     }
     if (!resetPromise) {
-        console.log(`[chapterhouse] Client not connected (state: ${copilotClient?.getState() ?? "null"}), resetting…`);
+        log.info({ state: copilotClient?.getState() ?? "null" }, "Client not connected, resetting");
         resetPromise = resetClient().then((c) => {
-            console.log(`[chapterhouse] Client reset successful, state: ${c.getState()}`);
+            log.info({ state: c.getState() }, "Client reset successful");
             copilotClient = c;
             return c;
         }).finally(() => { resetPromise = undefined; });
@@ -179,7 +181,7 @@ function startHealthCheck() {
         try {
             const state = copilotClient.getState();
             if (state !== "connected") {
-                console.log(`[chapterhouse] Health check: client state is '${state}', resetting…`);
+                log.info({ state }, "Health check: client not connected, resetting");
                 await ensureClient();
                 // Session may need recovery after client reset
                 sessionMap.clear();
@@ -187,7 +189,7 @@ function startHealthCheck() {
             }
         }
         catch (err) {
-            console.error(`[chapterhouse] Health check error:`, err instanceof Error ? err.message : err);
+            log.error({ err: err instanceof Error ? err.message : err }, "Health check error");
         }
     }, HEALTH_CHECK_INTERVAL_MS);
 }
@@ -237,7 +239,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
     const savedSessionId = stored?.copilotSessionId ?? (sessionKey === "default" ? getState(ORCHESTRATOR_SESSION_KEY) : undefined);
     if (savedSessionId) {
         try {
-            console.log(`[chapterhouse] Resuming session [${sessionKey}] ${savedSessionId.slice(0, 8)}…`);
+            log.info({ sessionKey, sessionId: savedSessionId.slice(0, 8) }, "Resuming session");
             const session = await client.resumeSession(savedSessionId, {
                 model: config.copilotModel,
                 configDir: SESSIONS_DIR,
@@ -249,19 +251,19 @@ async function createOrResumeSession(sessionKey, projectRoot) {
                 onPermissionRequest: orchestratorPermissionHandler,
                 infiniteSessions,
             });
-            console.log(`[chapterhouse] Resumed session [${sessionKey}] successfully`);
+            log.info({ sessionKey }, "Session resumed successfully");
             upsertCopilotSession(sessionKey, isProjectSession ? "project" : "default", session.sessionId, projectRoot, config.copilotModel);
             sessionModelMap.set(sessionKey, config.copilotModel);
             return session;
         }
         catch (err) {
-            console.log(`[chapterhouse] Could not resume session [${sessionKey}]: ${err instanceof Error ? err.message : err}. Creating new.`);
+            log.warn({ sessionKey, err: err instanceof Error ? err.message : err }, "Could not resume session, creating new");
             if (sessionKey === "default")
                 deleteState(ORCHESTRATOR_SESSION_KEY);
         }
     }
     // Create a fresh session
-    console.log(`[chapterhouse] Creating new session [${sessionKey}]`);
+    log.info({ sessionKey }, "Creating new session");
     const session = await client.createSession({
         model: config.copilotModel,
         configDir: SESSIONS_DIR,
@@ -273,7 +275,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         onPermissionRequest: orchestratorPermissionHandler,
         infiniteSessions,
     });
-    console.log(`[chapterhouse] Created session [${sessionKey}] ${session.sessionId.slice(0, 8)}…`);
+    log.info({ sessionKey, sessionId: session.sessionId.slice(0, 8) }, "Session created");
     upsertCopilotSession(sessionKey, isProjectSession ? "project" : "default", session.sessionId, projectRoot, config.copilotModel);
     // Backward compat: also persist the default session to the legacy state key
     if (sessionKey === "default")
@@ -287,30 +289,30 @@ export async function initOrchestrator(client) {
     // Initialize agent system
     ensureDefaultAgents();
     const agents = loadAgents();
-    console.log(`[chapterhouse] Loaded ${agents.length} agent(s): ${agents.map((a) => `@${a.slug}`).join(", ") || "(none)"}`);
+    log.info({ count: agents.length, agents: agents.map((a) => `@${a.slug}`) }, "Agents loaded");
     // Validate configured model against available models
     try {
         const models = await client.listModels();
         const configured = config.copilotModel;
         const isAvailable = models.some((m) => m.id === configured);
         if (!isAvailable) {
-            console.log(`[chapterhouse] ⚠️ Configured model '${configured}' is not available. Falling back to '${DEFAULT_MODEL}'.`);
+            log.warn({ configured, fallback: DEFAULT_MODEL }, "Configured model not available, falling back");
             config.copilotModel = DEFAULT_MODEL;
         }
     }
     catch (err) {
-        console.log(`[chapterhouse] Could not validate model (will use '${config.copilotModel}' as-is): ${err instanceof Error ? err.message : err}`);
+        log.warn({ model: config.copilotModel, err: err instanceof Error ? err.message : err }, "Could not validate model, using as-is");
     }
-    console.log(`[chapterhouse] Loading ${Object.keys(mcpServers).length} MCP server(s): ${Object.keys(mcpServers).join(", ") || "(none)"}`);
-    console.log(`[chapterhouse] Skill directories: ${skillDirectories.join(", ") || "(none)"}`);
-    console.log(`[chapterhouse] Persistent session mode — conversation history maintained by SDK`);
+    log.info({ mcpServerCount: Object.keys(mcpServers).length, mcpServers: Object.keys(mcpServers) }, "Loading MCP servers");
+    log.info({ skillDirectories }, "Skill directories");
+    log.info("Persistent session mode — conversation history maintained by SDK");
     startHealthCheck();
     // Eagerly create/resume the default orchestrator session
     try {
         await ensureOrchestratorSession("default");
     }
     catch (err) {
-        console.error(`[chapterhouse] Failed to create initial session (will retry on first message):`, err instanceof Error ? err.message : err);
+        log.error({ err: err instanceof Error ? err.message : err }, "Failed to create initial session (will retry on first message)");
     }
 }
 /** How long to wait for the orchestrator to finish a turn (10 min). */
@@ -450,22 +452,22 @@ async function executeOnSession(sessionKey, prompt, callback, attachments, onAct
         // session and may have been (partially) processed. Return what we have.
         if (/timeout/i.test(msg)) {
             if (accumulated.length > 0) {
-                console.log(`[chapterhouse] Timeout after ${ORCHESTRATOR_TIMEOUT_MS / 1000}s but have ${accumulated.length} chars — returning partial response`);
+                log.warn({ timeoutSec: ORCHESTRATOR_TIMEOUT_MS / 1000, charCount: accumulated.length }, "Timeout with partial response — returning partial");
                 return accumulated;
             }
             // No text yet but tool calls ran — the session is working in the background
             // (e.g. delegate_to_agent dispatched). Don't error out.
             if (toolCallCount > 0) {
-                console.log(`[chapterhouse] Timeout after ${ORCHESTRATOR_TIMEOUT_MS / 1000}s — ${toolCallCount} tool call(s) executed but no text yet. Session is still working.`);
+                log.warn({ timeoutSec: ORCHESTRATOR_TIMEOUT_MS / 1000, toolCallCount }, "Timeout — tool calls ran but no text yet, session still working");
                 return "I'm still working on this — I've started processing but it's taking longer than expected. I'll send you the results when I'm done.";
             }
             // No text, no tool calls — the session is truly stuck
-            console.log(`[chapterhouse] Timeout after ${ORCHESTRATOR_TIMEOUT_MS / 1000}s with no activity. Session may be stuck.`);
+            log.warn({ timeoutSec: ORCHESTRATOR_TIMEOUT_MS / 1000 }, "Timeout with no activity — session may be stuck");
             return "Sorry, that request timed out before I could start working on it. Try again or break it into smaller pieces?";
         }
         // If the session is broken, invalidate it so it's recreated on next attempt
         if (/closed|destroy|disposed|invalid|expired|not found/i.test(msg)) {
-            console.log(`[chapterhouse] Session [${sessionKey}] appears dead, will recreate: ${msg}`);
+            log.warn({ sessionKey, msg }, "Session appears dead, will recreate");
             sessionMap.delete(sessionKey);
             sessionModelMap.delete(sessionKey);
             if (sessionKey === "default")
@@ -493,7 +495,7 @@ async function executeOnSession(sessionKey, prompt, callback, attachments, onAct
 async function processQueue() {
     if (processing) {
         if (messageQueue.length > 0) {
-            console.log(`[chapterhouse] Message queued (${messageQueue.length} waiting — orchestrator is busy)`);
+            log.debug({ queueLength: messageQueue.length }, "Message queued, orchestrator is busy");
         }
         return;
     }
@@ -515,17 +517,17 @@ async function processQueue() {
                 const currentModel = sessionModelMap.get(sessionKey) ?? config.copilotModel;
                 const routeResult = await resolveModel(item.prompt, currentModel, recentTiers);
                 if (routeResult.switched) {
-                    console.log(`[chapterhouse] Auto: switching to ${routeResult.model} (${routeResult.overrideName || routeResult.tier})`);
+                    log.info({ model: routeResult.model, tier: routeResult.overrideName || routeResult.tier }, "Auto-routing: switching model");
                     config.copilotModel = routeResult.model;
                     const existingSession = sessionMap.get(sessionKey);
                     if (existingSession) {
                         try {
                             await existingSession.setModel(routeResult.model);
                             sessionModelMap.set(sessionKey, routeResult.model);
-                            console.log(`[chapterhouse] Model switched in-place via setModel() for [${sessionKey}]`);
+                            log.info({ sessionKey }, "Model switched in-place");
                         }
                         catch (err) {
-                            console.log(`[chapterhouse] setModel() failed for [${sessionKey}], will recreate: ${err instanceof Error ? err.message : err}`);
+                            log.warn({ sessionKey, err: err instanceof Error ? err.message : err }, "setModel() failed, will recreate session");
                             sessionMap.delete(sessionKey);
                             if (sessionKey === "default")
                                 deleteState(ORCHESTRATOR_SESSION_KEY);
@@ -570,6 +572,8 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
         sessionKey = "project:" + normalizeProjectPath(source.projectPath);
         // Keep the legacy channel-project map in sync for tools that read it
         setChannelProject(source.connectionId, normalizeProjectPath(source.projectPath));
+        // Bump last-used timestamp so sidebar can sort by real activity
+        bumpProjectLastUsed(normalizeProjectPath(source.projectPath));
     }
     else if (source.type === "background" && source.sessionKey) {
         sessionKey = source.sessionKey;
@@ -621,7 +625,7 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                 // the user reply path.
                 if (copilotClient) {
                     maybeWriteEpisode(copilotClient).catch((err) => {
-                        console.error("[chapterhouse] Episode write failed (non-fatal):", err instanceof Error ? err.message : err);
+                        log.error({ err: err instanceof Error ? err.message : err }, "Episode write failed (non-fatal)");
                     });
                 }
                 return;
@@ -634,7 +638,7 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                 }
                 if (isRecoverableError(err) && attempt < MAX_RETRIES) {
                     const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
-                    console.error(`[chapterhouse] Recoverable error: ${msg}. Retry ${attempt + 1}/${MAX_RETRIES} after ${delay}ms…`);
+                    log.warn({ msg, attempt: attempt + 1, maxRetries: MAX_RETRIES, delayMs: delay }, "Recoverable error, retrying");
                     await sleep(delay);
                     // Reset client before retry in case the connection is stale
                     try {
@@ -643,7 +647,7 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                     catch { /* will fail again on next attempt */ }
                     continue;
                 }
-                console.error(`[chapterhouse] Error processing message: ${msg}`);
+                log.error({ msg }, "Error processing message");
                 callback(`Error: ${msg}`, true);
                 return;
             }
@@ -663,11 +667,11 @@ export async function cancelCurrentMessage() {
     if (activeSession && currentCallback) {
         try {
             await activeSession.abort();
-            console.log(`[chapterhouse] Aborted in-flight request on [${currentProcessingSessionKey}]`);
+            log.info({ sessionKey: currentProcessingSessionKey }, "Aborted in-flight request");
             return true;
         }
         catch (err) {
-            console.error(`[chapterhouse] Abort failed:`, err instanceof Error ? err.message : err);
+            log.error({ err: err instanceof Error ? err.message : err }, "Abort failed");
         }
     }
     return drained > 0;
@@ -704,7 +708,7 @@ export async function shutdownAgents() {
             await session.disconnect();
         }
         catch (err) {
-            console.error(`[orchestrator] Error disconnecting session "${key}" during shutdown:`, err instanceof Error ? err.message : err);
+            log.error({ sessionKey: key, err: err instanceof Error ? err.message : err }, "Error disconnecting session during shutdown");
         }
     }
     sessionMap.clear();

package/dist/copilot/orchestrator.test.js

@@ -182,6 +182,7 @@ async function loadOrchestratorModule(t, overrides = {}) {
                     all: () => [],
                 }),
             }),
+            bumpProjectLastUsed: (_projectRoot) => { },
         },
     });
     t.mock.module("./episode-writer.js", {

package/dist/copilot/router.js

@@ -1,5 +1,7 @@
 import { getState, setState } from "../store/db.js";
 import { classifyWithLLM } from "./classifier.js";
+import { childLogger } from "../util/logger.js";
+const log = childLogger("router");
 // ---------------------------------------------------------------------------
 // Default configuration
 // ---------------------------------------------------------------------------
@@ -96,12 +98,12 @@ async function classifyMessage(prompt, recentTiers, client) {
     if (client) {
         const tier = await classifyWithLLM(client, text);
         if (tier) {
-            console.log(`[chapterhouse] Classifier: ${tier}`);
+            log.debug({ tier }, "LLM classifier result");
             return tier;
         }
     }
     // Fallback — standard is always safe
-    console.log(`[chapterhouse] Classifier (fallback): standard`);
+    log.debug({ tier: "standard" }, "Classifier fallback: using standard tier");
     return "standard";
 }
 // ---------------------------------------------------------------------------

package/dist/copilot/tools.js

@@ -22,6 +22,8 @@ import { getChannelProject } from "../squad/context.js";
 import { findSquadAgent } from "../squad/registry.js";
 import { buildSquadSystemPrefix } from "../squad/charter.js";
 import { mirrorDecisionToWiki, syncDecisionsFileToWiki } from "../squad/mirror.js";
+import { childLogger } from "../util/logger.js";
+const log = childLogger("tools");
 function getCategoryDir(category) {
     const map = {
         person: "people",
@@ -223,12 +225,12 @@ export function createTools(deps) {
                                 // all 89+ entries, not just this task-completion entry.
                                 syncDecisionsFileToWiki(projectRoot).then(syncResult => {
                                     if (syncResult) {
-                                        console.log(`[squad] Post-task decisions sync: ${syncResult.entriesSynced} entries → ${syncResult.wikiPath}`);
+                                        log.info({ entriesSynced: syncResult.entriesSynced, wikiPath: syncResult.wikiPath }, "Post-task squad decisions synced to wiki");
                                     }
                                 }).catch(() => { });
                             }
                             catch (mirrorErr) {
-                                console.error("[tools] Failed to mirror squad decision to wiki (non-fatal):", mirrorErr instanceof Error ? mirrorErr.message : mirrorErr);
+                                log.error({ err: mirrorErr instanceof Error ? mirrorErr.message : mirrorErr }, "Failed to mirror squad decision to wiki (non-fatal)");
                             }
                         }
                     }
@@ -689,7 +691,7 @@ export function createTools(deps) {
                         await switchSessionModel(args.model_id);
                     }
                     catch (err) {
-                        console.log(`[chapterhouse] setModel() failed during switch_model (will apply on next session): ${err instanceof Error ? err.message : err}`);
+                        log.warn({ err: err instanceof Error ? err.message : err }, "setModel() failed during switch_model, will apply on next session");
                     }
                     // Disable router when manually switching — user has explicit preference
                     if (getRouterConfig().enabled) {
@@ -1169,7 +1171,7 @@ export function createTools(deps) {
                 // Schedule restart after returning the response
                 setTimeout(() => {
                     restartDaemon().catch((err) => {
-                        console.error("[chapterhouse] Restart failed:", err);
+                        log.error({ err: err instanceof Error ? err.message : err }, "Restart failed");
                     });
                 }, 1000);
                 return `Restarting Chapterhouse${reason}. I'll be back in a few seconds.`;