pi-squad 0.17.2 → 0.18.0

package/src/scheduler-runtime.ts

@@ -0,0 +1,117 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { logError } from "./logger.js";
+import { buildCompletionSummary, buildFailureSummary } from "./report.js";
+import { buildOrchestratorReviewGate } from "./review.js";
+import { Scheduler, formatSuspendedStallAttention, type SchedulerEvent } from "./scheduler.js";
+import * as store from "./store.js";
+import type { SuspendedStallAttention } from "./types.js";
+import { forceWidgetUpdate, formatTaskProgress, focusSquad, repairFocusAfterCancellation, runtime, schedulerSpawnContext } from "./runtime.js";
+
+/** Wire one scheduler to durable main-session notifications. */
+export function wireSchedulerEvents(pi: ExtensionAPI, scheduler: Scheduler, squadId: string): void {
+	scheduler.onEvent((event: SchedulerEvent) => {
+		// Durable scheduler state remains authoritative, but disabled mode suppresses
+		// late operational UI, acknowledgements, focus, and ordinary notifications.
+		if (!runtime.squadEnabled) return;
+		forceWidgetUpdate();
+		switch (event.type) {
+			case "squad_review_required": {
+				const tasks = store.loadAllTasks(squadId);
+				const squad = store.loadSquad(squadId);
+				const summary = buildCompletionSummary(tasks, squad?.cwd);
+				const totalCost = tasks.reduce((sum, task) => sum + task.usage.cost, 0);
+				scheduler.updateContext();
+				if (!squad) break;
+				pi.sendMessage({
+					customType: "squad-review-required",
+					content: `[squad] TASK EXECUTION FINISHED for "${squadId}" — WORK IS UNTRUSTED AND NOT YET ACCEPTED.\n\n` +
+						`Squad claims (review inputs only):\n${summary}\n\n` +
+						`Total cost: $${totalCost.toFixed(4)}\n\n` +
+						buildOrchestratorReviewGate(squad, tasks),
+					display: true,
+				}, { triggerTurn: true, deliverAs: "followUp" });
+				// Keep the settled scheduler addressable. A later exact-task message
+				// can reopen the task immediately on its bound durable Pi session.
+				break;
+			}
+			case "suspended_stall": {
+				try {
+					const attention = event.data as SuspendedStallAttention;
+					pi.sendMessage({
+						customType: `squad-suspended-stall:${squadId}:${attention.fingerprint}`,
+						content: formatSuspendedStallAttention(squadId, attention),
+						display: true,
+					}, { triggerTurn: true, deliverAs: "followUp" });
+					scheduler.acknowledgeSuspendedStall(attention.fingerprint);
+				} catch (error) {
+					logError("squad-scheduler", `suspended-stall delivery failed for ${squadId}: ${(error as Error).message}`);
+				}
+				break;
+			}
+			case "squad_failed": {
+				const tasks = store.loadAllTasks(squadId);
+				const failed = tasks.filter((task) => task.status === "failed");
+				pi.sendMessage({
+					customType: "squad-failed",
+					content: `[squad] Squad "${squadId}" has stalled. ` +
+						`${formatTaskProgress(tasks)}, ${failed.length} failed.\n` +
+						`Failed: ${buildFailureSummary(tasks)}\n` +
+						"Use squad_status for details or squad_modify to adjust.",
+					display: true,
+				}, { triggerTurn: true, deliverAs: "followUp" });
+				break;
+			}
+			case "orchestrator_reply":
+				pi.sendMessage({
+					customType: "squad-agent-reply",
+					content: `[squad] Direct reply from '${event.agentName}' on task '${event.taskId}':\n${event.message}`,
+					display: true,
+				}, { triggerTurn: true, deliverAs: "followUp" });
+				break;
+			case "escalation":
+				pi.sendMessage({
+					customType: "squad-escalation",
+					content: `[squad] Agent '${event.agentName}' on task '${event.taskId}' needs attention:\n` +
+						`${event.message}\n\nReply to me and I'll forward your answer, or use the squad panel.`,
+					display: true,
+				}, { triggerTurn: true });
+				break;
+		}
+	});
+}
+
+/** Cancel one persisted exact squad without ever inferring or changing focus. */
+export async function cancelExactSquad(squadId: string, skillPaths: string[]): Promise<boolean> {
+	const squad = store.loadSquad(squadId);
+	if (!squad) return false;
+	const live = runtime.schedulers.get(squadId);
+	if (live) await live.stop();
+	else await new Scheduler(squadId, skillPaths, schedulerSpawnContext).stop();
+	const fresh = store.loadSquad(squadId);
+	if (fresh) {
+		fresh.status = "failed";
+		delete fresh.suspendedStallAttention;
+		store.saveSquad(fresh);
+	}
+	runtime.schedulers.delete(squadId);
+	repairFocusAfterCancellation(squadId);
+	return true;
+}
+
+/** Reconstruct one exact persisted squad without changing focus or starting work. */
+export function reviveScheduler(pi: ExtensionAPI, squadId: string, skillPaths: string[]): Scheduler {
+	let scheduler = runtime.schedulers.get(squadId);
+	if (!scheduler) {
+		scheduler = new Scheduler(squadId, skillPaths, schedulerSpawnContext);
+		runtime.schedulers.set(squadId, scheduler);
+		wireSchedulerEvents(pi, scheduler, squadId);
+	}
+	return scheduler;
+}
+
+/** Reconstruct and focus one exact persisted squad without creating/linking another. */
+export function ensureScheduler(pi: ExtensionAPI, squadId: string, skillPaths: string[]): Scheduler {
+	const scheduler = reviveScheduler(pi, squadId, skillPaths);
+	focusSquad(squadId);
+	return scheduler;
+}

package/src/scheduler.ts

@@ -797,159 +797,173 @@ export class Scheduler {
 
 	private handleAgentEvent(event: AgentEvent): void {
 		switch (event.type) {
-			case "message_end": {
-				const msg = event.data;
-				if (msg?.role === "assistant") {
-					// Extract text from assistant message
-					const text = this.extractAssistantText(msg);
-					if (text) {
-						// Route @mentions
-						this.router.processMessage(event.taskId, event.agentName, text);
-
-						// Log message
-						store.appendMessage(this.squadId, event.taskId, {
-							ts: store.now(),
-							from: event.agentName,
-							type: "text",
-							// Persist the complete handoff. Reports can be arbitrarily long;
-							// presentation layers may viewport them, but source data must never truncate.
-							text,
-						});
-
-						// A squad_message is a request/response channel, not fire-and-forget.
-						// Persist an acknowledgement marker before emitting so restart/focus
-						// changes cannot forward the same response twice.
-						if (this.hasPendingOrchestratorRequest(event.taskId)) {
-							store.appendMessage(this.squadId, event.taskId, {
-								ts: store.now(),
-								from: event.agentName,
-								type: "reply",
-								to: "orchestrator",
-								text: "Response forwarded to main orchestrator",
-							});
-							this.emit({
-								type: "orchestrator_reply",
-								squadId: this.squadId,
-								taskId: event.taskId,
-								agentName: event.agentName,
-								message: text,
-							});
-						}
-					}
-
-					// Track usage
-					if (msg.usage) {
-						store.updateTaskUsage(this.squadId, event.taskId, {
-							inputTokens: msg.usage.input || 0,
-							outputTokens: msg.usage.output || 0,
-							cost: msg.usage.cost?.total || 0,
-							turns: 1,
-						});
-					}
-				}
+			case "message_end":
+				this.onMessageEnd(event);
 				break;
-			}
+			case "tool_execution_start":
+				this.onToolExecutionStart(event);
+				break;
+			case "tool_execution_end":
+				this.onToolExecutionEnd(event);
+				break;
+			case "agent_end":
+				if (this.onAgentEnd(event)) return;
+				break;
+			case "agent_settled":
+				this.onAgentSettled(event);
+				return;
+			case "error":
+				this.onError(event);
+				break;
+		}
 
-			case "tool_execution_start": {
-				const data = event.data;
+		this.updateContext();
+	}
+
+	private onMessageEnd(event: AgentEvent): void {
+		const msg = event.data;
+		if (msg?.role === "assistant") {
+			// Extract text from assistant message
+			const text = this.extractAssistantText(msg);
+			if (text) {
+				// Route @mentions
+				this.router.processMessage(event.taskId, event.agentName, text);
+
+				// Log message
 				store.appendMessage(this.squadId, event.taskId, {
 					ts: store.now(),
 					from: event.agentName,
-					type: "tool",
-					text: data.toolName || "unknown",
-					name: data.toolName,
-					args: data.args,
+					type: "text",
+					// Persist the complete handoff. Reports can be arbitrarily long;
+					// presentation layers may viewport them, but source data must never truncate.
+					text,
 				});
 
-				this.emit({
-					type: "activity",
-					squadId: this.squadId,
-					taskId: event.taskId,
-					agentName: event.agentName,
-					message: `→ ${data.toolName}`,
-					data,
-				});
-				break;
-			}
-
-			case "tool_execution_end": {
-				// Track file modifications
-				const data = event.data;
-				if (data.toolName === "write" || data.toolName === "edit") {
-					const filePath = data.args?.path || data.args?.file_path;
-					if (filePath) {
-						this.updateModifiedFiles(event.agentName, filePath);
-					}
-				}
-				break;
-			}
-
-			case "agent_end": {
-				// Pi's low-level agent_end is not completion. AgentPool normally keeps
-				// it internal; if observed here, preserve in_progress. Only an actual
-				// child-process exit carries unexpectedExit and enters retry handling.
-				if (!event.data?.unexpectedExit) break;
-				this.handleUnexpectedAgentExit(event);
-				return;
-			}
-
-			case "agent_settled": {
-				const settledTask = store.loadTask(this.squadId, event.taskId);
-				const status = settledTask?.status;
-				if (status === "cancelled" || status === "suspended") return;
-				const settledSquad = store.loadSquad(this.squadId);
-				if (settledTask && settledSquad && !validateTaskSpecAttestation(settledSquad, settledTask)) {
-					store.updateTaskStatus(this.squadId, event.taskId, "pending", { completed: null, output: null, error: "Canonical squad spec was not fully delivered; read all chunks with squad_spec_read" });
-					store.appendMessage(this.squadId, event.taskId, { ts: store.now(), from: "system", type: "status", text: "Completion rejected: missing or invalid spec-read-attestation; reopening same task session" });
-					if (this.running) void this.reconcile();
-					this.updateContext();
-					return;
-				}
-				// A mailbox entry not acknowledged by Pi outranks this run's candidate
-				// completion. Reopen the same session so accepted-at-least-once delivery
-				// occurs before the task can become done.
-				if (store.loadPendingTaskMessages(this.squadId, event.taskId).length > 0) {
-					store.updateTaskStatus(this.squadId, event.taskId, "pending", { completed: null });
+				// A squad_message is a request/response channel, not fire-and-forget.
+				// Persist an acknowledgement marker before emitting so restart/focus
+				// changes cannot forward the same response twice.
+				if (this.hasPendingOrchestratorRequest(event.taskId)) {
 					store.appendMessage(this.squadId, event.taskId, {
 						ts: store.now(),
-						from: "system",
-						type: "status",
-						text: "Agent settled with pending durable messages; resuming the same task session",
+						from: event.agentName,
+						type: "reply",
+						to: "orchestrator",
+						text: "Response forwarded to main orchestrator",
 					});
-					if (this.running) void this.reconcile();
-					this.updateContext();
-					return;
-				}
-
-				const turnCount = event.data?.turnCount ?? 0;
-				const toolCallCount = event.data?.toolCallCount ?? 0;
-				const hasSubstantiveOutput = store.loadMessages(this.squadId, event.taskId)
-					.some((message) => message.from === event.agentName && message.type === "text" && message.text.trim().length > 0);
-				const hadMeaningfulWork = turnCount > 0 && (toolCallCount > 0 || hasSubstantiveOutput);
-				if (hadMeaningfulWork) {
-					this.handleTaskCompleted(event.taskId).then(() => this.updateContext());
-				} else {
-					this.handleUnexpectedAgentExit({
-						...event,
-						data: { ...event.data, unexpectedExit: true },
+					this.emit({
+						type: "orchestrator_reply",
+						squadId: this.squadId,
+						taskId: event.taskId,
+						agentName: event.agentName,
+						message: text,
 					});
 				}
-				return;
 			}
 
-			case "error": {
-				const errorMsg = event.data?.message || "Unknown error";
-				store.appendMessage(this.squadId, event.taskId, {
-					ts: store.now(),
-					from: "system",
-					type: "error",
-					text: errorMsg,
+			// Track usage
+			if (msg.usage) {
+				store.updateTaskUsage(this.squadId, event.taskId, {
+					inputTokens: msg.usage.input || 0,
+					outputTokens: msg.usage.output || 0,
+					cost: msg.usage.cost?.total || 0,
+					turns: 1,
 				});
-				break;
 			}
 		}
+	}
 
-		this.updateContext();
+	private onToolExecutionStart(event: AgentEvent): void {
+		const data = event.data;
+		store.appendMessage(this.squadId, event.taskId, {
+			ts: store.now(),
+			from: event.agentName,
+			type: "tool",
+			text: data.toolName || "unknown",
+			name: data.toolName,
+			args: data.args,
+		});
+
+		this.emit({
+			type: "activity",
+			squadId: this.squadId,
+			taskId: event.taskId,
+			agentName: event.agentName,
+			message: `→ ${data.toolName}`,
+			data,
+		});
+	}
+
+	private onToolExecutionEnd(event: AgentEvent): void {
+		// Track file modifications
+		const data = event.data;
+		if (data.toolName === "write" || data.toolName === "edit") {
+			const filePath = data.args?.path || data.args?.file_path;
+			if (filePath) {
+				this.updateModifiedFiles(event.agentName, filePath);
+			}
+		}
+	}
+
+	private onAgentEnd(event: AgentEvent): boolean {
+		// Pi's low-level agent_end is not completion. AgentPool normally keeps
+		// it internal; if observed here, preserve in_progress. Only an actual
+		// child-process exit carries unexpectedExit and enters retry handling.
+		if (!event.data?.unexpectedExit) return false;
+		this.handleUnexpectedAgentExit(event);
+		return true;
+	}
+
+	private onAgentSettled(event: AgentEvent): void {
+		const settledTask = store.loadTask(this.squadId, event.taskId);
+		const status = settledTask?.status;
+		if (status === "cancelled" || status === "suspended") return;
+		const settledSquad = store.loadSquad(this.squadId);
+		if (settledTask && settledSquad && !validateTaskSpecAttestation(settledSquad, settledTask)) {
+			store.updateTaskStatus(this.squadId, event.taskId, "pending", { completed: null, output: null, error: "Canonical squad spec was not fully delivered; read all chunks with squad_spec_read" });
+			store.appendMessage(this.squadId, event.taskId, { ts: store.now(), from: "system", type: "status", text: "Completion rejected: missing or invalid spec-read-attestation; reopening same task session" });
+			if (this.running) void this.reconcile();
+			this.updateContext();
+			return;
+		}
+		// A mailbox entry not acknowledged by Pi outranks this run's candidate
+		// completion. Reopen the same session so accepted-at-least-once delivery
+		// occurs before the task can become done.
+		if (store.loadPendingTaskMessages(this.squadId, event.taskId).length > 0) {
+			store.updateTaskStatus(this.squadId, event.taskId, "pending", { completed: null });
+			store.appendMessage(this.squadId, event.taskId, {
+				ts: store.now(),
+				from: "system",
+				type: "status",
+				text: "Agent settled with pending durable messages; resuming the same task session",
+			});
+			if (this.running) void this.reconcile();
+			this.updateContext();
+			return;
+		}
+
+		const turnCount = event.data?.turnCount ?? 0;
+		const toolCallCount = event.data?.toolCallCount ?? 0;
+		const hasSubstantiveOutput = store.loadMessages(this.squadId, event.taskId)
+			.some((message) => message.from === event.agentName && message.type === "text" && message.text.trim().length > 0);
+		const hadMeaningfulWork = turnCount > 0 && (toolCallCount > 0 || hasSubstantiveOutput);
+		if (hadMeaningfulWork) {
+			this.handleTaskCompleted(event.taskId).then(() => this.updateContext());
+		} else {
+			this.handleUnexpectedAgentExit({
+				...event,
+				data: { ...event.data, unexpectedExit: true },
+			});
+		}
+	}
+
+	private onError(event: AgentEvent): void {
+		const errorMsg = event.data?.message || "Unknown error";
+		store.appendMessage(this.squadId, event.taskId, {
+			ts: store.now(),
+			from: "system",
+			type: "error",
+			text: errorMsg,
+		});
 	}
 
 	private async handleTaskCompleted(taskId: string): Promise<void> {

package/src/start-squad.ts

@@ -0,0 +1,176 @@
+import * as path from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { chunkRanges, type PreparedSpec } from "./file-spec.js";
+import { logError } from "./logger.js";
+import { validatePlan } from "./plan-rules.js";
+import { runPlanner } from "./planner.js";
+import { Scheduler } from "./scheduler.js";
+import { wireSchedulerEvents } from "./scheduler-runtime.js";
+import * as store from "./store.js";
+import type { PlannerOutput, Squad, SquadAgentEntry, SquadConfig, Task } from "./types.js";
+import { DEFAULT_SQUAD_CONFIG } from "./types.js";
+import { disabledToolResult, focusSquad, resolveSquadDefaults, runtime, schedulerSpawnContext, type InlineSquadStart } from "./runtime.js";
+
+// ============================================================================
+// Start Squad
+// ============================================================================
+
+export async function startSquad(
+	squadId: string,
+	params: InlineSquadStart,
+	cwd: string,
+	skillPaths: string[],
+	pi: ExtensionAPI,
+	sessionFile: string | null = null,
+	preparedSpec?: PreparedSpec,
+) {
+	let plan: PlannerOutput;
+
+	if (params.tasks && params.tasks.length > 0) {
+		// User provided a plan — use it directly
+		plan = {
+			agents: params.agents || {},
+			tasks: params.tasks.map((t) => ({
+				...t,
+				description: t.description || "",
+				depends: t.depends || [],
+			})),
+		};
+
+		// Validate agent names — remap unknown agents to fullstack
+		for (const task of plan.tasks) {
+			const agentDef = store.loadAgentDef(task.agent, cwd);
+			if (!agentDef || agentDef.disabled) {
+				if (preparedSpec) throw new Error(`SPEC_MALFORMED: assigned agent '${task.agent}' is missing or disabled`);
+				const original = task.agent;
+				task.agent = "fullstack";
+				task.description = `[Note: agent "${original}" not found, remapped to fullstack]\n\n${task.description}`;
+			}
+		}
+	} else {
+		// Run planner to generate task breakdown (squad default policy as fallback)
+		try {
+			const defaults = resolveSquadDefaults();
+			plan = await runPlanner({ goal: params.goal, cwd, fallbackModel: defaults.model, fallbackThinking: defaults.thinking });
+		} catch (error) {
+			// Throwing marks the tool result as an error for the LLM (returning isError is ignored in current pi)
+			throw new Error(`Failed to plan: ${(error as Error).message}`);
+		}
+	}
+
+	// A planner may take long enough for /squad disable to run concurrently.
+	// Re-check before publishing any squad or constructing a scheduler.
+	if (!runtime.squadEnabled) return disabledToolResult();
+
+	// Merge agent roster
+	const agents: Record<string, SquadAgentEntry> = { ...plan.agents };
+	if (params.agents) {
+		for (const [name, entry] of Object.entries(params.agents)) {
+			agents[name] = { ...agents[name], ...entry };
+		}
+	}
+
+	// Validate the plan — same enforcement for main-session and planner plans.
+	// Errors block squad creation; warnings are reported back to the plan author.
+	const validation = validatePlan(plan.tasks);
+	if (validation.errors.length > 0) {
+		throw new Error(
+			`Plan rejected:\n- ${validation.errors.join("\n- ")}\n\nFix the task list and call squad again.`,
+		);
+	}
+
+	// Create squad
+	const config: SquadConfig = {
+		...DEFAULT_SQUAD_CONFIG,
+		...(params.config?.maxConcurrency ? { maxConcurrency: params.config.maxConcurrency } : {}),
+		...(typeof params.config?.autoUnblock === "boolean" ? { autoUnblock: params.config.autoUnblock } : {}),
+		...(typeof params.config?.maxRetries === "number" ? { maxRetries: params.config.maxRetries } : {}),
+	};
+
+	const squad: Squad = {
+		id: squadId,
+		goal: params.goal,
+		status: "running",
+		created: store.now(),
+		cwd,
+		sessionFile,
+		agents,
+		config,
+		...(preparedSpec ? { spec: {
+			schemaVersion: 1 as const,
+			sha256: preparedSpec.sha256,
+			bytes: preparedSpec.raw.length,
+			path: path.join(store.getSquadDir(squadId), "spec", "spec.v1.json"),
+			chunkBytes: 32768 as const,
+			chunkCount: chunkRanges(preparedSpec.raw).length,
+		} } : {}),
+	};
+
+	// Materialize task state in memory so file squads can publish spec+squad+tasks atomically.
+	const initialTasks: Task[] = plan.tasks.map((taskDef) => {
+		const task: Task = {
+			id: taskDef.id,
+			title: taskDef.title,
+			description: taskDef.description,
+			agent: taskDef.agent,
+			status: taskDef.depends.length === 0 ? "pending" : "blocked",
+			depends: taskDef.depends,
+			...(taskDef.inheritContext ? { inheritContext: true } : {}),
+			created: store.now(),
+			started: null,
+			completed: null,
+			output: null,
+			error: null,
+			usage: { inputTokens: 0, outputTokens: 0, cost: 0, turns: 0 },
+		};
+		return task;
+	});
+
+	if (preparedSpec) store.publishFileSquad(squad, initialTasks, preparedSpec.raw);
+	else {
+		store.saveSquad(squad);
+		for (const task of initialTasks) store.createTask(squadId, task);
+	}
+
+	// Start scheduler
+	const scheduler = new Scheduler(squadId, skillPaths, schedulerSpawnContext);
+	runtime.schedulers.set(squadId, scheduler);
+	// Activate panel/widget/tool focus as one invariant.
+	focusSquad(squadId);
+
+	// Wire up completion/escalation notifications to main agent.
+	wireSchedulerEvents(pi, scheduler, squadId);
+
+	// Start scheduling — fire and forget, don't block the tool call.
+	// scheduler.start() spawns agents which can take seconds per agent.
+	// We must return immediately so the main agent's turn completes
+	// and the user regains interactive control.
+	scheduler.start().catch((err) => {
+		logError("squad", `Scheduler start error: ${(err as Error).message}`);
+	});
+
+	// Build response. File mode returns only the bounded descriptor; the canonical
+	// contract is never reflected back into the main model's transport.
+	const taskSummary = preparedSpec
+		? `Canonical spec: ${squad.spec!.path}\nSHA-256: ${squad.spec!.sha256}\nBytes: ${squad.spec!.bytes}\nTasks: ${plan.tasks.length}`
+		: plan.tasks
+			.map((t) => {
+				const deps = t.depends.length > 0 ? ` (depends: ${t.depends.join(", ")})` : "";
+				return `${t.id} → ${t.agent}: ${t.title}${deps}`;
+			})
+			.join("\n");
+
+	return {
+		content: [
+			{
+				type: "text" as const,
+				text: `Squad "${squadId}" started with ${plan.tasks.length} tasks.\n\n${taskSummary}${
+					validation.warnings.length > 0
+						? `\n\n⚠️ Plan warnings (fix with squad_modify, or address at review):\n- ${validation.warnings.join("\n- ")}`
+						: ""
+				}\n\nAgents work in the background — you will be woken automatically when the squad completes, fails, or needs help. Report this plan to the user and END YOUR TURN now. Do NOT poll squad_status, do NOT sleep-wait, do NOT loop.`,
+			},
+		],
+		details: undefined,
+	};
+}

package/src/store.ts

@@ -12,7 +12,6 @@ import * as os from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 import type {
 	AgentDef,
-	KnowledgeEntry,
 	Squad,
 	SquadContext,
 	Task,
@@ -103,14 +102,6 @@ export function getContextFilePath(squadId: string): string {
 	return path.join(getSquadDir(squadId), "context.json");
 }
 
-export function getKnowledgeDir(squadId: string): string {
-	return path.join(getSquadDir(squadId), "knowledge");
-}
-
-export function getMemoryFilePath(): string {
-	return path.join(getSquadRoot(), "memory.jsonl");
-}
-
 /** Resolve task dir, supporting nested subtasks via parentPath */
 export function getTaskDir(squadId: string, taskId: string, parentPath?: string): string {
 	const base = parentPath
@@ -649,28 +640,6 @@ export function saveContext(squadId: string, context: SquadContext): void {
 	writeJsonAtomic(getContextFilePath(squadId), context);
 }
 
-// ============================================================================
-// Knowledge
-// ============================================================================
-
-export function appendKnowledge(squadId: string, type: KnowledgeEntry["type"], entry: KnowledgeEntry): void {
-	const file = path.join(getKnowledgeDir(squadId), `${type}s.jsonl`);
-	appendJsonl(file, entry);
-}
-
-export function loadKnowledge(squadId: string, type: KnowledgeEntry["type"]): KnowledgeEntry[] {
-	const file = path.join(getKnowledgeDir(squadId), `${type}s.jsonl`);
-	return readJsonl<KnowledgeEntry>(file);
-}
-
-export function loadAllKnowledge(squadId: string): KnowledgeEntry[] {
-	return [
-		...loadKnowledge(squadId, "decision"),
-		...loadKnowledge(squadId, "convention"),
-		...loadKnowledge(squadId, "finding"),
-	].sort((a, b) => a.ts.localeCompare(b.ts));
-}
-
 // ============================================================================
 // Rework Helpers
 // ============================================================================
@@ -688,18 +657,6 @@ export function getRetryCount(squadId: string, taskId: string): number {
 	return findRetries(squadId, taskId).length;
 }
 
-// ============================================================================
-// Memory (cross-squad)
-// ============================================================================
-
-export function appendMemory(entry: KnowledgeEntry): void {
-	appendJsonl(getMemoryFilePath(), entry);
-}
-
-export function loadMemory(): KnowledgeEntry[] {
-	return readJsonl<KnowledgeEntry>(getMemoryFilePath());
-}
-
 // ============================================================================
 // Bootstrap — first-run agent initialization
 // ============================================================================