chapterhouse 0.3.12 → 0.3.14

package/dist/copilot/task-event-log.test.js

@@ -14,13 +14,13 @@
  * 10. Multiple tasks tracked independently
  * 11. RING_BUFFER_CAPACITY constant: 500 items, evicts oldest
  *
- * Uses node:test (same pattern as hooks.test.ts, agents.squad.test.ts) so the
+ * Uses node:test (same pattern as hooks.test.ts) so the
  * daemon's `npm test` runner (node --test) picks these up from dist/.
  */
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { EventBus } from "@bradygaster/squad-sdk/runtime/event-bus";
-import { RingBuffer, RING_BUFFER_CAPACITY, } from "./task-event-log.js";
+import { agentEventBus } from "./agent-event-bus.js";
+import { RingBuffer, RING_BUFFER_CAPACITY, initTaskEventLog, getTaskLogEvents, subscribeTaskLog, clearTaskLog, taskLogSize, } from "./task-event-log.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -48,87 +48,6 @@ function makeDestroyedEvent(sessionId) {
         timestamp: new Date(),
     };
 }
-/**
- * Builds an isolated task-event-log wired to a fresh EventBus so tests don't
- * share state through the process-level squadEventBus singleton.
- */
-function buildIsolatedLog(bus) {
-    const CAPACITY = RING_BUFFER_CAPACITY;
-    const buffers = new Map();
-    const listeners = new Map();
-    function getOrCreate(taskId) {
-        let b = buffers.get(taskId);
-        if (!b) {
-            b = new RingBuffer(CAPACITY);
-            buffers.set(taskId, b);
-        }
-        return b;
-    }
-    function notify(taskId, event) {
-        const ls = listeners.get(taskId);
-        if (!ls)
-            return;
-        for (const fn of ls) {
-            try {
-                fn(event);
-            }
-            catch { /* non-fatal */ }
-        }
-    }
-    const unsubToolCall = bus.subscribe("session:tool_call", (event) => {
-        const taskId = event.sessionId;
-        if (!taskId)
-            return;
-        const p = event.payload;
-        const ev = {
-            id: 0, taskId,
-            seq: p._seq ?? 0,
-            ts: p._ts ?? Date.now(),
-            kind: p._kind === "tool_complete" ? "tool_complete" : "tool_start",
-            toolName: p.toolName ?? null,
-            summary: p._summary ?? null,
-        };
-        getOrCreate(taskId).push(ev);
-        notify(taskId, ev);
-    });
-    const unsubDestroyed = bus.subscribe("session:destroyed", (event) => {
-        if (event.sessionId) {
-            buffers.delete(event.sessionId);
-            listeners.delete(event.sessionId);
-        }
-    });
-    return {
-        getEvents: (taskId, afterSeq = 0) => {
-            const buf = buffers.get(taskId);
-            if (!buf)
-                return [];
-            const all = buf.getAll();
-            return afterSeq === 0 ? all : all.filter((e) => e.seq > afterSeq);
-        },
-        subscribe: (taskId, fn) => {
-            let ls = listeners.get(taskId);
-            if (!ls) {
-                ls = new Set();
-                listeners.set(taskId, ls);
-            }
-            ls.add(fn);
-            return () => {
-                const lss = listeners.get(taskId);
-                if (lss) {
-                    lss.delete(fn);
-                    if (lss.size === 0)
-                        listeners.delete(taskId);
-                }
-            };
-        },
-        clear: (taskId) => {
-            buffers.delete(taskId);
-            listeners.delete(taskId);
-        },
-        size: () => buffers.size,
-        shutdown: () => { unsubToolCall(); unsubDestroyed(); },
-    };
-}
 // ---------------------------------------------------------------------------
 // RingBuffer — pure class tests
 // ---------------------------------------------------------------------------
@@ -189,87 +108,94 @@ describe("RingBuffer", () => {
 // Task event log (bus-wired) tests
 // ---------------------------------------------------------------------------
 describe("task event log — bus-wired", () => {
-    let bus;
-    let log;
+    let shutdown;
     beforeEach(() => {
-        bus = new EventBus();
-        log = buildIsolatedLog(bus);
+        shutdown = initTaskEventLog();
     });
     afterEach(() => {
-        log.shutdown();
+        shutdown();
     });
     it("returns [] for an unknown taskId", () => {
-        assert.deepEqual(log.getEvents("no-such-task"), []);
+        assert.deepEqual(getTaskLogEvents("no-such-task"), []);
     });
-    it("populates ring buffer on session:tool_call bus event", async () => {
-        await bus.emit(makeToolCallEvent({ sessionId: "task-001", kind: "tool_start", seq: 1, toolName: "view" }));
-        const events = log.getEvents("task-001");
+    it("populates ring buffer on session:tool_call bus event", () => {
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-001", kind: "tool_start", seq: 1, toolName: "view" }));
+        const events = getTaskLogEvents("task-001");
         assert.equal(events.length, 1);
         assert.equal(events[0].kind, "tool_start");
         assert.equal(events[0].toolName, "view");
         assert.equal(events[0].taskId, "task-001");
         assert.equal(events[0].seq, 1);
+        clearTaskLog("task-001");
     });
-    it("accumulates multiple events in order", async () => {
-        await bus.emit(makeToolCallEvent({ sessionId: "task-002", kind: "tool_start", seq: 1, toolName: "bash" }));
-        await bus.emit(makeToolCallEvent({ sessionId: "task-002", kind: "tool_complete", seq: 2, summary: "ok" }));
-        await bus.emit(makeToolCallEvent({ sessionId: "task-002", kind: "tool_start", seq: 3, toolName: "view" }));
-        const events = log.getEvents("task-002");
+    it("accumulates multiple events in order", () => {
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-002", kind: "tool_start", seq: 1, toolName: "bash" }));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-002", kind: "tool_complete", seq: 2, summary: "ok" }));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-002", kind: "tool_start", seq: 3, toolName: "view" }));
+        const events = getTaskLogEvents("task-002");
         assert.equal(events.length, 3);
         assert.equal(events[0].seq, 1);
         assert.equal(events[2].seq, 3);
         assert.equal(events[1].kind, "tool_complete");
-    });
-    it("getEvents filters by afterSeq", async () => {
-        await bus.emit(makeToolCallEvent({ sessionId: "task-003", seq: 1 }));
-        await bus.emit(makeToolCallEvent({ sessionId: "task-003", seq: 2 }));
-        await bus.emit(makeToolCallEvent({ sessionId: "task-003", seq: 3 }));
-        assert.equal(log.getEvents("task-003", 1).length, 2);
-        assert.equal(log.getEvents("task-003", 2).length, 1);
-        assert.equal(log.getEvents("task-003", 3).length, 0);
-    });
-    it("subscribe delivers events as they arrive", async () => {
+        clearTaskLog("task-002");
+    });
+    it("getEvents filters by afterSeq", () => {
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-003", seq: 1 }));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-003", seq: 2 }));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-003", seq: 3 }));
+        assert.equal(getTaskLogEvents("task-003", 1).length, 2);
+        assert.equal(getTaskLogEvents("task-003", 2).length, 1);
+        assert.equal(getTaskLogEvents("task-003", 3).length, 0);
+        clearTaskLog("task-003");
+    });
+    it("subscribe delivers events as they arrive", () => {
         const received = [];
-        log.subscribe("task-004", (e) => received.push(e.toolName ?? "?"));
-        await bus.emit(makeToolCallEvent({ sessionId: "task-004", toolName: "bash" }));
-        await bus.emit(makeToolCallEvent({ sessionId: "task-004", toolName: "view" }));
+        const unsub = subscribeTaskLog("task-004", (e) => received.push(e.toolName ?? "?"));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-004", toolName: "bash" }));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-004", toolName: "view" }));
+        unsub();
         assert.deepEqual(received, ["bash", "view"]);
+        clearTaskLog("task-004");
     });
-    it("subscribe unsub stops delivery", async () => {
+    it("subscribe unsub stops delivery", () => {
         const received = [];
-        const unsub = log.subscribe("task-005", (e) => received.push(e.toolName ?? "?"));
-        await bus.emit(makeToolCallEvent({ sessionId: "task-005", toolName: "bash" }));
+        const unsub = subscribeTaskLog("task-005", (e) => received.push(e.toolName ?? "?"));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-005", toolName: "bash" }));
         unsub();
-        await bus.emit(makeToolCallEvent({ sessionId: "task-005", toolName: "view" }));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-005", toolName: "view" }));
         assert.equal(received.length, 1);
         assert.equal(received[0], "bash");
-    });
-    it("clearTaskLog removes buffer and listeners", async () => {
-        await bus.emit(makeToolCallEvent({ sessionId: "task-006", seq: 1 }));
-        assert.equal(log.getEvents("task-006").length, 1);
-        log.clear("task-006");
-        assert.equal(log.getEvents("task-006").length, 0);
-    });
-    it("session:destroyed auto-clears ring buffer", async () => {
-        await bus.emit(makeToolCallEvent({ sessionId: "task-007", seq: 1 }));
-        await bus.emit(makeToolCallEvent({ sessionId: "task-007", seq: 2 }));
-        assert.equal(log.getEvents("task-007").length, 2);
-        await bus.emit(makeDestroyedEvent("task-007"));
-        assert.equal(log.getEvents("task-007").length, 0);
-    });
-    it("tracks multiple tasks independently", async () => {
-        await bus.emit(makeToolCallEvent({ sessionId: "task-A", seq: 1, toolName: "bash" }));
-        await bus.emit(makeToolCallEvent({ sessionId: "task-B", seq: 1, toolName: "view" }));
-        await bus.emit(makeToolCallEvent({ sessionId: "task-A", seq: 2, toolName: "edit" }));
-        assert.equal(log.getEvents("task-A").length, 2);
-        assert.equal(log.getEvents("task-B").length, 1);
-        assert.equal(log.getEvents("task-A")[0].toolName, "bash");
-        assert.equal(log.getEvents("task-B")[0].toolName, "view");
-        assert.equal(log.size(), 2);
-    });
-    it("events for wrong taskId are not visible to other tasks", async () => {
-        await bus.emit(makeToolCallEvent({ sessionId: "task-X", seq: 1 }));
-        assert.equal(log.getEvents("task-Y").length, 0);
+        clearTaskLog("task-005");
+    });
+    it("clearTaskLog removes buffer and listeners", () => {
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-006", seq: 1 }));
+        assert.equal(getTaskLogEvents("task-006").length, 1);
+        clearTaskLog("task-006");
+        assert.equal(getTaskLogEvents("task-006").length, 0);
+    });
+    it("session:destroyed auto-clears ring buffer", () => {
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-007", seq: 1 }));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-007", seq: 2 }));
+        assert.equal(getTaskLogEvents("task-007").length, 2);
+        agentEventBus.emit(makeDestroyedEvent("task-007"));
+        assert.equal(getTaskLogEvents("task-007").length, 0);
+    });
+    it("tracks multiple tasks independently", () => {
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-A", seq: 1, toolName: "bash" }));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-B", seq: 1, toolName: "view" }));
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-A", seq: 2, toolName: "edit" }));
+        assert.equal(getTaskLogEvents("task-A").length, 2);
+        assert.equal(getTaskLogEvents("task-B").length, 1);
+        assert.equal(getTaskLogEvents("task-A")[0].toolName, "bash");
+        assert.equal(getTaskLogEvents("task-B")[0].toolName, "view");
+        assert.equal(taskLogSize(), 2);
+        clearTaskLog("task-A");
+        clearTaskLog("task-B");
+    });
+    it("events for wrong taskId are not visible to other tasks", () => {
+        agentEventBus.emit(makeToolCallEvent({ sessionId: "task-X", seq: 1 }));
+        assert.equal(getTaskLogEvents("task-Y").length, 0);
+        clearTaskLog("task-X");
     });
 });
 //# sourceMappingURL=task-event-log.test.js.map

package/dist/copilot/tools.js

@@ -6,23 +6,18 @@ import { join } from "path";
 import { homedir } from "os";
 import { listSkills, createSkill, removeSkill } from "./skills.js";
 import { config, persistModel } from "../config.js";
-import { createSessionHooks } from "./hooks.js";
-import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentChannelKey, getCurrentSessionKey, switchSessionModel, } from "./orchestrator.js";
+import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
 import { ensureWikiStructure, readPage, writePage, deletePage, listPages, writeRawSource, listSources, assertPagePath } from "../wiki/fs.js";
 import { searchIndex, addToIndex, removeFromIndex, parseIndex, buildIndexEntryForPage } from "../wiki/index-manager.js";
 import { appendLog } from "../wiki/log-manager.js";
 import { withWikiWrite } from "../wiki/lock.js";
 import { readWikiPage, teamWikiSync } from "../wiki/team-sync.js";
-import { getAgentRegistry, getAgent, createEphemeralAgentSession, createSquadAgentSession, getAgentSessionStatus, getTask, registerTask, completeTask, failTask, createAgentFile, removeAgentFile, loadAgents, } from "./agents.js";
+import { getAgentRegistry, getAgent, createEphemeralAgentSession, getAgentSessionStatus, getTask, registerTask, completeTask, failTask, createAgentFile, removeAgentFile, loadAgents, } from "./agents.js";
 import { adoGetOkrs, adoOkrSummary, adoUpdateKr } from "../integrations/ado-skill.js";
 import { TeamsNotifier } from "../integrations/teams-notify.js";
 import { TeamPushClient } from "../integrations/team-push.js";
 import { OKRMapper, parseOKRPageContent } from "./okr-mapper.js";
-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) {
@@ -112,45 +107,15 @@ export function createTools(deps) {
                 if (agent?.slug === "chapterhouse") {
                     return "Cannot delegate to yourself. Handle this directly or pick a specialist agent.";
                 }
-                const channelKey = getCurrentChannelKey() ?? "default";
-                const projectRoot = config.squadEnabled ? (getChannelProject(channelKey) ?? undefined) : undefined;
-                const squadDescriptor = (!agent && projectRoot)
-                    ? (() => { try {
-                        return findSquadAgent(projectRoot, args.agent_name);
-                    }
-                    catch {
-                        return null;
-                    } })()
-                    : null;
-                if (!agent && !squadDescriptor) {
+                if (!agent) {
                     const available = getAgentRegistry().map((a) => a.slug).join(", ");
                     return `Agent '${args.agent_name}' not found. Available agents: ${available}`;
                 }
-                const delegatedSlug = agent?.slug ?? squadDescriptor?.slug ?? args.agent_name;
+                const delegatedSlug = agent.slug;
                 let session;
-                let isSquadAgent = false;
                 try {
                     const allTools = createTools(deps);
-                    if (squadDescriptor && projectRoot) {
-                        const squadContext = {
-                            projectRoot,
-                            squadDir: join(projectRoot, ".squad"),
-                            teamDir: join(projectRoot, ".squad"),
-                            personalDir: null,
-                            mode: "local",
-                            projectKey: null,
-                            config: {},
-                            agents: [squadDescriptor],
-                            decisionsPath: join(projectRoot, ".squad", "decisions.md"),
-                            loadedAt: new Date().toISOString(),
-                        };
-                        const charterPrefix = await buildSquadSystemPrefix(squadContext, squadDescriptor);
-                        session = await createSquadAgentSession(delegatedSlug, deps.client, allTools, charterPrefix, args.model_override || squadDescriptor.modelPreference);
-                        isSquadAgent = true;
-                    }
-                    else {
-                        session = await createEphemeralAgentSession(agent.slug, deps.client, allTools, args.model_override);
-                    }
+                    session = await createEphemeralAgentSession(agent.slug, deps.client, allTools, args.model_override);
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
@@ -212,28 +177,6 @@ export function createTools(deps) {
                         completeTask(task.taskId, output);
                         db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(output.slice(0, 10000), task.taskId);
                         deps.onAgentTaskComplete(task.taskId, delegatedSlug, output);
-                        if (isSquadAgent && projectRoot && squadDescriptor) {
-                            try {
-                                const wikiDecisionPath = await mirrorDecisionToWiki({
-                                    taskId: task.taskId,
-                                    projectRoot,
-                                    squadAgentSlug: squadDescriptor.slug,
-                                    wikiDecisionPath: "",
-                                }, args.summary, output);
-                                db.prepare(`INSERT OR REPLACE INTO squad_task_links (task_id, project_root, squad_agent_slug, wiki_decision_path)
-                   VALUES (?, ?, ?, ?)`).run(task.taskId, projectRoot, squadDescriptor.slug, wikiDecisionPath);
-                                // Sync the full decisions.md file to the wiki so the page reflects
-                                // all 89+ entries, not just this task-completion entry.
-                                syncDecisionsFileToWiki(projectRoot).then(syncResult => {
-                                    if (syncResult) {
-                                        log.info({ entriesSynced: syncResult.entriesSynced, wikiPath: syncResult.wikiPath }, "Post-task squad decisions synced to wiki");
-                                    }
-                                }).catch(() => { });
-                            }
-                            catch (mirrorErr) {
-                                log.error({ err: mirrorErr instanceof Error ? mirrorErr.message : mirrorErr }, "Failed to mirror squad decision to wiki (non-fatal)");
-                            }
-                        }
                     }
                     catch (err) {
                         const msg = err instanceof Error ? err.message : String(err);
@@ -253,7 +196,7 @@ export function createTools(deps) {
                 })();
                 const model = (args.model_override && args.model_override.length > 0)
                     ? args.model_override
-                    : squadDescriptor?.modelPreference || (agent?.model === "auto" ? "claude-sonnet-4.6" : agent?.model || "claude-sonnet-4.6");
+                    : (agent.model === "auto" ? "claude-sonnet-4.6" : agent.model || "claude-sonnet-4.6");
                 return `Task delegated to @${delegatedSlug} (${model}). Task ID: ${task.taskId}. I'll notify you when it's done.`;
             },
         }),
@@ -323,12 +266,10 @@ export function createTools(deps) {
             },
         }),
         defineTool("show_agent_roster", {
-            description: "List all registered agents with their name, model, status, and current tasks. When a squad project is active, also shows squad team members available via @mention.",
+            description: "List all registered agents with their name, model, status, and current tasks.",
             parameters: z.object({}),
             handler: async () => {
                 const agents = getAgentRegistry();
-                const channelKey = getCurrentChannelKey() ?? "default";
-                const projectRoot = config.squadEnabled ? (getChannelProject(channelKey) ?? undefined) : undefined;
                 const chLines = agents.map((a) => {
                     const status = getAgentSessionStatus(a.slug);
                     const runningTasks = status.tasks.filter((t) => t.status === "running");
@@ -338,25 +279,9 @@ export function createTools(deps) {
                         : "";
                     return `• @${a.slug} (${a.name}) — ${a.model} — ${badge}${taskInfo}\n  ${a.description}`;
                 });
-                let squadSection = "";
-                if (projectRoot) {
-                    try {
-                        const { renderProjectAgentRoster } = await import("../squad/registry.js");
-                        const squadRoster = renderProjectAgentRoster(projectRoot);
-                        if (squadRoster) {
-                            squadSection = `\n\nSquad agents (project: ${projectRoot}):\n${squadRoster}`;
-                        }
-                    }
-                    catch {
-                        // squad unavailable — skip
-                    }
-                }
-                else if (config.squadEnabled) {
-                    squadSection = "\n\n(Squad is enabled — select a project context to see squad agents)";
-                }
-                if (chLines.length === 0 && !squadSection)
+                if (chLines.length === 0)
                     return "No agents registered.";
-                return `Registered agents (${chLines.length}):\n${chLines.join("\n")}${squadSection}`;
+                return `Registered agents (${chLines.length}):\n${chLines.join("\n")}`;
             },
         }),
         defineTool("teams_notify", {
@@ -584,7 +509,6 @@ export function createTools(deps) {
                     const session = await deps.client.resumeSession(args.session_id, {
                         model: config.copilotModel,
                         onPermissionRequest: approveAll,
-                        hooks: createSessionHooks(args.name),
                     });
                     const db = getDb();
                     db.prepare(`INSERT OR REPLACE INTO agent_sessions (slug, copilot_session_id, model, status)

package/dist/daemon.js

@@ -2,7 +2,6 @@ import { getClient, stopClient } from "./copilot/client.js";
 import { initOrchestrator, setMessageLogger, setProactiveNotify, getAgentInfo, shutdownAgents } from "./copilot/orchestrator.js";
 import { stopEpisodeWriter } from "./copilot/episode-writer.js";
 import { startApiServer, broadcastToSSE } from "./api/server.js";
-import { killRalphOnShutdown } from "./api/ralph.js";
 import { getDb, closeDb, getState } from "./store/db.js";
 import { config } from "./config.js";
 import { spawn } from "child_process";
@@ -15,7 +14,6 @@ import { shouldMigrate, migrateMemoriesToWiki, shouldReorganize, reorganizeWiki
 import { SESSIONS_DIR } from "./paths.js";
 import { getDisplayHost } from "./api/server-runtime.js";
 import { StandupScheduler } from "./copilot/standup.js";
-import { DecisionsSyncScheduler } from "./squad/mirror.scheduler.js";
 import { registerShutdownSignals } from "./shutdown-signals.js";
 import { logger } from "./util/logger.js";
 import { CHAPTERHOUSE_VERSION } from "./version.js";
@@ -148,9 +146,6 @@ async function main() {
     if (config.chapterhouseMode === "personal" && (config.adoPat || config.teamChapterhouseUrl)) {
         new StandupScheduler().schedule();
     }
-    // Start periodic decisions→wiki sync for all registered projects
-    decisionsSyncScheduler = new DecisionsSyncScheduler();
-    decisionsSyncScheduler.start();
     const url = `http://${getDisplayHost(config.apiHost)}:${config.apiPort}`;
     log.info({ url }, "Chapterhouse is fully operational");
     if (process.env.CHAPTERHOUSE_OPEN_BROWSER === "1") {
@@ -177,7 +172,6 @@ async function main() {
 }
 // Graceful shutdown
 let shutdownState = "idle";
-let decisionsSyncScheduler;
 async function shutdown() {
     if (shutdownState === "shutting_down") {
         log.warn("Forced exit");
@@ -202,10 +196,6 @@ async function shutdown() {
     forceTimer.unref();
     // Destroy all active agent sessions
     await shutdownAgents();
-    try {
-        decisionsSyncScheduler?.stop();
-    }
-    catch { /* best effort */ }
     try {
         stopEpisodeWriter();
     }
@@ -214,10 +204,6 @@ async function shutdown() {
         await stopClient();
     }
     catch { /* best effort */ }
-    try {
-        killRalphOnShutdown();
-    }
-    catch { /* best effort */ }
     closeDb();
     log.info("Goodbye");
     process.exit(0);
@@ -231,10 +217,6 @@ export async function restartDaemon() {
     }
     // Destroy all active agent sessions
     await shutdownAgents();
-    try {
-        decisionsSyncScheduler?.stop();
-    }
-    catch { /* best effort */ }
     try {
         stopEpisodeWriter();
     }
@@ -243,10 +225,6 @@ export async function restartDaemon() {
         await stopClient();
     }
     catch { /* best effort */ }
-    try {
-        killRalphOnShutdown();
-    }
-    catch { /* best effort */ }
     closeDb();
     // Spawn a detached replacement process with the same args (include execArgv for tsx/loaders)
     const child = spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {

package/dist/store/db.js

@@ -68,42 +68,6 @@ export function getDb() {
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
         last_accessed DATETIME DEFAULT CURRENT_TIMESTAMP
       )
-    `);
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS project_squads (
-        project_root TEXT PRIMARY KEY,
-        squad_dir TEXT NOT NULL,
-        team_dir TEXT NOT NULL,
-        personal_dir TEXT,
-        mode TEXT NOT NULL CHECK(mode IN ('local', 'remote')),
-        project_key TEXT,
-        config_source TEXT,
-        registered INTEGER NOT NULL DEFAULT 0,
-        loaded_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS squad_agents (
-        project_root TEXT NOT NULL,
-        slug TEXT NOT NULL,
-        role TEXT NOT NULL,
-        description TEXT,
-        charter_path TEXT NOT NULL,
-        model_preference TEXT,
-        tools_json TEXT,
-        capabilities_json TEXT,
-        stale INTEGER NOT NULL DEFAULT 0,
-        loaded_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY (project_root, slug)
-      )
-    `);
-        db.exec(`
-      CREATE TABLE IF NOT EXISTS squad_task_links (
-        task_id TEXT PRIMARY KEY,
-        project_root TEXT NOT NULL,
-        squad_agent_slug TEXT NOT NULL,
-        wiki_decision_path TEXT NOT NULL
-      )
     `);
         // Migrate: if the table already existed with a stricter CHECK, recreate it
         try {
@@ -146,7 +110,7 @@ export function getDb() {
         if (!taskCols.some((c) => c.name === 'session_key')) {
             db.exec(`ALTER TABLE agent_tasks ADD COLUMN session_key TEXT NOT NULL DEFAULT 'default'`);
         }
-        // Migrate: add source column to agent_tasks ('adhoc' | 'squad') if not present
+        // Migrate: add source column to agent_tasks ('adhoc') if not present
         if (!taskCols.some((c) => c.name === 'source')) {
             db.exec(`ALTER TABLE agent_tasks ADD COLUMN source TEXT NOT NULL DEFAULT 'adhoc'`);
         }
@@ -168,13 +132,6 @@ export function getDb() {
         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')) {
-            db.exec(`ALTER TABLE project_squads ADD COLUMN last_used_at INTEGER`);
-            // Backfill from loaded_at so sidebar is not empty for existing projects
-            db.exec(`UPDATE project_squads SET last_used_at = CAST((julianday(loaded_at) - 2440587.5) * 86400000 AS INTEGER) WHERE last_used_at IS NULL`);
-        }
         // turn_events: append-only per-turn event log for the SSE chat channel (#130).
         // Events are written on turn completion; ring buffer serves live/recent replay.
         db.exec(`
@@ -297,7 +254,7 @@ export function getTaskSessionKey(taskId) {
  * Get recent conversation history formatted for injection into system message.
  *
  * When `sessionKey` is provided, only rows belonging to that session are
- * returned — useful for project/squad sessions that must not bleed context
+ * 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).
  */
@@ -408,11 +365,6 @@ export function getTaskEvents(taskId, afterSeq = 0) {
         summary: r.summary,
     }));
 }
-export function bumpProjectLastUsed(projectRoot) {
-    getDb()
-        .prepare(`UPDATE project_squads SET last_used_at = ? WHERE project_root = ?`)
-        .run(Date.now(), projectRoot);
-}
 export function closeDb() {
     if (db) {
         db.close();

package/dist/store/db.test.js

@@ -167,51 +167,6 @@ test("getSessionMessages returns structured messages in chronological order, exc
     }
 });
 // ---------------------------------------------------------------------------
-// #26 — bumpProjectLastUsed
-// ---------------------------------------------------------------------------
-test("migration adds last_used_at column to project_squads when absent", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        const db = dbModule.getDb();
-        const cols = db.prepare(`PRAGMA table_info(project_squads)`).all();
-        assert.equal(cols.some((c) => c.name === "last_used_at"), true, "last_used_at column should exist after migration");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-test("bumpProjectLastUsed updates last_used_at for the given project_root", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        const db = dbModule.getDb();
-        db.prepare(`INSERT INTO project_squads (project_root, squad_dir, team_dir, mode, registered) VALUES (?, ?, ?, 'local', 1)`).run("/home/user/test-proj", "/home/user/test-proj/.squad", "/home/user/test-proj/.squad");
-        const before = db
-            .prepare(`SELECT last_used_at FROM project_squads WHERE project_root = ?`)
-            .get("/home/user/test-proj");
-        const beforeTs = before.last_used_at ?? 0;
-        await new Promise((r) => setTimeout(r, 5));
-        dbModule.bumpProjectLastUsed("/home/user/test-proj");
-        const after = db
-            .prepare(`SELECT last_used_at FROM project_squads WHERE project_root = ?`)
-            .get("/home/user/test-proj");
-        assert.ok(after.last_used_at !== null, "last_used_at should not be null after bump");
-        assert.ok(after.last_used_at > beforeTs, "last_used_at should advance after bump");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-test("bumpProjectLastUsed is a no-op for unknown project_root (no throw)", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        dbModule.bumpProjectLastUsed("/does/not/exist");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
 // #86: agent_task_events — appendTaskEvent and getTaskEvents
 // ---------------------------------------------------------------------------
 test("#86: appendTaskEvent inserts a row and getTaskEvents returns it ordered by seq", async () => {