@agentrific/server 0.2.0 → 0.4.0

package/index.js

@@ -455,6 +455,7 @@ var RunPreparationSchema = z2.object({
 var SessionSchema = z2.object({
   id: z2.string(),
   taskId: z2.string().nullable().optional(),
+  kind: z2.enum(["task", "repo_chat"]).optional(),
   projectId: z2.string(),
   title: z2.string(),
   status: SessionStatusSchema,
@@ -465,6 +466,11 @@ var SessionSchema = z2.object({
   gitFlow: GitFlowSchema.optional(),
   gitDelivery: GitDeliverySchema.optional(),
   preparation: RunPreparationSchema.optional(),
+  usage: z2.object({
+    tokens: z2.number().nonnegative(),
+    turns: z2.number().int().nonnegative(),
+    tools: z2.number().int().nonnegative()
+  }).optional(),
   createdAt: z2.string().datetime(),
   updatedAt: z2.string().datetime()
 });
@@ -528,6 +534,7 @@ var SessionEventSchema = z2.discriminatedUnion("type", [
   }),
   z2.object({
     type: z2.literal("message.completed"),
+    tokens: z2.number().nonnegative().optional(),
     model: ModelIdentitySchema.optional(),
     sessionId: z2.string(),
     messageId: z2.string().optional(),
@@ -863,7 +870,7 @@ var Attachments = class extends Context.Service()(
 };
 
 // src/index.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 import { realpath as realpath2 } from "node:fs/promises";
@@ -1090,7 +1097,7 @@ async function startControl(directory, security2, status, maintenance2) {
 // package.json
 var package_default = {
   name: "@agentrific/server",
-  version: "0.2.0",
+  version: "0.4.0",
   description: "Self-hosted control plane for long-running coding agents",
   keywords: [
     "agentrific",
@@ -1476,7 +1483,7 @@ var UpdateDiscovery = class {
 };
 
 // src/index.ts
-import { Effect as Effect16, ManagedRuntime } from "effect";
+import { Effect as Effect17, ManagedRuntime } from "effect";
 import { z as z17 } from "zod";
 
 // src/automation.ts
@@ -1564,7 +1571,9 @@ async function boardTasks(store2, projectId) {
       status: taskStatusForSession(session.status, session)
     };
   });
-  const legacyTasks = sessions.filter((session) => !session.taskId && !linkedSessionIds.has(session.id)).filter((session) => !projectId || session.projectId === projectId).map(sessionTask);
+  const legacyTasks = sessions.filter(
+    (session) => session.kind !== "repo_chat" && !session.taskId && !linkedSessionIds.has(session.id)
+  ).filter((session) => !projectId || session.projectId === projectId).map(sessionTask);
   return [...linkedTasks, ...legacyTasks].map((task) => TaskSchema.parse(task)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
 }
 async function findTask(store2, id) {
@@ -1783,13 +1792,29 @@ var AgentController = class {
       const entry = {
         session,
         agent,
-        unsubscribe: agent.subscribe(this.emit),
+        unsubscribe: () => {
+        },
         running: false,
         stopping: false,
         pending: []
       };
+      entry.unsubscribe = agent.subscribe((event) => {
+        this.emit(event);
+        if (event.type !== "message.completed" && event.type !== "tool.started") return;
+        const usage = entry.session.usage ?? { tokens: 0, turns: 0, tools: 0 };
+        entry.session = {
+          ...entry.session,
+          usage: {
+            tokens: usage.tokens + (event.type === "message.completed" ? event.tokens ?? 0 : 0),
+            turns: usage.turns + (event.type === "message.completed" ? 1 : 0),
+            tools: usage.tools + (event.type === "tool.started" ? 1 : 0)
+          },
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.emit({ type: "session.updated", session: entry.session });
+      });
       if (agent.model) {
-        entry.session = { ...session, model: agent.model };
+        entry.session = { ...entry.session, model: agent.model };
         this.emit({ type: "session.updated", session: entry.session });
       }
       this.active.set(session.id, entry);
@@ -2981,6 +3006,7 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
                   sessionId,
                   messageId: assistantMessageId,
                   text,
+                  tokens: event.message.usage.totalTokens,
                   model: models2.identity(event.message.provider, event.message.model)
                 });
               assistantMessageId = void 0;
@@ -3004,7 +3030,8 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
                 sessionId,
                 toolCallId: event.toolCallId,
                 tool: event.toolName,
-                input: boundedJson(event.args, 1200),
+                // Preserve complete Bash arguments so multiline commands can be inspected.
+                input: event.toolName === "bash" ? JSON.stringify(event.args) : boundedJson(event.args, 1200),
                 filePath: filePaths.get(event.toolCallId)
               });
               return true;
@@ -3711,6 +3738,38 @@ async function removeRunFiles(dataRoot2, sessionId) {
   await rm2(path8.join(dataRoot2, "pi", sessionId), { recursive: true, force: true });
 }
 
+// src/repo-chat.ts
+import { randomUUID as randomUUID8 } from "node:crypto";
+import { Effect as Effect16 } from "effect";
+function openRepoChat(store2, projectId, workspacePath, defaultModel, reset = false) {
+  return withTaskLock(`repo-chat:${projectId}`, async () => {
+    const existing = (await Effect16.runPromise(store2.list())).filter((session2) => session2.projectId === projectId && session2.kind === "repo_chat").sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
+    if (existing && !reset) return existing;
+    if (existing?.status === "running")
+      throw new Error("Wait for the current reply before resetting chat.");
+    const model = await defaultModel();
+    if (!model) throw new Error("Choose an available default model in Settings before chatting.");
+    const now = new Date(
+      Math.max(Date.now(), existing ? Date.parse(existing.createdAt) + 1 : 0)
+    ).toISOString();
+    const session = {
+      id: randomUUID8(),
+      projectId,
+      kind: "repo_chat",
+      title: workspacePath.split("/").at(-1) ?? projectId,
+      status: "waiting_for_input",
+      agent: "pi",
+      model,
+      branch: null,
+      workspacePath,
+      createdAt: now,
+      updatedAt: now
+    };
+    await Effect16.runPromise(store2.append({ type: "session.updated", session }));
+    return session;
+  });
+}
+
 // src/index.ts
 var host = process.env.AGENTRIFIC_HOST ?? "127.0.0.1";
 var port = Number(process.env.AGENTRIFIC_PORT ?? 4318);
@@ -3743,7 +3802,7 @@ var dataRoot = path9.resolve(process.env.AGENTRIFIC_DATA_DIR ?? "./data");
 var releaseLock = await acquireServerLock(dataRoot);
 var effects = ManagedRuntime.make(SessionStore.layer(path9.join(dataRoot, "sessions.sqlite")));
 var store = await effects.runPromise(SessionStore);
-var security = new ServerSecurity(store, await Effect16.runPromise(store.serverIdentity()));
+var security = new ServerSecurity(store, await Effect17.runPromise(store.serverIdentity()));
 var testPushUrl = process.env.AGENTRIFIC_PUSH_TEST_URL;
 if (testPushUrl && (process.env.AGENTRIFIC_TEST_MODE !== "1" || !new URL(testPushUrl).hostname.endsWith(".ts.net") || new URL(testPushUrl).protocol !== "https:"))
   throw new Error("Test relay requires explicit test mode and Tailscale HTTPS.");
@@ -3766,10 +3825,10 @@ var attachmentEffects = ManagedRuntime.make(
   Attachments.layer(path9.join(dataRoot, "attachments"), store)
 );
 var attachments = await attachmentEffects.runPromise(Attachments);
-await Effect16.runPromise(attachments.cleanup());
+await Effect17.runPromise(attachments.cleanup());
 var attachmentCleanup = setInterval(
   () => {
-    void Effect16.runPromise(attachments.cleanup()).catch((error) => app.log.error(error));
+    void Effect17.runPromise(attachments.cleanup()).catch((error) => app.log.error(error));
   },
   60 * 60 * 1e3
 );
@@ -3780,14 +3839,14 @@ await app.register(multipart, {
 app.post(
   "/api/projects/:projectId/attachments",
   async (request, reply) => {
-    const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
-    const projects = await Effect16.runPromise(discoverProjects(root, store));
+    const root = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
+    const projects = await Effect17.runPromise(discoverProjects(root, store));
     if (!projects.some((project) => project.id === request.params.projectId && project.available))
       return reply.code(404).send({ error: "Project not found." });
     try {
       const file = await request.file();
       if (!file) return reply.code(400).send({ error: "Choose a file to upload." });
-      return reply.code(201).send(await Effect16.runPromise(attachments.upload(request.params.projectId, file)));
+      return reply.code(201).send(await Effect17.runPromise(attachments.upload(request.params.projectId, file)));
     } catch (error) {
       return reply.code(400).send({ error: error instanceof Error ? error.message : "Upload failed." });
     }
@@ -3796,7 +3855,7 @@ app.post(
 app.get(
   "/api/projects/:projectId/attachments/:id/content",
   async (request, reply) => {
-    const attachment = await Effect16.runPromise(store.getAttachment(request.params.id));
+    const attachment = await Effect17.runPromise(store.getAttachment(request.params.id));
     if (!attachment || attachment.projectId !== request.params.projectId)
       return reply.code(404).send({ error: "Attachment not found." });
     const preview = request.query.preview === "1" && attachment.kind === "image";
@@ -3810,7 +3869,7 @@ app.get(
   }
 );
 function publish(event, workflowUpdate = false) {
-  const previous = event.type === "session.updated" ? Effect16.runSync(store.get(event.session.id)) : void 0;
+  const previous = event.type === "session.updated" ? Effect17.runSync(store.get(event.session.id)) : void 0;
   const emittedEvent = event.type === "session.updated" && previous && !workflowUpdate ? {
     type: "session.updated",
     session: {
@@ -3820,7 +3879,7 @@ function publish(event, workflowUpdate = false) {
     }
   } : event;
   const notification = emittedEvent.type === "session.updated" ? push.pending(emittedEvent.session, previous) : void 0;
-  const record = Effect16.runSync(store.append(emittedEvent, notification));
+  const record = Effect17.runSync(store.append(emittedEvent, notification));
   const message = JSON.stringify({ type: "event", record });
   for (const client of security.sockets.keys()) {
     if (!(client instanceof WebSocket) || client.readyState !== WebSocket.OPEN) continue;
@@ -3833,8 +3892,8 @@ var delivery = new DeliveryCoordinator(store, {
   publish: (event) => publish(event, true),
   draft: deliveryWriter(models),
   projectPath: async (session) => {
-    const projectsRoot = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
-    const project = (await Effect16.runPromise(discoverProjects(projectsRoot, store))).find(
+    const projectsRoot = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
+    const project = (await Effect17.runPromise(discoverProjects(projectsRoot, store))).find(
       (item) => item.id === session.projectId && item.available
     );
     if (!project) throw new Error("Reconnect the project folder before delivering changes.");
@@ -3848,7 +3907,7 @@ var agentEffects = ManagedRuntime.make(
     publish,
     worktreesRoot,
     path9.join(dataRoot, "pi"),
-    (sessionId, messageId) => Effect16.runSync(store.hasMessage(sessionId, messageId)),
+    (sessionId, messageId) => Effect17.runSync(store.hasMessage(sessionId, messageId)),
     (session) => delivery.settled(session.id)
   )
 );
@@ -3883,7 +3942,7 @@ var stopUpdateDiscovery = updates.start(
   () => maintenance.ready(),
   (error) => app.log.error(error)
 );
-for (const session of await Effect16.runPromise(store.list())) {
+for (const session of await Effect17.runPromise(store.list())) {
   if (session.gitDelivery?.status === "pending") {
     publish(
       {
@@ -3927,7 +3986,7 @@ async function githubCliStatus() {
 }
 app.get("/api/connections", async () => githubCliStatus());
 app.get("/api/settings", async () => ({
-  projectsRoot: await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot)),
+  projectsRoot: await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot)),
   defaultModel: await models.defaultIdentity()
 }));
 app.get("/api/models", async (_request, reply) => {
@@ -3955,7 +4014,7 @@ app.post("/api/settings/model", async (request, reply) => {
   try {
     const defaultModel = await models.setDefault(parsed.data);
     return {
-      projectsRoot: await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot)),
+      projectsRoot: await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot)),
       defaultModel
     };
   } catch {
@@ -3968,13 +4027,13 @@ app.post(
   "/api/sessions/:id/model",
   async (request, reply) => withSessionTaskLock(request.params.id, async () => {
     const parsed = ModelReferenceSchema.safeParse(request.body);
-    const session = await Effect16.runPromise(store.get(request.params.id));
+    const session = await Effect17.runPromise(store.get(request.params.id));
     if (!session) return reply.code(404).send({ error: "Session not found." });
     if (!parsed.success)
       return reply.code(400).send({ error: "Choose a model from the server catalogue." });
     try {
       await models.resolve(parsed.data);
-      return await Effect16.runPromise(runtime.setModel(session, parsed.data));
+      return await Effect17.runPromise(runtime.setModel(session, parsed.data));
     } catch {
       return reply.code(409).send({
         error: "Could not change the model. Wait for the current reply to finish and choose an available model."
@@ -3985,21 +4044,21 @@ app.post(
 app.post("/api/settings", async (request, reply) => {
   const parsed = UpdateSettingsSchema.safeParse(request.body);
   if (!parsed.success) return reply.code(400).send({ error: "Enter a projects folder." });
-  const result = await Effect16.runPromise(
-    resolveProjectsRoot(parsed.data.projectsRoot).pipe(Effect16.result)
+  const result = await Effect17.runPromise(
+    resolveProjectsRoot(parsed.data.projectsRoot).pipe(Effect17.result)
   );
   if (result._tag === "Failure") return reply.code(400).send({ error: result.failure.message });
-  return Effect16.runPromise(store.setProjectsRoot(result.success));
+  return Effect17.runPromise(store.setProjectsRoot(result.success));
 });
 app.get("/api/projects", async (_request, reply) => {
-  const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const result = await Effect16.runPromise(discoverProjects(root, store).pipe(Effect16.result));
+  const root = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const result = await Effect17.runPromise(discoverProjects(root, store).pipe(Effect17.result));
   if (result._tag === "Failure") return reply.code(400).send({ error: result.failure.message });
   return result.success;
 });
 app.get("/api/projects/:id", async (request, reply) => {
-  const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const result = await Effect16.runPromise(discoverProjects(root, store).pipe(Effect16.result));
+  const root = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const result = await Effect17.runPromise(discoverProjects(root, store).pipe(Effect17.result));
   if (result._tag === "Failure") return reply.code(400).send({ error: result.failure.message });
   const project = result.success.find((item) => item.id === request.params.id);
   return project ?? reply.code(404).send({ error: "Project not found on this server." });
@@ -4008,13 +4067,13 @@ app.post("/api/projects/:id/reconnect", async (request, reply) => {
   const parsed = z17.object({ path: z17.string().trim().min(1).max(4096) }).safeParse(request.body);
   if (!parsed.success)
     return reply.code(400).send({ error: "Enter the project's new folder path." });
-  const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const result = await Effect16.runPromise(
-    reconnectProject(root, request.params.id, parsed.data.path, store).pipe(Effect16.result)
+  const root = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const result = await Effect17.runPromise(
+    reconnectProject(root, request.params.id, parsed.data.path, store).pipe(Effect17.result)
   );
   return result._tag === "Failure" ? reply.code(400).send({ error: result.failure.message }) : result.success;
 });
-app.get("/api/sessions", () => Effect16.runPromise(store.list()));
+app.get("/api/sessions", () => Effect17.runPromise(store.list()));
 app.get(
   "/api/tasks",
   (request) => boardTasks(store, request.query.projectId)
@@ -4027,15 +4086,15 @@ app.post("/api/tasks", async (request, reply) => {
     if (!github.githubCli.authenticated)
       return reply.code(400).send({ error: "GitHub CLI must be authenticated on the server to open a PR." });
   }
-  const projectsRoot = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const projects = await Effect16.runPromise(
-    discoverProjects(projectsRoot, store).pipe(Effect16.result)
+  const projectsRoot = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const projects = await Effect17.runPromise(
+    discoverProjects(projectsRoot, store).pipe(Effect17.result)
   );
   if (projects._tag === "Failure" || !projects.success.some((project) => project.id === parsed.data.projectId && project.available))
     return reply.code(404).send({ error: "Project not found in the server's projects folder." });
   let files;
   try {
-    files = await Effect16.runPromise(
+    files = await Effect17.runPromise(
       attachments.resolve(parsed.data.projectId, parsed.data.attachmentIds ?? [])
     );
   } catch (error) {
@@ -4043,7 +4102,7 @@ app.post("/api/tasks", async (request, reply) => {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const task = TaskSchema.parse({
-    id: randomUUID8(),
+    id: randomUUID9(),
     ...parsed.data,
     attachments: files,
     status: "backlog",
@@ -4051,7 +4110,7 @@ app.post("/api/tasks", async (request, reply) => {
     createdAt: now,
     updatedAt: now
   });
-  return reply.code(201).send(await Effect16.runPromise(store.saveTask(task)));
+  return reply.code(201).send(await Effect17.runPromise(store.saveTask(task)));
 });
 app.patch("/api/tasks/:id", async (request, reply) => {
   const parsed = UpdateTaskSchema.safeParse(request.body);
@@ -4066,8 +4125,8 @@ app.patch("/api/tasks/:id", async (request, reply) => {
         return reply.code(400).send({ error: "GitHub CLI must be authenticated on the server to open a PR." });
     }
     return await editTask(store, request.params.id, parsed.data, async (projectId, ids) => {
-      const result = await Effect16.runPromise(
-        attachments.resolve(projectId, ids).pipe(Effect16.result)
+      const result = await Effect17.runPromise(
+        attachments.resolve(projectId, ids).pipe(Effect17.result)
       );
       if (result._tag === "Failure") throw new TaskActionError(result.failure.message, 400);
       return result.success;
@@ -4081,11 +4140,11 @@ app.patch("/api/tasks/:id", async (request, reply) => {
 app.delete("/api/tasks/:id", async (request, reply) => {
   try {
     await deleteTask(store, request.params.id, async (session) => {
-      await Effect16.runPromise(runtime.forget(session.id));
+      await Effect17.runPromise(runtime.forget(session.id));
       await worktreeCleanup.remove(session);
       await removeRunFiles(dataRoot, session.id);
     });
-    await Effect16.runPromise(attachments.cleanup());
+    await Effect17.runPromise(attachments.cleanup());
     return reply.code(204).send();
   } catch (error) {
     if (error instanceof TaskActionError)
@@ -4094,14 +4153,14 @@ app.delete("/api/tasks/:id", async (request, reply) => {
   }
 });
 app.get("/api/sessions/:id", async (request, reply) => {
-  const session = await Effect16.runPromise(store.get(request.params.id));
+  const session = await Effect17.runPromise(store.get(request.params.id));
   if (!session) return reply.code(404).send({ error: "Session not found." });
   return session;
 });
 app.post(
   "/api/sessions/:id/delivery",
   async (request, reply) => withSessionTaskLock(request.params.id, async () => {
-    const session = await Effect16.runPromise(store.get(request.params.id));
+    const session = await Effect17.runPromise(store.get(request.params.id));
     if (!session) return reply.code(404).send({ error: "Session not found." });
     try {
       const result = await delivery.retry(session.id);
@@ -4118,10 +4177,10 @@ app.post(
     try {
       const prepared = await preparation.retry(request.params.id);
       preparedSession = prepared.session;
-      const files = await Effect16.runPromise(
+      const files = await Effect17.runPromise(
         attachments.resolve(prepared.session.projectId, prepared.input.attachmentIds ?? [])
       );
-      await Effect16.runPromise(runtime.send(prepared.session, prepared.input.prompt, files));
+      await Effect17.runPromise(runtime.send(prepared.session, prepared.input.prompt, files));
       return reply.code(202).send(prepared.session);
     } catch (error) {
       if (preparedSession) {
@@ -4144,9 +4203,9 @@ var HistoryQuery = z17.object({
 app.get("/api/sessions/:id/events", async (request, reply) => {
   const query = HistoryQuery.safeParse(request.query);
   if (!query.success) return reply.code(400).send({ error: "Invalid history cursor or limit." });
-  const session = await Effect16.runPromise(store.get(request.params.id));
+  const session = await Effect17.runPromise(store.get(request.params.id));
   if (!session) return reply.code(404).send({ error: "Session not found." });
-  return Effect16.runPromise(store.history(session.id, query.data.after, query.data.limit));
+  return Effect17.runPromise(store.history(session.id, query.data.after, query.data.limit));
 });
 async function selectSessionModel(input, hasImages) {
   try {
@@ -4166,8 +4225,8 @@ async function selectSessionModel(input, hasImages) {
   }
 }
 async function resolveSessionProject(projectId) {
-  const projectsRoot = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const project = (await Effect16.runPromise(discoverProjects(projectsRoot, store))).find(
+  const projectsRoot = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const project = (await Effect17.runPromise(discoverProjects(projectsRoot, store))).find(
     (item) => item.id === projectId && item.available
   );
   if (!project)
@@ -4209,7 +4268,7 @@ async function createAndStartSession(input) {
   const projectPath = location.projectPath;
   let files;
   try {
-    files = await Effect16.runPromise(
+    files = await Effect17.runPromise(
       attachments.resolve(input.projectId, input.attachmentIds ?? [])
     );
   } catch (error) {
@@ -4222,17 +4281,18 @@ async function createAndStartSession(input) {
   if (selection.error !== void 0) return { error: selection.error, status: selection.status };
   const selectedModel = selection.model;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const task = input.taskId ? await Effect16.runPromise(store.getTask(input.taskId)) : void 0;
+  const task = input.taskId ? await Effect17.runPromise(store.getTask(input.taskId)) : void 0;
   if (input.taskId && sessionTaskUnavailable(task, input.projectId))
     return { error: "Task not found.", status: 404 };
   const session = SessionSchema.parse({
-    id: randomUUID8(),
+    id: randomUUID9(),
     taskId: input.taskId ?? null,
     projectId: input.projectId,
     title: task?.title ?? input.prompt.slice(0, 80),
     status: "starting",
     agent: input.agent,
     model: selectedModel,
+    usage: { tokens: 0, turns: 0, tools: 0 },
     gitFlow: input.gitFlow,
     branch: null,
     createdAt: now,
@@ -4251,7 +4311,7 @@ async function createAndStartSession(input) {
     );
   } catch (error) {
     if (task)
-      await Effect16.runPromise(
+      await Effect17.runPromise(
         store.saveTask({ ...task, sessionId: session.id, updatedAt: (/* @__PURE__ */ new Date()).toISOString() })
       );
     return {
@@ -4260,7 +4320,7 @@ async function createAndStartSession(input) {
     };
   }
   try {
-    await Effect16.runPromise(runtime.send(running, input.prompt, files));
+    await Effect17.runPromise(runtime.send(running, input.prompt, files));
   } catch (error) {
     publish({
       type: "session.updated",
@@ -4269,8 +4329,27 @@ async function createAndStartSession(input) {
     publish({ type: "error", sessionId: session.id, message: String(error) });
     return { error: "Could not start the agent session.", status: 500 };
   }
-  return { session: await Effect16.runPromise(store.get(session.id)), status: 201 };
+  return { session: await Effect17.runPromise(store.get(session.id)), status: 201 };
 }
+app.post("/api/projects/:id/chat", async (request, reply) => {
+  maintenance.assertReady();
+  const location = await resolveSessionProject(request.params.id);
+  if (location.error !== void 0)
+    return reply.code(location.status).send({ error: location.error });
+  const parsed = z17.object({ reset: z17.boolean().optional() }).safeParse(request.body ?? {});
+  if (!parsed.success) return reply.code(400).send({ error: parsed.error.flatten() });
+  try {
+    return await openRepoChat(
+      store,
+      request.params.id,
+      location.projectPath,
+      () => models.defaultIdentity(),
+      parsed.data.reset
+    );
+  } catch (error) {
+    return reply.code(409).send({ error: String(error) });
+  }
+});
 app.post("/api/sessions", async (request, reply) => {
   const parsed = CreateSessionSchema.safeParse(request.body);
   if (!parsed.success) return reply.code(400).send({ error: parsed.error.flatten() });
@@ -4287,11 +4366,11 @@ function startTask(id, instructionsOverride, automated = false) {
     "agent-dispatch",
     () => withTaskLock(id, async () => {
       maintenance.assertReady();
-      const task = await Effect16.runPromise(store.getTask(id));
+      const task = await Effect17.runPromise(store.getTask(id));
       if (!task || task.deletedAt) throw new TaskActionError("Task not found.", 404);
       if (automated) {
-        const state = await Effect16.runPromise(store.automation());
-        if (activeAgents(await Effect16.runPromise(store.list())) >= state.config.parallelism) return;
+        const state = await Effect17.runPromise(store.automation());
+        if (activeAgents(await Effect17.runPromise(store.list())) >= state.config.parallelism) return;
         const backlog = await boardTasks(store);
         if (!backlog.some((item) => item.id === id && item.status === "backlog")) return;
       }
@@ -4299,7 +4378,7 @@ function startTask(id, instructionsOverride, automated = false) {
       const prompt = instructions ? `${task.title}
 
 ${instructions}` : task.title;
-      const linkedSession = task.sessionId ? await Effect16.runPromise(store.get(task.sessionId)) : void 0;
+      const linkedSession = task.sessionId ? await Effect17.runPromise(store.get(task.sessionId)) : void 0;
       if (linkedSession && (["starting", "running", "queued"].includes(linkedSession.status) || linkedSession.gitDelivery?.status === "pending"))
         throw new TaskActionError("This task already has a running agent.", 409);
       const result = await createAndStartSession({
@@ -4313,7 +4392,7 @@ ${instructions}` : task.title;
       });
       if (!result.session)
         throw new TaskActionError(result.error ?? "Could not start task.", result.status);
-      const updatedTask = await Effect16.runPromise(
+      const updatedTask = await Effect17.runPromise(
         store.saveTask({
           ...task,
           status: taskStatusForSession(result.session.status, result.session),
@@ -4348,8 +4427,8 @@ app.patch("/api/automation", async (request, reply) => {
   const parsed = AutomationConfigSchema.safeParse(request.body);
   if (!parsed.success)
     return reply.code(400).send({ error: parsed.error.issues.map((issue) => issue.message).join(" ") });
-  const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
-  const projects = await Effect16.runPromise(discoverProjects(root, store));
+  const root = await Effect17.runPromise(store.projectsRoot(defaultProjectsRoot));
+  const projects = await Effect17.runPromise(discoverProjects(root, store));
   if (parsed.data.projectIds.some(
     (id) => !projects.some((project) => project.id === id && project.available)
   ))
@@ -4377,7 +4456,7 @@ automationTimer.unref();
 app.post(
   "/api/sessions/:id/messages",
   async (request, reply) => withSessionTaskLock(request.params.id, async () => {
-    const session = await Effect16.runPromise(store.get(request.params.id));
+    const session = await Effect17.runPromise(store.get(request.params.id));
     if (!session) return reply.code(404).send({ error: "Session not found." });
     const parsed = SendMessageSchema.safeParse(request.body);
     if (!parsed.success) return reply.code(400).send({ error: parsed.error.flatten() });
@@ -4385,10 +4464,10 @@ app.post(
       await delivery.assertCanWork(session.id);
       if (session.preparation && session.preparation.status !== "ready")
         throw new Error("Retry workspace preparation before sending a message.");
-      const files = await Effect16.runPromise(
+      const files = await Effect17.runPromise(
         attachments.resolve(session.projectId, parsed.data.attachmentIds ?? [])
       );
-      await Effect16.runPromise(
+      await Effect17.runPromise(
         runtime.send(
           session,
           parsed.data.message,
@@ -4404,22 +4483,22 @@ app.post(
   })
 );
 async function withSessionTaskLock(id, operation) {
-  const session = await Effect16.runPromise(store.get(id));
+  const session = await Effect17.runPromise(store.get(id));
   const lockId = session ? await sessionTaskLockId(store, session) : `session-${id}`;
   return withTaskLock(lockId, operation);
 }
 app.post(
   "/api/sessions/:id/stop",
   async (request, reply) => withSessionTaskLock(request.params.id, async () => {
-    const session = await Effect16.runPromise(store.get(request.params.id));
+    const session = await Effect17.runPromise(store.get(request.params.id));
     if (!session) return reply.code(404).send({ error: "Session not found." });
-    await Effect16.runPromise(runtime.stop(session));
+    await Effect17.runPromise(runtime.stop(session));
     return reply.code(202).send({ accepted: true });
   })
 );
 attachEventServer(app, security, allowedOrigins, () => ({
   type: "snapshot",
-  sessions: Effect16.runSync(store.list())
+  sessions: Effect17.runSync(store.list())
 }));
 var closeControl = await startControl(
   dataRoot,
@@ -4431,7 +4510,7 @@ var closeControl = await startControl(
     connectedDevices: new Set(security.sockets.values()).size,
     connectedSockets: security.sockets.size,
     memory: process.memoryUsage().rss,
-    activeRuns: activeAgents(Effect16.runSync(store.list())),
+    activeRuns: activeAgents(Effect17.runSync(store.list())),
     maintenance: maintenance.status()
   }),
   maintenance
@@ -4449,7 +4528,7 @@ app.addHook("onClose", async () => {
   clearInterval(automationTimer);
   await withTaskLock("automation", async () => {
   });
-  await Effect16.runPromise(runtime.close());
+  await Effect17.runPromise(runtime.close());
   await agentEffects.dispose();
   await attachmentEffects.dispose();
   await effects.dispose();