pretticlaw 0.1.0

package/dist/web/server.js

@@ -0,0 +1,169 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:http";
+import { loadConfig, saveConfig } from "../config/loader.js";
+function dashboardDir() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(here, "../dashboard"),
+        path.resolve(here, "../../src/dashboard"),
+        path.resolve(process.cwd(), "dist/dashboard"),
+        path.resolve(process.cwd(), "src/dashboard"),
+    ];
+    const found = candidates.find((p) => fs.existsSync(path.join(p, "index.html")));
+    return found ?? candidates[candidates.length - 1];
+}
+function readBody(req) {
+    return new Promise((resolve) => {
+        let buf = "";
+        req.on("data", (c) => {
+            buf += c.toString();
+            if (buf.length > 2_000_000)
+                req.destroy();
+        });
+        req.on("end", () => {
+            try {
+                resolve(buf ? JSON.parse(buf) : {});
+            }
+            catch {
+                resolve({});
+            }
+        });
+        req.on("error", () => resolve({}));
+    });
+}
+function sendJson(res, status, data) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(data));
+}
+function contentType(file) {
+    if (file.endsWith(".html"))
+        return "text/html; charset=utf-8";
+    if (file.endsWith(".js"))
+        return "text/javascript; charset=utf-8";
+    if (file.endsWith(".css"))
+        return "text/css; charset=utf-8";
+    if (file.endsWith(".json"))
+        return "application/json; charset=utf-8";
+    if (file.endsWith(".svg"))
+        return "image/svg+xml";
+    return "application/octet-stream";
+}
+export function startDashboardServer(input) {
+    const staticDir = dashboardDir();
+    const server = createServer(async (req, res) => {
+        const method = req.method || "GET";
+        const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+        const pathname = url.pathname;
+        if (method === "GET" && pathname === "/api/status") {
+            const cfg = loadConfig();
+            return sendJson(res, 200, {
+                provider: cfg.agents.defaults.provider,
+                model: cfg.agents.defaults.model,
+                cron: input.cron.status(),
+                channels: cfg.channels,
+                gateway: cfg.gateway,
+            });
+        }
+        if (method === "GET" && pathname === "/api/history") {
+            const session = input.sessionManager.getOrCreate(input.sessionKey);
+            const messages = (session.messages || []).map(msg => {
+                if (msg && Array.isArray(msg.tool_calls)) {
+                    return { ...msg, tool_calls: msg.tool_calls };
+                }
+                return msg;
+            });
+            return sendJson(res, 200, { messages });
+        }
+        if (method === "POST" && pathname === "/api/chat") {
+            const body = await readBody(req);
+            const message = String(body.message ?? "").trim();
+            const session = String(body.session ?? "web:dashboard");
+            if (!message)
+                return sendJson(res, 400, { error: "message required" });
+            const progress = [];
+            try {
+                const response = await input.agent.processDirect(message, session, "cli", "dashboard", async (content, meta) => {
+                    // meta.tool_calls may exist (array of tool call objects)
+                    progress.push({ content, toolHint: !!meta?.toolHint, tool_calls: meta?.tool_calls });
+                });
+                return sendJson(res, 200, { response, progress });
+            }
+            catch (err) {
+                return sendJson(res, 500, { error: String(err) });
+            }
+        }
+        if (method === "GET" && pathname === "/api/config") {
+            return sendJson(res, 200, loadConfig());
+        }
+        if (method === "PUT" && pathname === "/api/config") {
+            const raw = await readBody(req);
+            const cfg = raw;
+            saveConfig(cfg);
+            return sendJson(res, 200, { ok: true });
+        }
+        if (method === "GET" && pathname === "/api/cron/jobs") {
+            const includeDisabled = url.searchParams.get("all") === "1";
+            return sendJson(res, 200, input.cron.listJobs(includeDisabled));
+        }
+        if (method === "POST" && pathname === "/api/cron/jobs") {
+            const body = await readBody(req);
+            try {
+                const job = input.cron.addJob({
+                    name: String(body.name ?? "job"),
+                    schedule: body.schedule,
+                    message: String(body.message ?? ""),
+                    deliver: !!body.deliver,
+                    channel: body.channel ? String(body.channel) : undefined,
+                    to: body.to ? String(body.to) : undefined,
+                    deleteAfterRun: !!body.deleteAfterRun,
+                });
+                return sendJson(res, 200, job);
+            }
+            catch (err) {
+                return sendJson(res, 400, { error: String(err) });
+            }
+        }
+        const cronIdMatch = pathname.match(/^\/api\/cron\/jobs\/([^/]+)$/);
+        if (cronIdMatch && method === "DELETE") {
+            return sendJson(res, 200, { ok: input.cron.removeJob(cronIdMatch[1]) });
+        }
+        const cronEnableMatch = pathname.match(/^\/api\/cron\/jobs\/([^/]+)\/enable$/);
+        if (cronEnableMatch && method === "POST") {
+            const body = await readBody(req);
+            const enabled = body.enabled !== false;
+            const job = input.cron.enableJob(cronEnableMatch[1], enabled);
+            if (!job)
+                return sendJson(res, 404, { error: "not found" });
+            return sendJson(res, 200, job);
+        }
+        const cronRunMatch = pathname.match(/^\/api\/cron\/jobs\/([^/]+)\/run$/);
+        if (cronRunMatch && method === "POST") {
+            const body = await readBody(req);
+            const ok = await input.cron.runJob(cronRunMatch[1], !!body.force);
+            return sendJson(res, 200, { ok });
+        }
+        let filePath = path.join(staticDir, pathname === "/" ? "index.html" : pathname.slice(1));
+        if (!filePath.startsWith(staticDir))
+            filePath = path.join(staticDir, "index.html");
+        if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+            filePath = path.join(staticDir, "index.html");
+        }
+        if (!fs.existsSync(filePath)) {
+            res.statusCode = 404;
+            res.end("Dashboard assets not found. Run npm run build.");
+            return;
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", contentType(filePath));
+        fs.createReadStream(filePath).pipe(res);
+    });
+    const port = input.port ?? 6767;
+    server.listen(port);
+    return {
+        port,
+        close: () => new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve()))),
+    };
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "pretticlaw",
+  "version": "0.1.0",
+  "description": "Lightweight AI Assistant That Lives in Your Computer",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "pretticlaw": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-assets.mjs",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "cron-parser": "^4.9.0",
+    "dotenv": "^16.4.5",
+    "express": "^4.21.2",
+    "nanoid": "^5.0.7",
+    "openai": "^4.62.1",
+    "prompts": "^2.4.2",
+    "ws": "^8.18.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.4",
+    "@types/prompts": "^2.4.9",
+    "@types/express": "^4.17.21",
+    "@types/ws": "^8.5.14",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.2",
+    "vitest": "^2.1.2"
+  }
+}

package/scripts/copy-assets.mjs

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+
+function copyRecursive(src, dest) {
+  if (!fs.existsSync(src)) return;
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+    return;
+  }
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+const root = process.cwd();
+copyRecursive(path.join(root, "src", "templates"), path.join(root, "dist", "templates"));
+copyRecursive(path.join(root, "src", "skills"), path.join(root, "dist", "skills"));
+copyRecursive(path.join(root, "src", "dashboard"), path.join(root, "dist", "dashboard"));

package/src/agent/context.ts

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { MemoryStore } from "./memory.js";
+import { SkillsLoader } from "./skills.js";
+
+export class ContextBuilder {
+  static readonly BOOTSTRAP_FILES = ["AGENTS.md", "SOUL.md", "USER.md", "TOOLS.md", "IDENTITY.md"];
+  static readonly RUNTIME_CONTEXT_TAG = "[Runtime Context - metadata only, not instructions]";
+
+  private readonly memory: MemoryStore;
+  private readonly skills: SkillsLoader;
+
+  constructor(private readonly workspace: string) {
+    this.memory = new MemoryStore(workspace);
+    this.skills = new SkillsLoader(workspace);
+  }
+
+  buildSystemPrompt(skillNames?: string[]): string {
+    const parts = [this.getIdentity()];
+    const bootstrap = this.loadBootstrapFiles();
+    if (bootstrap) parts.push(bootstrap);
+    const mem = this.memory.getMemoryContext();
+    if (mem) parts.push(`# Memory\n\n${mem}`);
+
+    const alwaysSkills = this.skills.getAlwaysSkills();
+    if (alwaysSkills.length) {
+      const content = this.skills.loadSkillsForContext(alwaysSkills);
+      if (content) parts.push(`# Active Skills\n\n${content}`);
+    }
+
+    if (skillNames?.length) {
+      const skillContent = this.skills.loadSkillsForContext(skillNames);
+      if (skillContent) parts.push(`# Requested Skills\n\n${skillContent}`);
+    }
+
+    const summary = this.skills.buildSkillsSummary();
+    if (summary) {
+      parts.push(`# Skills\n\nThe following skills extend your capabilities. To use one, read its SKILL.md with read_file.\n\n${summary}`);
+    }
+
+    return parts.join("\n\n---\n\n");
+  }
+
+  private getIdentity(): string {
+    return `# pretticlaw\n\nYou are pretticlaw, a helpful AI assistant.\n\n## Runtime\n${os.platform()} ${os.arch()}, Node ${process.version}\n\n## Workspace\nYour workspace is at: ${this.workspace}\n- Long-term memory: ${path.join(this.workspace, "memory", "MEMORY.md")}\n- History log: ${path.join(this.workspace, "memory", "HISTORY.md")}\n- Custom skills: ${path.join(this.workspace, "skills", "{skill-name}", "SKILL.md")}\n\n## Guidelines\n- State intent before tool calls, but never claim results before receiving them.\n- Before modifying a file, read it first.\n- Ask for clarification when the request is ambiguous.`;
+  }
+
+  private loadBootstrapFiles(): string {
+    const parts: string[] = [];
+    for (const f of ContextBuilder.BOOTSTRAP_FILES) {
+      const p = path.join(this.workspace, f);
+      if (!fs.existsSync(p)) continue;
+      parts.push(`## ${f}\n\n${fs.readFileSync(p, "utf8")}`);
+    }
+    return parts.join("\n\n");
+  }
+
+  static buildRuntimeContext(channel?: string, chatId?: string): string {
+    const now = new Date();
+    const lines = [`Current Time: ${now.toISOString()}`];
+    if (channel && chatId) {
+      lines.push(`Channel: ${channel}`);
+      lines.push(`Chat ID: ${chatId}`);
+    }
+    return `${ContextBuilder.RUNTIME_CONTEXT_TAG}\n${lines.join("\n")}`;
+  }
+
+  buildMessages(input: { history: Array<Record<string, unknown>>; currentMessage: string; skillNames?: string[]; media?: string[]; channel?: string; chatId?: string }): Array<Record<string, unknown>> {
+    return [
+      { role: "system", content: this.buildSystemPrompt(input.skillNames) },
+      ...input.history,
+      { role: "user", content: ContextBuilder.buildRuntimeContext(input.channel, input.chatId) },
+      { role: "user", content: input.currentMessage },
+    ];
+  }
+
+  addToolResult(messages: Array<Record<string, unknown>>, toolCallId: string, toolName: string, result: string): Array<Record<string, unknown>> {
+    messages.push({ role: "tool", tool_call_id: toolCallId, name: toolName, content: result });
+    return messages;
+  }
+
+  addAssistantMessage(messages: Array<Record<string, unknown>>, content: string | null, toolCalls?: Array<Record<string, unknown>>, reasoningContent?: string | null): Array<Record<string, unknown>> {
+    const msg: Record<string, unknown> = { role: "assistant", content };
+    if (toolCalls?.length) msg.tool_calls = toolCalls;
+    if (reasoningContent != null) msg.reasoning_content = reasoningContent;
+    messages.push(msg);
+    return messages;
+  }
+}

package/src/agent/loop.ts

@@ -0,0 +1,291 @@
+import path from "node:path";
+import { ContextBuilder } from "./context.js";
+import { MemoryStore } from "./memory.js";
+import { SubagentManager } from "./subagent.js";
+import { ReadFileTool, WriteFileTool, EditFileTool, ListDirTool } from "./tools/filesystem.js";
+import { ExecTool } from "./tools/shell.js";
+import { WebSearchTool, WebFetchTool } from "./tools/web.js";
+import { MessageTool } from "./tools/message.js";
+import { SpawnTool } from "./tools/spawn.js";
+import { CronTool } from "./tools/cron.js";
+import { ToolRegistry } from "./tools/registry.js";
+import type { MessageBus } from "../bus/queue.js";
+import type { InboundMessage, OutboundMessage } from "../bus/events.js";
+import { sessionKey as getSessionKey } from "../bus/events.js";
+import type { LLMProvider } from "../providers/base.js";
+import { SessionManager, type Session } from "../session/manager.js";
+import type { CronService } from "../cron/service.js";
+
+function stripThink(text: string | null): string | null {
+  if (!text) return null;
+  return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim() || null;
+}
+
+type ProgressFn = (content: string, meta?: { toolHint?: boolean; tool_calls?: any[] }) => Promise<void>;
+
+export class AgentLoop {
+  private readonly context: ContextBuilder;
+  private readonly sessions: SessionManager;
+  readonly tools: ToolRegistry;
+  readonly subagents: SubagentManager;
+  private running = false;
+  private readonly consolidating = new Set<string>();
+  private readonly activeTasks = new Map<string, Set<Promise<void>>>();
+  private processing = Promise.resolve();
+  private static readonly TOOL_RESULT_MAX_CHARS = 500;
+
+  constructor(private readonly input: {
+    bus: MessageBus;
+    provider: LLMProvider;
+    workspace: string;
+    model?: string;
+    maxIterations?: number;
+    temperature?: number;
+    maxTokens?: number;
+    memoryWindow?: number;
+    braveApiKey?: string | null;
+    execConfig?: { timeout: number; pathAppend: string };
+    cronService?: CronService;
+    restrictToWorkspace?: boolean;
+    sessionManager?: SessionManager;
+    channelsConfig?: { sendProgress: boolean; sendToolHints: boolean };
+  }) {
+    const workspace = path.resolve(input.workspace);
+    this.context = new ContextBuilder(workspace);
+    this.sessions = input.sessionManager ?? new SessionManager(workspace);
+    this.tools = new ToolRegistry();
+
+    const model = input.model ?? input.provider.getDefaultModel();
+    this.subagents = new SubagentManager(
+      input.provider,
+      workspace,
+      input.bus,
+      model,
+      input.temperature ?? 0.1,
+      input.maxTokens ?? 4096,
+      input.braveApiKey ?? null,
+      input.execConfig ?? { timeout: 60, pathAppend: "" },
+      !!input.restrictToWorkspace,
+    );
+
+    this.registerDefaultTools();
+  }
+
+  get model(): string {
+    return this.input.model ?? this.input.provider.getDefaultModel();
+  }
+
+  get channelsConfig(): { sendProgress: boolean; sendToolHints: boolean } | undefined {
+    return this.input.channelsConfig;
+  }
+
+  private registerDefaultTools(): void {
+    const workspace = path.resolve(this.input.workspace);
+    const allowed = this.input.restrictToWorkspace ? workspace : undefined;
+    this.tools.register(new ReadFileTool(workspace, allowed));
+    this.tools.register(new WriteFileTool(workspace, allowed));
+    this.tools.register(new EditFileTool(workspace, allowed));
+    this.tools.register(new ListDirTool(workspace, allowed));
+    this.tools.register(new ExecTool(this.input.execConfig?.timeout ?? 60, workspace, !!this.input.restrictToWorkspace, this.input.execConfig?.pathAppend ?? ""));
+    this.tools.register(new WebSearchTool(this.input.braveApiKey ?? null));
+    this.tools.register(new WebFetchTool());
+    this.tools.register(new MessageTool((msg) => this.input.bus.publishOutbound(msg)));
+    this.tools.register(new SpawnTool(this.subagents));
+    if (this.input.cronService) this.tools.register(new CronTool(this.input.cronService));
+  }
+
+  private setToolContext(channel: string, chatId: string, messageId?: string): void {
+    const message = this.tools.get("message");
+    if (message && message instanceof MessageTool) message.setContext(channel, chatId, messageId);
+    const spawn = this.tools.get("spawn") as any;
+    if (spawn?.setContext) spawn.setContext(channel, chatId);
+    const cron = this.tools.get("cron") as any;
+    if (cron?.setContext) cron.setContext(channel, chatId);
+  }
+
+  private toolHint(toolCalls: Array<{ name: string; arguments: Record<string, unknown> }>): string {
+    return toolCalls.map((tc) => {
+      const val = Object.values(tc.arguments ?? {})[0];
+      if (typeof val !== "string") return tc.name;
+      return val.length > 40 ? `${tc.name}("${val.slice(0, 40)}...")` : `${tc.name}("${val}")`;
+    }).join(", ");
+  }
+
+  private async runAgentLoop(initialMessages: Array<Record<string, unknown>>, onProgress?: ProgressFn): Promise<{ finalContent: string | null; toolsUsed: string[]; messages: Array<Record<string, unknown>> }> {
+    const messages = [...initialMessages];
+    let finalContent: string | null = null;
+    const toolsUsed: string[] = [];
+    const maxIterations = this.input.maxIterations ?? 40;
+
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+      const response = await this.input.provider.chat({
+        messages,
+        tools: this.tools.getDefinitions(),
+        model: this.model,
+        temperature: this.input.temperature ?? 0.1,
+        maxTokens: this.input.maxTokens ?? 4096,
+      });
+
+      if (response.toolCalls.length) {
+        if (onProgress) {
+          const clean = stripThink(response.content);
+          if (clean) await onProgress(clean, { toolHint: false });
+          await onProgress(this.toolHint(response.toolCalls), { toolHint: true });
+        }
+
+        const toolCallDicts = response.toolCalls.map((tc) => ({ id: tc.id, type: "function", function: { name: tc.name, arguments: JSON.stringify(tc.arguments) } }));
+        this.context.addAssistantMessage(messages, response.content, toolCallDicts, response.reasoningContent);
+
+        for (const call of response.toolCalls) {
+          toolsUsed.push(call.name);
+          const result = await this.tools.execute(call.name, call.arguments);
+          this.context.addToolResult(messages, call.id, call.name, result);
+        }
+      } else {
+        finalContent = stripThink(response.content);
+        this.context.addAssistantMessage(messages, finalContent, undefined, response.reasoningContent);
+        break;
+      }
+    }
+
+    if (finalContent == null) {
+      finalContent = `I reached the maximum number of tool call iterations (${maxIterations}) without completing the task.`;
+    }
+
+    return { finalContent, toolsUsed, messages };
+  }
+
+  async run(): Promise<void> {
+    this.running = true;
+    while (this.running) {
+      const msg = await this.input.bus.consumeInbound();
+      if (msg.content.trim().toLowerCase() === "/stop") {
+        await this.handleStop(msg);
+        continue;
+      }
+      const session = getSessionKey(msg);
+      const task = this.dispatch(msg).finally(() => {
+        const set = this.activeTasks.get(session);
+        if (!set) return;
+        set.delete(task);
+        if (!set.size) this.activeTasks.delete(session);
+      });
+      if (!this.activeTasks.has(session)) this.activeTasks.set(session, new Set());
+      this.activeTasks.get(session)!.add(task);
+    }
+  }
+
+  stop(): void {
+    this.running = false;
+  }
+
+  async processDirect(content: string, session = "cli:direct", channel = "cli", chatId = "direct", onProgress?: ProgressFn): Promise<string> {
+    const msg: InboundMessage = { channel, senderId: "user", chatId, content };
+    const out = await this.processMessage(msg, session, onProgress);
+    return out?.content ?? "";
+  }
+
+  private async dispatch(msg: InboundMessage): Promise<void> {
+    this.processing = this.processing.then(async () => {
+      try {
+        const response = await this.processMessage(msg);
+        if (response) {
+          await this.input.bus.publishOutbound(response);
+        } else if (msg.channel === "cli") {
+          await this.input.bus.publishOutbound({ channel: msg.channel, chatId: msg.chatId, content: "", metadata: msg.metadata ?? {} });
+        }
+      } catch {
+        await this.input.bus.publishOutbound({ channel: msg.channel, chatId: msg.chatId, content: "Sorry, I encountered an error." });
+      }
+    });
+    return this.processing;
+  }
+
+  private async handleStop(msg: InboundMessage): Promise<void> {
+    const key = getSessionKey(msg);
+    const tasks = [...(this.activeTasks.get(key) ?? [])];
+    const subCancelled = await this.subagents.cancelBySession(key);
+    const total = tasks.length + subCancelled;
+    await this.input.bus.publishOutbound({ channel: msg.channel, chatId: msg.chatId, content: total ? `Stopped ${total} task(s).` : "No active task to stop." });
+  }
+
+  private async consolidateMemory(session: Session, archiveAll = false): Promise<boolean> {
+    return new MemoryStore(this.input.workspace).consolidate(session, this.input.provider, this.model, { archiveAll, memoryWindow: this.input.memoryWindow ?? 100 });
+  }
+
+  private saveTurn(session: Session, messages: Array<Record<string, unknown>>, skip: number): void {
+    for (const m of messages.slice(skip)) {
+      const entry: Record<string, unknown> = { ...m };
+      delete entry.reasoning_content;
+      if (entry.role === "tool" && typeof entry.content === "string" && entry.content.length > AgentLoop.TOOL_RESULT_MAX_CHARS) {
+        entry.content = `${entry.content.slice(0, AgentLoop.TOOL_RESULT_MAX_CHARS)}\n... (truncated)`;
+      }
+      if (entry.role === "user" && typeof entry.content === "string" && entry.content.startsWith(ContextBuilder.RUNTIME_CONTEXT_TAG)) continue;
+      if (!entry.timestamp) entry.timestamp = new Date().toISOString();
+      session.messages.push(entry as any);
+    }
+    session.updatedAt = new Date().toISOString();
+  }
+
+  async processMessage(msg: InboundMessage, sessionKeyOverride?: string, onProgress?: ProgressFn): Promise<OutboundMessage | null> {
+    if (msg.channel === "system") {
+      const [channel, chatId] = String(msg.chatId).includes(":") ? String(msg.chatId).split(/:(.*)/s, 2) : ["cli", String(msg.chatId)];
+      const key = `${channel}:${chatId}`;
+      const session = this.sessions.getOrCreate(key);
+      this.setToolContext(channel, chatId, msg.metadata?.message_id as string | undefined);
+      const history = session.getHistory(this.input.memoryWindow ?? 100);
+      const messages = this.context.buildMessages({ history, currentMessage: msg.content, channel, chatId });
+      const { finalContent, messages: allMsgs } = await this.runAgentLoop(messages);
+      this.saveTurn(session, allMsgs, 1 + history.length);
+      this.sessions.save(session);
+      return { channel, chatId, content: finalContent ?? "Background task completed." };
+    }
+
+    const key = sessionKeyOverride ?? getSessionKey(msg);
+    const session = this.sessions.getOrCreate(key);
+    const cmd = msg.content.trim().toLowerCase();
+
+    if (cmd === "/new") {
+      if (session.messages.length) {
+        const ok = await this.consolidateMemory(session, true);
+        if (!ok) return { channel: msg.channel, chatId: msg.chatId, content: "Memory archival failed, session not cleared. Please try again." };
+      }
+      session.clear();
+      this.sessions.save(session);
+      this.sessions.invalidate(session.key);
+      return { channel: msg.channel, chatId: msg.chatId, content: "New session started." };
+    }
+
+    if (cmd === "/help") {
+      return { channel: msg.channel, chatId: msg.chatId, content: "pretticlaw commands:\n/new - Start a new conversation\n/stop - Stop the current task\n/help - Show available commands" };
+    }
+
+    const unconsolidated = session.messages.length - session.lastConsolidated;
+    if (unconsolidated >= (this.input.memoryWindow ?? 100) && !this.consolidating.has(session.key)) {
+      this.consolidating.add(session.key);
+      void this.consolidateMemory(session).finally(() => this.consolidating.delete(session.key));
+    }
+
+    this.setToolContext(msg.channel, msg.chatId, msg.metadata?.message_id as string | undefined);
+    const messageTool = this.tools.get("message");
+    if (messageTool instanceof MessageTool) messageTool.startTurn();
+
+    const history = session.getHistory(this.input.memoryWindow ?? 100);
+    const initialMessages = this.context.buildMessages({ history, currentMessage: msg.content, media: msg.media, channel: msg.channel, chatId: msg.chatId });
+
+    const busProgress: ProgressFn = async (content, meta) => {
+      const metadata = { ...(msg.metadata ?? {}), _progress: true, _tool_hint: !!meta?.toolHint } as Record<string, unknown>;
+      await this.input.bus.publishOutbound({ channel: msg.channel, chatId: msg.chatId, content, metadata });
+    };
+
+    const { finalContent, messages: allMsgs } = await this.runAgentLoop(initialMessages, onProgress ?? busProgress);
+    const out = finalContent ?? "I've completed processing but have no response to give.";
+
+    this.saveTurn(session, allMsgs, 1 + history.length);
+    this.sessions.save(session);
+
+    if (messageTool instanceof MessageTool && messageTool.sentInTurn) return null;
+
+    return { channel: msg.channel, chatId: msg.chatId, content: out, metadata: msg.metadata ?? {} };
+  }
+}