chapterhouse 0.1.1 → 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 } 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). */
@@ -403,6 +405,32 @@ async function executeOnSession(sessionKey, prompt, callback, attachments, onAct
             });
         })
         : () => { };
+    // Always persist SDK subagent dispatches to agent_tasks so Workers tab shows them.
+    // These fire when the built-in `task` tool (Squad coordinator) routes work to a
+    // specialist — separate from `delegate_to_agent` which handles CH-registry agents.
+    const db = getDb();
+    const unsubSubStartDb = session.on("subagent.started", (event) => {
+        try {
+            const data = event.data;
+            const agentSlug = (data.agentName || "unknown").toLowerCase().replace(/\s+/g, "-");
+            const description = (data.agentDescription || data.agentDisplayName || `Squad dispatch: ${agentSlug}`).slice(0, 500);
+            db.prepare(`INSERT OR IGNORE INTO agent_tasks (task_id, agent_slug, description, status, origin_channel, session_key, source) VALUES (?, ?, ?, 'running', ?, ?, 'squad')`).run(data.toolCallId, agentSlug, description, currentSourceChannel || null, sessionKey);
+        }
+        catch { /* non-fatal */ }
+    });
+    const unsubSubDoneDb = session.on("subagent.completed", (event) => {
+        try {
+            db.prepare(`UPDATE agent_tasks SET status = 'completed', completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(event.data.toolCallId);
+        }
+        catch { /* non-fatal */ }
+    });
+    const unsubSubFailDb = session.on("subagent.failed", (event) => {
+        try {
+            const data = event.data;
+            db.prepare(`UPDATE agent_tasks SET status = 'error', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(data.error || "Subagent failed", data.toolCallId);
+        }
+        catch { /* non-fatal */ }
+    });
     const unsubDelta = session.on("assistant.message_delta", (event) => {
         // After a tool call completes, ensure a line break separates the text blocks
         // so they don't visually run together in the rendered chat.
@@ -424,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")
@@ -455,6 +483,9 @@ async function executeOnSession(sessionKey, prompt, callback, attachments, onAct
         unsubSubStart();
         unsubSubDone();
         unsubSubFail();
+        unsubSubStartDb();
+        unsubSubDoneDb();
+        unsubSubFailDb();
         currentCallback = undefined;
         currentActivityCallback = undefined;
         currentProcessingSessionKey = undefined;
@@ -464,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;
     }
@@ -486,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);
@@ -541,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;
@@ -592,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;
@@ -605,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 {
@@ -614,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;
             }
@@ -634,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;
@@ -675,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

@@ -13,6 +13,11 @@ function createFakeClient(state) {
                 this.listeners.set(eventName, next);
             };
         }
+        emit(eventName, data) {
+            for (const handler of this.listeners.get(eventName) || []) {
+                handler({ data });
+            }
+        }
         async sendAndWait(request, _timeoutMs) {
             state.sessionPrompts.push(request);
             if (state.sendResult === "__PENDING__") {
@@ -45,7 +50,11 @@ function createFakeClient(state) {
             if (state.createSessionError) {
                 throw new Error(state.createSessionError);
             }
-            return new FakeSession();
+            const session = new FakeSession();
+            state.lastSession = {
+                emit: (eventName, data) => session.emit(eventName, data),
+            };
+            return session;
         },
         async resumeSession(savedId, options) {
             state.resumeSessionCalls.push({ savedId, options });
@@ -71,6 +80,7 @@ async function loadOrchestratorModule(t, overrides = {}) {
         disconnectCalls: 0,
         conversationLogs: [],
         dbLogs: [],
+        dbWrites: [],
         episodeWrites: 0,
         ensureDefaultAgentsCalls: 0,
         loadAgentsCalls: 0,
@@ -162,6 +172,17 @@ async function loadOrchestratorModule(t, overrides = {}) {
             getCopilotSession: (_sessionKey) => undefined,
             upsertCopilotSession: (_sessionKey, _mode, _copilotSessionId, _projectRoot, _model) => { },
             getTaskSessionKey: (taskId) => state.taskSessionKeys?.get(taskId) ?? "default",
+            getDb: () => ({
+                prepare: (sql) => ({
+                    run: (...args) => {
+                        state.dbWrites.push({ sql, args });
+                        return {};
+                    },
+                    get: () => undefined,
+                    all: () => [],
+                }),
+            }),
+            bumpProjectLastUsed: (_projectRoot) => { },
         },
     });
     t.mock.module("./episode-writer.js", {
@@ -520,4 +541,89 @@ test("ensureOrchestratorSession cleans up in-flight promise on session creation
     await new Promise((resolve) => setTimeout(resolve, 20));
     assert.ok(state.createSessionCalls.length > countAfterFirst, "a second message must trigger a new createSession attempt, proving sessionCreatePromises was cleaned up");
 });
+// ---------------------------------------------------------------------------
+// S5-01: SDK subagent events persist to agent_tasks (squad dispatch tracking)
+// Root cause: executeOnSession subscribed to subagent.* events for the UI
+// activity feed but never wrote rows to agent_tasks. Workers tab only reads
+// agent_tasks, so squad coordinator dispatches were invisible.
+// Fix: unconditional DB subscriptions in executeOnSession write/update rows.
+// ---------------------------------------------------------------------------
+test("S5-01: subagent.started event inserts a squad row into agent_tasks", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    // Start a message so executeOnSession runs and registers event handlers
+    const callbackResults = [];
+    orchestrator.sendToOrchestrator("dispatch something", { type: "background" }, (text, done) => {
+        callbackResults.push({ text, done });
+    });
+    // Yield so the async IIFE reaches sendAndWait (which is pending)
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.ok(state.lastSession, "FakeSession should have been created");
+    // Fire a subagent.started event — simulates the SDK's task tool starting a squad dispatch
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "subagent-call-001",
+        agentName: "Kaylee",
+        agentDisplayName: "Kaylee — Backend Dev",
+        agentDescription: "Implement S5-01 backend fix",
+    });
+    // The handler is synchronous — DB write should be in state.dbWrites immediately
+    const insertWrite = state.dbWrites.find((w) => w.sql.includes("INSERT") && w.sql.includes("agent_tasks"));
+    assert.ok(insertWrite, "subagent.started must INSERT a row into agent_tasks");
+    assert.ok((insertWrite.sql + JSON.stringify(insertWrite.args)).includes("squad"), "inserted row must carry source='squad'");
+    assert.ok(JSON.stringify(insertWrite.args).includes("subagent-call-001"), "task_id must equal the toolCallId from the event");
+    // Resolve the pending sendAndWait so the test can clean up
+    state.pendingReject?.(new Error("test teardown"));
+});
+test("S5-01: subagent.completed event updates agent_tasks status to completed", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("dispatch something", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // First, start the subagent
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "subagent-call-002",
+        agentName: "Wash",
+        agentDisplayName: "Wash — Frontend Dev",
+        agentDescription: "Fix Workers tab UI",
+    });
+    // Then complete it
+    state.lastSession.emit("subagent.completed", {
+        toolCallId: "subagent-call-002",
+        agentName: "Wash",
+        agentDisplayName: "Wash — Frontend Dev",
+        durationMs: 1234,
+    });
+    const updateWrite = state.dbWrites.find((w) => w.sql.includes("UPDATE") && w.sql.includes("agent_tasks") && w.sql.includes("completed"));
+    assert.ok(updateWrite, "subagent.completed must UPDATE agent_tasks to completed");
+    assert.ok(JSON.stringify(updateWrite.args).includes("subagent-call-002"), "UPDATE must target the correct task_id");
+    state.pendingReject?.(new Error("test teardown"));
+});
+test("S5-01: subagent.failed event updates agent_tasks status to error", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("dispatch something", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "subagent-call-003",
+        agentName: "Zoe",
+        agentDisplayName: "Zoe — QA",
+        agentDescription: "Run test suite",
+    });
+    state.lastSession.emit("subagent.failed", {
+        toolCallId: "subagent-call-003",
+        agentName: "Zoe",
+        agentDisplayName: "Zoe — QA",
+        error: "Timeout after 600s",
+    });
+    const errorWrite = state.dbWrites.find((w) => w.sql.includes("UPDATE") && w.sql.includes("agent_tasks") && w.sql.includes("error"));
+    assert.ok(errorWrite, "subagent.failed must UPDATE agent_tasks to error status");
+    assert.ok(JSON.stringify(errorWrite.args).includes("subagent-call-003"), "UPDATE must target the correct task_id");
+    state.pendingReject?.(new Error("test teardown"));
+});
 //# sourceMappingURL=orchestrator.test.js.map

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",
@@ -156,7 +158,7 @@ export function createTools(deps) {
                 const task = registerTask(delegatedSlug, args.summary, getCurrentSourceChannel());
                 // Persist task to DB
                 const db = getDb();
-                db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, status, origin_channel, session_key) VALUES (?, ?, ?, 'running', ?, ?)`).run(task.taskId, delegatedSlug, args.summary, task.originChannel || null, getCurrentSessionKey());
+                db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, status, origin_channel, session_key, source) VALUES (?, ?, ?, 'running', ?, ?, 'adhoc')`).run(task.taskId, delegatedSlug, args.summary, task.originChannel || null, getCurrentSessionKey());
                 // Capture the parent's activity callback so the child session can stream
                 // its events back to the originating SSE connection. This survives past
                 // the parent assistant turn — the child runs long after the parent's
@@ -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.`;