pi-feats 0.1.2 → 0.1.4

package/extensions/api-server/server.ts

@@ -18,6 +18,8 @@ import { ProfileStore, RESOURCE_KINDS, type ProfileSettings, type ResourceKind }
 import { ApplicationRuntime, type Settings as ApplicationSettings } from "./application-runtime.ts";
 import { ApplicationStore, type ApplicationRecord } from "./application-store.ts";
 import { applicationHandlerTemplate } from "../lib/application-handler-templates.ts";
+import { applicationExecutionContext, type ContextMemoryExecutionLog } from "../lib/application-context.ts";
+import { contextMemoryCharacters, contextMemoryConfig, contextMemoryLimit, memoryPath, readMemory } from "../lib/context-memory.ts";
 import { isSandboxEnabled } from "../lib/profile-sandbox.ts";
 import { handlerEnvironment, HOST_SSH_CREDENTIAL_KEYS, parseProfileEnv, profileEnvironment } from "../lib/profile-env.ts";
 import { PulseStore } from "../pulse/store.ts";
@@ -98,10 +100,12 @@ class ApiServer {
   private readonly sessions = new Map<string, SessionHandle>();
   private readonly sandboxBusy = new Set<string>();
   private readonly runtimes = new Map<string, Promise<ModelRuntime>>();
+  private readonly toolDiscoveries = new Map<string, Promise<void>>();
   readonly profiles: ProfileStore;
   readonly pulses: PulseStore;
   readonly applications: ApplicationStore;
   readonly skillSources: SkillSourceStore;
+  private contextMemoryLogger?: (application: string, profile: string, identityKey: string, sessionId: string, execution: ContextMemoryExecutionLog) => void;
 
   constructor(private readonly options: ServerOptions, private readonly config: ApiConfig) {
     this.profiles = new ProfileStore(options.agentDir);
@@ -230,6 +234,21 @@ class ApiServer {
     return { id: session.getSessionId(), name: session.getSessionName() ?? null, createdAt: header.timestamp, updatedAt: header.timestamp, messageCount: 0, preview: "" };
   }
 
+  async createApplicationConsoleSession(profile: string, input: unknown): Promise<Record<string, unknown>> {
+    const body = objectBody(input), application = body.application, identityKey = body.identityKey;
+    if (typeof application !== "string" || !application) throw Object.assign(new Error("Application is required."), { status: 400 });
+    if (typeof identityKey !== "string" || !identityKey.trim()) throw Object.assign(new Error("Identity key is required."), { status: 400 });
+    const record = this.applications.get(application);
+    if (!record?.enabled) throw Object.assign(new Error("Application was not found or is disabled."), { status: 404 });
+    const mapping = this.applications.identityMapping(application, identityKey.trim());
+    if (!mapping) throw Object.assign(new Error("No Identity Key mapping was found for this Application."), { status: 422 });
+    if (mapping.profile !== profile) throw Object.assign(new Error("This identity routes to a different profile."), { status: 422 });
+    const id = this.applications.nextConsoleSessionId(application, identityKey.trim());
+    const session = await this.createSession(profile, { id, name: `Application: ${record.name}` });
+    this.applications.createConsoleSession(id, application, profile, identityKey.trim());
+    return { ...session, application, manualApplicationSession: true };
+  }
+
   async renameSession(profile: string, id: string, name: string): Promise<Record<string, unknown>> {
     if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(id)) throw Object.assign(new Error("Invalid sessionId"), { status: 400 });
     const trimmed = name.trim();
@@ -256,6 +275,7 @@ class ApiServer {
     active?.session.dispose();
     this.sessions.delete(key);
     await rm(existing.path);
+    this.applications.deleteConsoleSession(profile, id);
   }
 
   async getSessionConversation(profile: string, id: string, before?: string, requestedLimit = 16): Promise<Record<string, unknown>> {
@@ -287,7 +307,7 @@ class ApiServer {
   private async discoverSandboxedExtensionTools(profile: string): Promise<void> {
     const agentDir = this.profileDirectory(profile);
     const environment = { ...(await profileEnvironment(agentDir)), PI_PROFILE_ROOT: this.options.agentDir, PI_PROFILE_DISCOVER_TOOLS: "1" };
-    const output = await new Promise<string>((resolveRun, reject) => {
+    const output = await new Promise<{ stdout: string; stderr: string }>((resolveRun, reject) => {
       delete environment.PI_API_WORKER;
       const child = spawn(process.execPath, [process.argv[1], "profile", profile, "--no-session", "--print", ""], {
         cwd: agentDir,
@@ -298,13 +318,15 @@ class ApiServer {
       child.stdout.on("data", (chunk) => { stdout += String(chunk); });
       child.stderr.on("data", (chunk) => { stderr += String(chunk); });
       child.once("error", reject);
-      child.once("exit", (code) => code === 0 ? resolveRun(stdout) : reject(new Error(stderr.trim() || `Sandboxed tool discovery exited with ${code ?? "unknown"}`)));
+      child.once("exit", (code) => code === 0 ? resolveRun({ stdout, stderr }) : reject(new Error(stderr.trim() || `Sandboxed tool discovery exited with ${code ?? "unknown"}`)));
     });
-    const line = output.split(/\r?\n/).map((value) => value.trim()).find((value) => value.startsWith("{\"tools\":"));
+    // Nono can relay a successful child Pi process through stderr. Its JSON
+    // protocol remains authoritative regardless of the stream it arrived on.
+    const line = `${output.stdout}\n${output.stderr}`.split(/\r?\n/).map((value) => value.trim()).find((value) => value.startsWith("{\"tools\":"));
     if (!line) throw new Error("Sandboxed tool discovery returned no tool list.");
     const value = JSON.parse(line) as { tools?: unknown };
     if (!Array.isArray(value.tools) || value.tools.some((name) => typeof name !== "string")) throw new Error("Sandboxed tool discovery returned an invalid tool list.");
-    this.profiles.registerExtensionTools(value.tools);
+    this.profiles.registerExtensionTools(profile, value.tools);
   }
 
   async complete(profile: string, prompt: string): Promise<string> {
@@ -329,46 +351,71 @@ class ApiServer {
   }
 
   async discoverExtensionTools(profile: string): Promise<void> {
-    const agentDir = this.profileDirectory(profile);
-    await this.profiles.readSettings(profile);
-    if (await this.sandboxed(profile)) return this.discoverSandboxedExtensionTools(profile);
-    await this.withProfileEnvironment(agentDir, async () => {
-      const settingsManager = SettingsManager.create(this.options.cwd, agentDir);
-      const loader = new DefaultResourceLoader({ cwd: this.options.cwd, agentDir, settingsManager });
-      await loader.reload();
-      let runtime = this.runtimes.get(agentDir);
-      if (!runtime) {
-        runtime = ModelRuntime.create({ authPath: join(agentDir, "auth.json"), modelsPath: join(agentDir, "models.json") });
-        this.runtimes.set(agentDir, runtime);
-      }
-      const { session } = await createAgentSession({
-        cwd: this.options.cwd,
-        agentDir,
-        sessionManager: SessionManager.inMemory(this.options.cwd),
-        settingsManager,
-        resourceLoader: loader,
-        modelRuntime: await runtime,
+    const existing = this.toolDiscoveries.get(profile);
+    if (existing) return existing;
+    const discovery = (async () => {
+      const agentDir = this.profileDirectory(profile);
+      await this.profiles.readSettings(profile);
+      if (await this.sandboxed(profile)) return this.discoverSandboxedExtensionTools(profile);
+      await this.withProfileEnvironment(agentDir, async () => {
+        const settingsManager = SettingsManager.create(this.options.cwd, agentDir);
+        const loader = new DefaultResourceLoader({ cwd: this.options.cwd, agentDir, settingsManager });
+        await loader.reload();
+        let runtime = this.runtimes.get(agentDir);
+        if (!runtime) {
+          runtime = ModelRuntime.create({ authPath: join(agentDir, "auth.json"), modelsPath: join(agentDir, "models.json") });
+          this.runtimes.set(agentDir, runtime);
+        }
+        const { session } = await createAgentSession({
+          cwd: this.options.cwd,
+          agentDir,
+          sessionManager: SessionManager.inMemory(this.options.cwd),
+          settingsManager,
+          resourceLoader: loader,
+          modelRuntime: await runtime,
+        });
+        try {
+          this.profiles.registerExtensionTools(profile, session.agent.state.tools.map((tool) => tool.name));
+        } finally {
+          session.dispose();
+        }
       });
-      try {
-        this.profiles.registerExtensionTools(session.agent.state.tools.map((tool) => tool.name));
-      } finally {
-        session.dispose();
-      }
-    });
+    })();
+    this.toolDiscoveries.set(profile, discovery);
+    try {
+      await discovery;
+    } catch (error) {
+      this.toolDiscoveries.delete(profile);
+      throw error;
+    }
+  }
+
+  invalidateExtensionTools(profile?: string): void {
+    if (profile) this.toolDiscoveries.delete(profile);
+    else this.toolDiscoveries.clear();
+    this.profiles.clearExtensionTools(profile);
+  }
+
+  setContextMemoryLogger(logger: (application: string, profile: string, identityKey: string, sessionId: string, execution: ContextMemoryExecutionLog) => void): void {
+    this.contextMemoryLogger = logger;
+  }
+
+  private recordContextMemoryExecution(application: string, profile: string, identityKey: string, sessionId: string, execution: ContextMemoryExecutionLog): void {
+    this.contextMemoryLogger?.(application, profile, identityKey, sessionId, execution);
   }
 
   private async sandboxed(profile: string): Promise<boolean> {
     return isSandboxEnabled(this.profileDirectory(profile), profile === "default");
   }
 
-  private async runSandboxedPrompt(profile: string, id: string, message: string, onData?: (text: string) => void, handoff?: string): Promise<string> {
+  private async runSandboxedPrompt(profile: string, id: string, message: string, onData?: (text: string) => void, handoff?: string, applicationContext?: { application: string; identityKey: string }): Promise<string> {
     const key = `${profile}:${id}`;
     if (this.sandboxBusy.has(key)) throw Object.assign(new Error("The session is already processing a request."), { status: 409 });
     this.sandboxBusy.add(key);
     try {
       const session = (await this.listProfileSessions(profile)).find((item) => item.id === id);
       if (!session) throw Object.assign(new Error(`No session found matching '${id}'`), { status: 404 });
-      const workerEnv = { ...(await profileEnvironment(this.profileDirectory(profile))), PI_PROFILE_ROOT: this.options.agentDir, ...(handoff ? { PI_APPLICATION_HANDOFF: handoff } : {}) }; 
+      const workerEnv: NodeJS.ProcessEnv = { ...(await profileEnvironment(this.profileDirectory(profile))), PI_PROFILE_ROOT: this.options.agentDir, ...(handoff ? { PI_APPLICATION_HANDOFF: handoff } : {}), ...(applicationContext ? { PI_APPLICATION_IDENTITY_KEY: applicationContext.identityKey, PI_APPLICATION_SLUG: applicationContext.application, PI_APPLICATION_SESSION_ID: id } : {}) };
       // The HTTP gateway is an API worker itself. Its children are agent
       // runtimes, not additional HTTP servers.
       delete workerEnv.PI_API_WORKER;
@@ -388,31 +435,43 @@ class ApiServer {
         child.once("error", reject);
         child.once("exit", (code) => resolveRun({ stdout, stderr, code: code ?? 1 }));
       });
-      if (result.code !== 0) throw new Error(result.stderr.trim() || `Sandboxed Pi exited with ${result.code}`);
+      const stderr = result.stderr.split(/\r?\n/).filter((line) => {
+        if (!line.startsWith("PI_CONTEXT_MEMORY_LOG:")) return true;
+        if (applicationContext) try {
+          const execution = JSON.parse(line.slice("PI_CONTEXT_MEMORY_LOG:".length)) as ContextMemoryExecutionLog;
+          this.recordContextMemoryExecution(applicationContext.application, profile, applicationContext.identityKey, id, execution);
+        } catch { /* Ignore malformed child telemetry. */ }
+        return false;
+      }).join("\n").trim();
+      if (result.code !== 0) throw new Error(stderr || `Sandboxed Pi exited with ${result.code}`);
       return result.stdout.trim();
     } finally { this.sandboxBusy.delete(key); }
   }
 
-  async prompt(profile: string, id: string, message: string, handoff?: string): Promise<{ profile: string; sessionId: string; response: string }> {
-    if (await this.sandboxed(profile)) return { profile, sessionId: id, response: await this.runSandboxedPrompt(profile, id, message, undefined, handoff) };
+  async prompt(profile: string, id: string, message: string, handoff?: string, applicationContext?: { application: string; identityKey: string }): Promise<{ profile: string; sessionId: string; response: string }> {
+    if (await this.sandboxed(profile)) return { profile, sessionId: id, response: await this.runSandboxedPrompt(profile, id, message, undefined, handoff, applicationContext) };
     const handle = await this.getSession(profile, id);
     if (handle.busy || !handle.session.isIdle) throw Object.assign(new Error("The session is already processing a request."), { status: 409 });
     handle.busy = true;
     try {
-      await this.withProfileEnvironment(this.profileDirectory(profile), () => handle.session.prompt(message, { source: "rpc" }), handoff ? { PI_APPLICATION_HANDOFF: handoff } : {});
+      const promptSession = () => this.withProfileEnvironment(this.profileDirectory(profile), () => handle.session.prompt(message, { source: "rpc" }), handoff ? { PI_APPLICATION_HANDOFF: handoff } : {});
+      if (applicationContext) await applicationExecutionContext.run({ ...applicationContext, profile, sessionId: id, onContextMemoryExecution: (execution) => this.recordContextMemoryExecution(applicationContext.application, profile, applicationContext.identityKey, id, execution) }, promptSession);
+      else await promptSession();
       const assistant = [...handle.session.messages].reverse().find((item) => item.role === "assistant");
       return { profile, sessionId: id, response: textFromMessage(assistant) };
     } finally { handle.busy = false; }
   }
 
   private async chat(profile: string, id: string, message: string, reply: FastifyReply, stream: boolean): Promise<void> {
+    const manual = this.applications.consoleSession(profile, id);
+    const applicationContext = manual ? { application: manual.application, identityKey: manual.identityKey } : undefined;
     if (await this.sandboxed(profile)) {
-      if (!stream) { reply.send({ profile, sessionId: id, response: await this.runSandboxedPrompt(profile, id, message) }); return; }
+      if (!stream) { reply.send({ profile, sessionId: id, response: await this.runSandboxedPrompt(profile, id, message, undefined, undefined, applicationContext) }); return; }
       reply.hijack();
       reply.raw.writeHead(200, { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-cache, no-transform", connection: "keep-alive", "x-accel-buffering": "no" });
       reply.raw.write(`event: session\ndata: ${JSON.stringify({ profile, sessionId: id })}\n\n`);
       try {
-        const response = await this.runSandboxedPrompt(profile, id, message, (text) => reply.raw.write(`event: token\ndata: ${JSON.stringify({ text })}\n\n`));
+        const response = await this.runSandboxedPrompt(profile, id, message, (text) => reply.raw.write(`event: token\ndata: ${JSON.stringify({ text })}\n\n`), undefined, applicationContext);
         reply.raw.write(`event: done\ndata: ${JSON.stringify({ response, sessionId: id, profile })}\n\n`);
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -446,7 +505,9 @@ class ApiServer {
         });
         response.once("close", () => { closed = true; void handle.session.abort(); });
       }
-      await this.withProfileEnvironment(this.profileDirectory(profile), () => handle.session.prompt(message, { source: "rpc" }));
+      const promptSession = () => this.withProfileEnvironment(this.profileDirectory(profile), () => handle.session.prompt(message, { source: "rpc" }));
+      if (applicationContext) await applicationExecutionContext.run({ ...applicationContext, profile, sessionId: id, onContextMemoryExecution: (execution) => this.recordContextMemoryExecution(applicationContext.application, profile, applicationContext.identityKey, id, execution) }, promptSession);
+      else await promptSession();
       const assistant = [...handle.session.messages].reverse().find((item) => item.role === "assistant");
       const response = textFromMessage(assistant);
       if (stream) {
@@ -586,6 +647,41 @@ export async function startApiServer(options: ServerOptions): Promise<FastifyIns
     documentRoute("soul", "SOUL.md");
     documentRoute("refine", "REFINE.md");
 
+    server.get<{ Params: { profile: string } }>("/api/profiles/:profile/context-memory", async (request, reply) => {
+      if (!guard(request, reply)) return;
+      const profile = profileName(request);
+      const settings = await api.profiles.readSettings(profile);
+      return { config: contextMemoryConfig((settings.profile as { contextMemory?: unknown } | undefined)?.contextMemory) };
+    });
+    server.put<{ Params: { profile: string } }>("/api/profiles/:profile/context-memory", async (request, reply) => {
+      if (!guard(request, reply)) return;
+      const profile = profileName(request), body = objectBody(request.body);
+      const config = body.config === null ? undefined : contextMemoryConfig(body.config);
+      if (body.config !== null && !config) throw Object.assign(new Error("Invalid Context Memory configuration."), { status: 400 });
+      const settings = await api.profiles.readSettings(profile);
+      const policy = { ...((settings.profile as Record<string, unknown> | undefined) ?? {}) };
+      if (config) policy.contextMemory = config; else delete policy.contextMemory;
+      await api.profiles.writeSettings(profile, { ...settings, profile: policy });
+      return { config: config ?? null };
+    });
+    for (const target of ["operational", "profile"] as const) {
+      server.get<{ Params: { profile: string } }>(`/api/profiles/:profile/context-memory/${target}`, async (request, reply) => {
+        if (!guard(request, reply)) return;
+        const profile = profileName(request), directory = api.profiles.directory(profile);
+        return { content: await readMemory(memoryPath(options.agentDir, directory, target)) };
+      });
+      server.put<{ Params: { profile: string } }>(`/api/profiles/:profile/context-memory/${target}`, async (request, reply) => {
+        if (!guard(request, reply)) return;
+        const content = objectBody(request.body).content;
+        if (typeof content !== "string") throw Object.assign(new Error("Content must be a string."), { status: 400 });
+        const limit = contextMemoryLimit(target);
+        if (contextMemoryCharacters(content.trim()) > limit) throw Object.assign(new Error(`${target === "operational" ? "OPERATIONAL.md" : "PROFILE.md"} exceeds its ${limit}-character limit.`), { status: 413 });
+        const profile = profileName(request), directory = api.profiles.directory(profile), path = memoryPath(options.agentDir, directory, target);
+        await mkdir(dirname(path), { recursive: true }); await writeFile(path, `${content.trim()}${content.trim() ? "\n" : ""}`, { mode: 0o600 });
+        return { content: content.trim() };
+      });
+    }
+
     server.get<{ Params: { profile: string } }>("/api/profiles/:profile/env", async (request, reply) => {
       if (!guard(request, reply)) return;
       const path = join(api.profiles.directory(profileName(request)), ".env");
@@ -652,6 +748,10 @@ export async function startApiServer(options: ServerOptions): Promise<FastifyIns
       if (!guard(request, reply)) return;
       return reply.code(201).send(await api.createSession(profileName(request), request.body));
     });
+    server.post<{ Params: { profile: string } }>("/api/profiles/:profile/application-sessions", async (request, reply) => {
+      if (!guard(request, reply)) return;
+      return reply.code(201).send(await api.createApplicationConsoleSession(profileName(request), request.body));
+    });
     server.get<{ Params: { profile: string; sessionId: string }; Querystring: { before?: string; limit?: string } }>("/api/profiles/:profile/sessions/:sessionId", async (request, reply) => {
       if (!guard(request, reply)) return;
       const limit = request.query.limit === undefined ? 16 : Number(request.query.limit);
@@ -675,6 +775,15 @@ export async function startApiServer(options: ServerOptions): Promise<FastifyIns
       await api.profiles.readSettings(profileName(request));
       return { pulses: api.pulses.list(profileName(request)) };
     });
+    server.get<{ Params: { profile: string; name: string }; Querystring: { start?: string; end?: string; limit?: string } }>("/api/profiles/:profile/pulses/:name/runs", async (request, reply) => {
+      if (!guard(request, reply)) return;
+      const profile = profileName(request); await api.profiles.readSettings(profile);
+      const end = request.query.end ?? new Date().toISOString(), start = request.query.start ?? new Date(Date.now() - 24 * 60 * 60 * 1_000).toISOString(), limit = request.query.limit === undefined ? 100 : Number(request.query.limit);
+      if (Number.isNaN(Date.parse(start)) || Number.isNaN(Date.parse(end)) || Date.parse(start) > Date.parse(end)) throw Object.assign(new Error("'start' and 'end' must be a valid chronological ISO-8601 range."), { status: 400 });
+      if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw Object.assign(new Error("The 'limit' query parameter must be an integer from 1 to 100."), { status: 400 });
+      try { return { runs: api.pulses.runs(profile, request.params.name, start, end, limit) }; }
+      catch (error) { throw Object.assign(error instanceof Error ? error : new Error(String(error)), { status: 404 }); }
+    });
     server.get<{ Params: { profile: string } }>("/api/profiles/:profile/pulses/history", async (request, reply) => {
       if (!guard(request, reply)) return;
       await api.profiles.readSettings(profileName(request));
@@ -720,9 +829,9 @@ export async function startApiServer(options: ServerOptions): Promise<FastifyIns
     server.post<{ Params: { profile: string; name: string }; Querystring: { source?: string } }>("/api/profiles/:profile/skills/:name/publish", async (request, reply) => { if (!guard(request, reply)) return; const profile=profileName(request), body=objectBody(request.body), source=skillSource(request.query.source); if (typeof body.identifier !== "string" || !body.identifier) throw Object.assign(new Error("A Skill Source is required."), { status: 400 }); const skill=await api.profiles.resource(profile, "skills", request.params.name, source); if (!skill.path) throw Object.assign(new Error("Skill path is not available."), { status: 404 }); if (source === "shared" && profile !== "default") throw Object.assign(new Error("Shared Skills can only be published by the default profile."), { status: 403 }); const publication=await api.skillSources.publish(body.identifier, profile, request.params.name, skill.path); await api.profiles.refreshSkills(profile); return reply.code(publication.action === "created" ? 201 : 200).send({ publication }); });
     server.post<{ Params: { profile: string; name: string }; Querystring: { source?: string } }>("/api/profiles/:profile/skills/:name/sync", async (request, reply) => { if (!guard(request, reply)) return; const profile=profileName(request), source=skillSource(request.query.source), skill=await api.profiles.resource(profile, "skills", request.params.name, source); if (!skill.path) throw Object.assign(new Error("Skill path is not available."), { status: 404 }); const synchronization=await api.skillSources.syncInstallation(profile, request.params.name, skill.path); await api.profiles.refreshSkills(profile); return { synchronization }; });
 
-    const skillSource = (value: unknown): "shared" | "profile" | undefined => {
+    const skillSource = (value: unknown): "shared" | "profile" | "package" | undefined => {
       if (value === undefined) return undefined;
-      if (value === "shared" || value === "profile") return value;
+      if (value === "shared" || value === "profile" || value === "package") return value;
       throw Object.assign(new Error("Invalid skill source."), { status: 400 });
     };
     server.get<{ Params: { profile: string } }>("/api/profiles/:profile/skills/sources", async (request, reply) => {
@@ -746,13 +855,15 @@ export async function startApiServer(options: ServerOptions): Promise<FastifyIns
     server.patch<{ Params: { profile: string; name: string }; Body: { enabled?: unknown } }>("/api/profiles/:profile/packages/:name", async (request, reply) => {
       if (!guard(request, reply)) return;
       if (typeof request.body?.enabled !== "boolean") return reply.code(400).send({ error: "'enabled' must be a boolean." });
-      return { package: await api.profiles.setPackage(profileName(request), decodeURIComponent(request.params.name), request.body.enabled) };
+      const result = await api.profiles.setPackage(profileName(request), decodeURIComponent(request.params.name), request.body.enabled);
+      api.invalidateExtensionTools();
+      return { package: result };
     });
 
     server.get<{ Params: { profile: string; kind: string } }>("/api/profiles/:profile/resources/:kind", async (request, reply) => {
       if (!guard(request, reply)) return;
       const kind = resourceKind(request.params.kind);
-      if (kind === "tools") await api.discoverExtensionTools(profileName(request)).catch(() => {});
+      if (kind === "tools") await api.discoverExtensionTools(profileName(request));
       return { resources: await api.profiles.resources(profileName(request), kind) };
     });
     server.get<{ Params: { profile: string; kind: string; name: string }; Querystring: { source?: string } }>("/api/profiles/:profile/resources/:kind/:name", async (request, reply) => {
@@ -767,7 +878,9 @@ export async function startApiServer(options: ServerOptions): Promise<FastifyIns
       if (kind === "tools") await api.discoverExtensionTools(profileName(request));
       const enabled = objectBody(request.body).enabled;
       if (typeof enabled !== "boolean") throw Object.assign(new Error("The 'enabled' field must be a boolean."), { status: 400 });
-      return api.profiles.setResource(profileName(request), kind, request.params.name, enabled, kind === "skills" ? skillSource(request.query.source) : undefined);
+      const result = await api.profiles.setResource(profileName(request), kind, request.params.name, enabled, kind === "skills" ? skillSource(request.query.source) : undefined);
+      if (kind === "extensions") api.invalidateExtensionTools();
+      return result;
     });
 
     server.delete<{ Params: { profile: string; kind: string; name: string }; Querystring: { source?: string } }>("/api/profiles/:profile/resources/:kind/:name", async (request, reply) => {
@@ -784,10 +897,13 @@ export async function startApiServer(options: ServerOptions): Promise<FastifyIns
     const applicationsRoot = join(options.agentDir, "applications");
     const applicationBySlug = new Map<string, { record: ApplicationRecord; runtime: ApplicationRuntime }>();
     const applicationSettings = (record: ApplicationRecord): ApplicationSettings => ({ ...record.settings, responseMode: record.responseMode, defaultProfile: record.defaultProfile }) as ApplicationSettings;
-    const ensureApplicationFiles = async (slug: string) => { const handlers = join(applicationsRoot, slug, "handlers"); await mkdir(join(handlers, "transforms"), { recursive: true }); const inbound = join(handlers, "inbound.ts"); if (!existsSync(inbound)) await writeFile(inbound, applicationHandlerTemplate("inbound"), "utf8"); };
-    const loadApplication = async (record: ApplicationRecord) => { const directory = join(applicationsRoot, record.slug); await ensureApplicationFiles(record.slug); const runtime = await ApplicationRuntime.load(directory, api, applicationSettings(record), async (settings) => { const saved = applicationStore.update(record.slug, { settings, responseMode: settings.responseMode, defaultProfile: settings.defaultProfile ?? null }); applicationBySlug.set(saved.slug, { record: saved, runtime }); }, record); applicationBySlug.set(record.slug, { record, runtime }); };
+    const ensureApplicationFiles = async (slug: string) => { const handlers = join(applicationsRoot, slug, "handlers"); await mkdir(join(handlers, "transforms"), { recursive: true }); await mkdir(join(handlers, "context-memory"), { recursive: true }); const inbound = join(handlers, "inbound.ts"); if (!existsSync(inbound)) await writeFile(inbound, applicationHandlerTemplate("inbound"), "utf8"); };
+    const loadApplication = async (record: ApplicationRecord) => { applicationBySlug.get(record.slug)?.runtime.dispose(); const directory = join(applicationsRoot, record.slug); await ensureApplicationFiles(record.slug); const runtime = await ApplicationRuntime.load(directory, api, applicationSettings(record), async (settings) => { const saved = applicationStore.update(record.slug, { settings, responseMode: settings.responseMode, defaultProfile: settings.defaultProfile ?? null }); applicationBySlug.set(saved.slug, { record: saved, runtime }); }, record); applicationBySlug.set(record.slug, { record, runtime }); };
     for (const record of applicationStore.list()) await loadApplication(record);
     const registeredApplication = (slug: string) => { const application = applicationBySlug.get(slug); if (!application) throw Object.assign(new Error("Application not found."), { status: 404 }); return application; };
+    api.setContextMemoryLogger((application, profile, identityKey, sessionId, execution) => {
+      applicationBySlug.get(application)?.runtime.logs.recordContextMemory({ profile, identityKey, sessionId, execution });
+    });
     const handlerFiles = async (directory: string, prefix = ""): Promise<string[]> => { const entries = await readdir(directory, { withFileTypes: true }); const files: string[] = []; for (const entry of entries) { const path = join(directory, entry.name), name = `${prefix}${entry.name}`; if (entry.isDirectory()) files.push(...await handlerFiles(path, `${name}/`)); else if (entry.isFile() && entry.name.endsWith(".ts")) files.push(name); } return files; };
     const applicationHandlerPath = (slug: string, file: unknown) => {
       if (typeof file !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_./-]*\.ts$/.test(file) || file.includes("..")) throw Object.assign(new Error("Invalid handler path."), { status: 400 });
@@ -818,7 +934,7 @@ export async function startApiServer(options: ServerOptions): Promise<FastifyIns
       const record = applicationStore.update(current.slug, { name: typeof body.name === "string" ? body.name : current.name, enabled: typeof body.enabled === "boolean" ? body.enabled : current.enabled, responseMode: body.responseMode === "result" || body.responseMode === "ack" ? body.responseMode : current.responseMode, defaultProfile: typeof body.defaultProfile === "string" ? body.defaultProfile || null : current.defaultProfile, routingPolicy: body.routingPolicy === "drop" || body.routingPolicy === "default_as_fallback" ? body.routingPolicy : current.routingPolicy, settings: body.settings && typeof body.settings === "object" && !Array.isArray(body.settings) ? body.settings as Record<string, unknown> : current.settings });
       await loadApplication(record); return { application: record };
     });
-    server.delete<{ Params: { slug: string } }>("/api/applications/:slug", async (request, reply) => { if (!guard(request, reply)) return; applicationStore.delete(request.params.slug); applicationBySlug.delete(request.params.slug); await rm(join(applicationsRoot, request.params.slug), { recursive: true, force: true }); return reply.code(204).send(); });
+    server.delete<{ Params: { slug: string } }>("/api/applications/:slug", async (request, reply) => { if (!guard(request, reply)) return; applicationBySlug.get(request.params.slug)?.runtime.dispose(); applicationStore.delete(request.params.slug); applicationBySlug.delete(request.params.slug); await rm(join(applicationsRoot, request.params.slug), { recursive: true, force: true }); return reply.code(204).send(); });
     server.get<{ Params: { slug: string } }>("/api/applications/:slug/identity-mappings", async (request, reply) => { if (!guard(request, reply)) return; registeredApplication(request.params.slug); return { mappings: applicationStore.identityMappings(request.params.slug) }; });
     server.put<{ Params: { slug: string; identityKey: string } }>("/api/applications/:slug/identity-mappings/:identityKey", async (request, reply) => { if (!guard(request, reply)) return; registeredApplication(request.params.slug); const body = objectBody(request.body), previousIdentityKey = request.params.identityKey, identityKey = typeof body.identityKey === "string" ? body.identityKey.trim() : previousIdentityKey, automatic = identityKey === "*" || body.sessionMode === "automatic", prefix = automatic ? null : body.sessionPrefix; if (identityKey === "*" && identityKey !== previousIdentityKey && applicationStore.identityMapping(request.params.slug, "*")) throw Object.assign(new Error("Only one wildcard (*) Identity Key mapping is allowed per Application."), { status: 409 }); if (!identityKey || typeof body.profile !== "string" || !body.profile || (!automatic && typeof prefix !== "string")) throw Object.assign(new Error("profile and a fixed sessionPrefix are required."), { status: 400 }); if (typeof prefix === "string" && !/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(prefix)) throw Object.assign(new Error("Invalid sessionPrefix."), { status: 400 }); await api.profiles.readSettings(body.profile); return { mapping: typeof body.previousIdentityKey === "string" ? applicationStore.renameIdentityMapping(request.params.slug, previousIdentityKey, identityKey, body.profile, automatic ? "automatic" : "fixed", automatic ? null : prefix) : applicationStore.saveIdentityMapping(request.params.slug, identityKey, body.profile, automatic ? "automatic" : "fixed", automatic ? null : prefix) }; });
     server.delete<{ Params: { slug: string; identityKey: string } }>("/api/applications/:slug/identity-mappings/:identityKey", async (request, reply) => { if (!guard(request, reply)) return; try { applicationStore.deleteIdentityMapping(request.params.slug, request.params.identityKey); return reply.code(204).send(); } catch (error) { throw Object.assign(error instanceof Error ? error : new Error(String(error)), { status: 404 }); } });
@@ -830,7 +946,26 @@ export async function startApiServer(options: ServerOptions): Promise<FastifyIns
     server.patch<{ Params: { slug: string }; Querystring: { path?: string } }>("/api/applications/:slug/handler", async (request, reply) => { if (!guard(request, reply)) return; const application = registeredApplication(request.params.slug), oldPath = applicationHandlerPath(request.params.slug, request.query.path), newFile = objectBody(request.body).newPath; const newPath = applicationHandlerPath(request.params.slug, newFile); if (dirname(oldPath) !== dirname(newPath)) throw Object.assign(new Error("Handlers must remain in their current folder."), { status: 400 }); if (existsSync(newPath)) throw Object.assign(new Error("A handler with this name already exists."), { status: 409 }); await rename(oldPath, newPath); const oldFile = String(request.query.path), oldName = oldFile.replace(/^transforms\//, "").replace(/\.ts$/, ""), newName = String(newFile).replace(/^transforms\//, "").replace(/\.ts$/, ""), settings = structuredClone(application.record.settings) as ApplicationSettings & Record<string, unknown>, testPayloads = handlerTestPayloads(settings); if (oldFile in testPayloads) { testPayloads[String(newFile)] = testPayloads[oldFile]; delete testPayloads[oldFile]; } settings.handlerTestPayloads = testPayloads; if (settings.inboundHandler === oldName) settings.inboundHandler = newName; if (settings.outboundHandler === oldName) settings.outboundHandler = newName; settings.transformHandlers = settings.transformHandlers?.map((value) => value === oldName ? newName : value); const record = updateApplicationSettings(application, settings); await loadApplication(record); return { ok: true, path: newFile, settingsUpdated: true }; });
     server.delete<{ Params: { slug: string }; Querystring: { path?: string } }>("/api/applications/:slug/handler", async (request, reply) => { if (!guard(request, reply)) return; const application = registeredApplication(request.params.slug), path = applicationHandlerPath(request.params.slug, request.query.path), file = String(request.query.path), handlerName = file.replace(/^transforms\//, "").replace(/\.ts$/, ""), settings = structuredClone(application.record.settings) as ApplicationSettings & Record<string, unknown>; if (settings.inboundHandler === handlerName || settings.outboundHandler === handlerName || settings.transformHandlers?.includes(handlerName)) throw Object.assign(new Error("This handler is active in Application Settings."), { status: 409 }); await rm(path); const testPayloads = handlerTestPayloads(settings); if (file in testPayloads) { delete testPayloads[file]; settings.handlerTestPayloads = testPayloads; const record = updateApplicationSettings(application, settings); applicationBySlug.set(record.slug, { record, runtime: application.runtime }); } return reply.code(204).send(); });
     server.post<{ Params: { slug: string }; Querystring: { path?: string } }>("/api/applications/:slug/handler/test",  async (request, reply) => { if (!guard(request, reply)) return; const application = registeredApplication(request.params.slug); const body = objectBody(request.body); if (!body.payload || typeof body.payload !== "object" || Array.isArray(body.payload)) throw Object.assign(new Error("The 'payload' field must be a JSON object."), { status: 400 }); applicationHandlerPath(request.params.slug, request.query.path); const settings = structuredClone(application.record.settings) as Record<string, unknown>, testPayloads = handlerTestPayloads(settings); testPayloads[String(request.query.path)] = body.payload; settings.handlerTestPayloads = testPayloads; const record = updateApplicationSettings(application, settings); applicationBySlug.set(record.slug, { record, runtime: application.runtime }); return application.runtime.testHandler(applicationHandlerPath(request.params.slug, request.query.path), body.payload as Record<string, unknown>, typeof body.content === "string" ? body.content : undefined); });
-    server.get<{ Params: { slug: string } }>("/api/applications/:slug/logs", async (request, reply) => { if (!guard(request, reply)) return; return { calls: registeredApplication(request.params.slug).runtime.logs.list() }; });
+    server.get<{ Params: { slug: string }; Querystring: { summary?: string; limit?: string; start?: string; end?: string } }>("/api/applications/:slug/logs", async (request, reply) => {
+      if (!guard(request, reply)) return;
+      const logs = registeredApplication(request.params.slug).runtime.logs;
+      if (request.query.summary !== "1") return { calls: logs.list() };
+      const limit = request.query.limit === undefined ? 250 : Number(request.query.limit);
+      if (!Number.isInteger(limit) || limit < 1 || limit > 250) throw Object.assign(new Error("The 'limit' query parameter must be an integer from 1 to 250."), { status: 400 });
+      const parseDate = (value: string | undefined, name: string) => {
+        if (!value) return undefined;
+        const date = new Date(value);
+        if (Number.isNaN(date.getTime())) throw Object.assign(new Error(`The '${name}' query parameter must be a valid ISO date.`), { status: 400 });
+        return date;
+      };
+      return { calls: logs.listSummaries(limit, parseDate(request.query.start, "start"), parseDate(request.query.end, "end")) };
+    });
+    server.get<{ Params: { slug: string; callId: string } }>("/api/applications/:slug/logs/calls/:callId", async (request, reply) => {
+      if (!guard(request, reply)) return;
+      const call = registeredApplication(request.params.slug).runtime.logs.get(request.params.callId);
+      if (!call) throw Object.assign(new Error("Log call not found."), { status: 404 });
+      return { call };
+    });
     server.delete<{ Params: { slug: string } }>("/api/applications/:slug/logs", async (request, reply) => { if (!guard(request, reply)) return; await registeredApplication(request.params.slug).runtime.logs.clear(); return reply.code(204).send(); });
     server.post<{ Params: { slug: string } }>("/api/applications/:slug/logs/ticket", async (request, reply) => { if (!guard(request, reply)) return; const application = registeredApplication(request.params.slug), ticket = randomUUID(); applicationLogTickets.set(ticket, { slug: application.record.slug, expiresAt: Date.now() + 60_000 }); const base = new URL(config.publicBaseUrl ?? `http://127.0.0.1:${config.port}`); base.protocol = base.protocol === "https:" ? "wss:" : "ws:"; base.pathname = `/api/applications/${encodeURIComponent(application.record.slug)}/logs/stream`; base.search = `ticket=${encodeURIComponent(ticket)}`; return { ticket, url: base.toString() }; });
     server.get("/api/applications/:slug/logs/stream", { websocket: true }, (socket, request) => { const ticket = (request.query as { ticket?: string }).ticket; const value = ticket && applicationLogTickets.get(ticket); if (!value || value.slug !== (request.params as { slug: string }).slug || value.expiresAt < Date.now()) return socket.close(1008, "Invalid ticket"); applicationLogTickets.delete(ticket!); const unsubscribe = registeredApplication(value.slug).runtime.logs.on((event) => socket.send(JSON.stringify(event))); socket.on("close", unsubscribe); });