@agentrific/server 0.1.0 → 0.1.4

package/index.js

@@ -33,6 +33,9 @@ var cronBounds = [
   [1, 12],
   [0, 6]
 ];
+function cronRange(base, min, max, stepped) {
+  return base === "*" ? [min, max] : base.includes("-") ? base.split("-").map(Number) : [Number(base), stepped ? max : Number(base)];
+}
 function cronFields(expression) {
   const fields = expression.trim().split(/\s+/);
   if (fields.length !== 5)
@@ -45,7 +48,7 @@ function cronFields(expression) {
       if (!match) throw new Error("Use numeric cron fields, *, ranges, lists and steps.");
       const base = match[1];
       const step = Number(match[2] ?? 1);
-      const [start, end] = base === "*" ? [min, max] : base.includes("-") ? base.split("-").map(Number) : [Number(base), match[2] ? max : Number(base)];
+      const [start, end] = cronRange(base, min, max, Boolean(match[2]));
       if (!Number.isInteger(step) || step < 1 || step > max - min + 1 || start < min || end > max || start > end)
         throw new Error("Cron field is outside its allowed range.");
       for (let value = start; value <= end; value += step) values.add(value);
@@ -287,6 +290,7 @@ var TaskSchema = z.object({
   gitFlow: GitFlowSchema.optional(),
   status: TaskStatusSchema,
   sessionId: z.string().nullable(),
+  pullRequestUrl: z.string().url().optional(),
   createdAt: z.string().datetime(),
   updatedAt: z.string().datetime(),
   deletedAt: z.string().datetime().optional()
@@ -304,7 +308,7 @@ var UpdateTaskSchema = CreateTaskSchema.pick({
   prompt: true,
   attachmentIds: true,
   gitFlow: true
-}).strict();
+}).extend({ gitFlow: GitFlowSchema.nullable().optional() }).strict();
 var PROTOCOL_VERSION = 1;
 var ServerUpdateStatusSchema = z.object({
   currentVersion: z.string(),
@@ -910,8 +914,20 @@ async function startControl(directory, security2, status, maintenance2) {
 // package.json
 var package_default = {
   name: "@agentrific/server",
-  version: "0.1.0",
+  version: "0.1.4",
   description: "Self-hosted control plane for long-running coding agents",
+  keywords: [
+    "agentrific",
+    "ai",
+    "android",
+    "cli",
+    "coding-agents",
+    "ios",
+    "pi",
+    "remote-control",
+    "self-hosted"
+  ],
+  homepage: "https://agentrific.com",
   repository: {
     type: "git",
     url: "git+https://github.com/devular/agentrific.git",
@@ -931,7 +947,7 @@ var package_default = {
     cli: "AGENTRIFIC_DATA_DIR=./data tsx src/cli.ts"
   },
   dependencies: {
-    "@earendil-works/pi-coding-agent": "^0.87.1",
+    "@earendil-works/pi-coding-agent": "1.0.0",
     "@fastify/cors": "^11.3.0",
     "@fastify/multipart": "^10.1.2",
     "@inquirer/select": "^5.2.5",
@@ -1157,6 +1173,9 @@ function taskStatusForSession(status, session) {
       return "needs_user_input";
   }
 }
+function pullRequestUrl(session) {
+  return session.gitDelivery?.status === "pr_opened" ? session.gitDelivery.url : void 0;
+}
 function sessionTask(session) {
   return TaskSchema.parse({
     id: `session-${session.id}`,
@@ -1167,6 +1186,7 @@ function sessionTask(session) {
     gitFlow: session.gitFlow,
     status: taskStatusForSession(session.status, session),
     sessionId: session.id,
+    pullRequestUrl: pullRequestUrl(session),
     createdAt: session.createdAt,
     updatedAt: session.updatedAt
   });
@@ -1178,12 +1198,13 @@ async function boardTasks(store2, projectId) {
     tasks.flatMap((task) => task.sessionId ? [task.sessionId] : [])
   );
   const linkedTasks = tasks.filter((task) => !task.deletedAt).map((task) => {
-    const session = sessions.find((item) => item.taskId === task.id) ?? sessions.find((item) => item.id === task.sessionId);
-    if (!session) return { ...task, status: "backlog" };
+    const session = sessions.find((item) => item.id === task.sessionId) ?? sessions.find((item) => item.taskId === task.id);
+    if (!session) return { ...task, status: "backlog", pullRequestUrl: void 0 };
     linkedSessionIds.add(session.id);
     return {
       ...task,
       sessionId: session.id,
+      pullRequestUrl: pullRequestUrl(session),
       status: taskStatusForSession(session.status, session)
     };
   });
@@ -1201,7 +1222,9 @@ async function findTask(store2, id) {
 function editTask(store2, id, input, resolveAttachments) {
   return withTaskLock(id, async () => {
     const task = await findTask(store2, id);
-    const { attachmentIds, ...updates2 } = input;
+    const { attachmentIds, gitFlow, ...updates2 } = input;
+    const configuration = { gitFlow: task.gitFlow };
+    if (gitFlow !== void 0) configuration.gitFlow = gitFlow ?? void 0;
     let files = task.attachments;
     if (attachmentIds) {
       if (!resolveAttachments)
@@ -1212,6 +1235,7 @@ function editTask(store2, id, input, resolveAttachments) {
       store2.saveTask({
         ...task,
         ...updates2,
+        ...configuration,
         attachments: files,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       })
@@ -1455,7 +1479,7 @@ var AgentController = class {
       Effect7.gen({ self: this }, function* () {
         if (this.closed)
           return yield* Effect7.fail(new AgentError({ message: "Server is shutting down" }));
-        if (!session.branch)
+        if (!session.branch && (session.gitFlow || !session.workspacePath))
           return yield* Effect7.fail(new AgentError({ message: "Session checkout is not ready" }));
         if (this.hasMessage(session.id, messageId)) return;
         const entry = yield* this.open(session);
@@ -1762,45 +1786,7 @@ ${error ? workflowError(error instanceof Error ? error : String(error)) : messag
         if (await this.git(session, ["branch", "--show-current"], signal) !== session.branch)
           throw new Error("Restore the assigned run branch before requesting delivery.");
         if (dirty) {
-          await this.git(session, ["add", "--all"], signal);
-          await this.stage(job, "drafting");
-          const diff = await this.git(session, ["diff", "--cached", "HEAD", "--"], signal);
-          const files = await this.git(
-            session,
-            ["ls-files", "--others", "--exclude-standard"],
-            signal
-          );
-          if (this.options.draft) {
-            try {
-              const draft = await this.options.draft(
-                session,
-                input,
-                `${diff}
-New files:
-${files}`.slice(0, 4e4),
-                signal
-              );
-              job.title = draft.title;
-              job.body = draft.body;
-            } catch (error) {
-              job.logs = workflowLog(
-                `${job.logs}
-Message helper unavailable; using task summary. ${workflowError(error instanceof Error ? error : String(error))}`
-              );
-            }
-          }
-          await this.stage(job, "committing");
-          if (await this.git(session, ["branch", "--show-current"], signal) !== session.branch)
-            throw new Error("The workspace changed branches while preparing delivery.");
-          const output = await this.git(
-            session,
-            ["commit", "-m", `${job.title}
-
-Agentrific run ${id}.`],
-            signal
-          );
-          job.logs = workflowLog(`${job.logs}
-${output}`);
+          await this.commitChanges(session, job, input, signal);
         } else {
           await this.git(session, ["hook", "run", "--ignore-missing", "pre-commit"], signal);
         }
@@ -1827,6 +1813,44 @@ ${workflowError(error instanceof Error ? error : String(error))}`
       }
     });
   }
+  async commitChanges(session, job, input, signal) {
+    const id = session.id;
+    await this.git(session, ["add", "--all"], signal);
+    await this.stage(job, "drafting");
+    const diff = await this.git(session, ["diff", "--cached", "HEAD", "--"], signal);
+    const files = await this.git(session, ["ls-files", "--others", "--exclude-standard"], signal);
+    if (this.options.draft) {
+      try {
+        const draft = await this.options.draft(
+          session,
+          input,
+          `${diff}
+New files:
+${files}`.slice(0, 4e4),
+          signal
+        );
+        job.title = draft.title;
+        job.body = draft.body;
+      } catch (error) {
+        job.logs = workflowLog(
+          `${job.logs}
+Message helper unavailable; using task summary. ${workflowError(error instanceof Error ? error : String(error))}`
+        );
+      }
+    }
+    await this.stage(job, "committing");
+    if (await this.git(session, ["branch", "--show-current"], signal) !== session.branch)
+      throw new Error("The workspace changed branches while preparing delivery.");
+    const output = await this.git(
+      session,
+      ["commit", "-m", `${job.title}
+
+Agentrific run ${id}.`],
+      signal
+    );
+    job.logs = workflowLog(`${job.logs}
+${output}`);
+  }
   fallbackBody(id, input) {
     return `${input.summary}
 
@@ -1899,6 +1923,31 @@ Agentrific run ${id}.`;
         );
     }
   }
+  async mergeChanges(session, job, projectPath, commit) {
+    await this.stage(job, "integrating");
+    if (session.gitFlow.workspace === "checkout" && await this.command(projectPath, "git", ["branch", "--show-current"]) === session.branch)
+      await this.command(projectPath, "git", ["switch", "main"]);
+    if (await this.command(projectPath, "git", ["branch", "--show-current"]) !== "main")
+      throw new Error("Switch the project checkout to main, then retry delivery.");
+    if (await this.command(projectPath, "git", ["status", "--porcelain"]))
+      throw new Error(
+        "Waiting for local changes in the main checkout. Commit or move them, then retry delivery."
+      );
+    const included = await this.command(projectPath, "git", ["merge-base", "main", commit]) === commit;
+    if (!included) {
+      try {
+        await this.command(projectPath, "git", ["merge", "--no-edit", commit]);
+      } catch (error) {
+        await this.command(projectPath, "git", ["merge", "--abort"]).catch(() => void 0);
+        throw new Error(
+          `Integration failed. Resolve conflicts against main in the run workspace, then call deliver_changes again.
+${workflowError(error instanceof Error ? error : String(error))}`
+        );
+      }
+    }
+    job.result = "merged";
+    job.message = "Committed changes are on main.";
+  }
   async integrate(id) {
     const job = await this.job(id);
     if (!job?.commitSha) return;
@@ -1912,29 +1961,7 @@ Agentrific run ${id}.`;
             "The workspace changed after requesting delivery. Call deliver_changes again for the new changes."
           );
         if (session.gitFlow.delivery === "merge") {
-          await this.stage(job, "integrating");
-          if (session.gitFlow.workspace === "checkout" && await this.command(projectPath, "git", ["branch", "--show-current"]) === session.branch)
-            await this.command(projectPath, "git", ["switch", "main"]);
-          if (await this.command(projectPath, "git", ["branch", "--show-current"]) !== "main")
-            throw new Error("Switch the project checkout to main, then retry delivery.");
-          if (await this.command(projectPath, "git", ["status", "--porcelain"]))
-            throw new Error(
-              "Waiting for local changes in the main checkout. Commit or move them, then retry delivery."
-            );
-          const included = await this.command(projectPath, "git", ["merge-base", "main", commit]) === commit;
-          if (!included) {
-            try {
-              await this.command(projectPath, "git", ["merge", "--no-edit", commit]);
-            } catch (error) {
-              await this.command(projectPath, "git", ["merge", "--abort"]).catch(() => void 0);
-              throw new Error(
-                `Integration failed. Resolve conflicts against main in the run workspace, then call deliver_changes again.
-${workflowError(error instanceof Error ? error : String(error))}`
-              );
-            }
-          }
-          job.result = "merged";
-          job.message = "Committed changes are on main.";
+          await this.mergeChanges(session, job, projectPath, commit);
         } else {
           await this.stage(job, "pushing");
           await this.git(session, ["push", "origin", `${commit}:refs/heads/${session.branch}`]);
@@ -2012,6 +2039,7 @@ var PreparationCoordinator = class {
     return [...this.preparing.values()].map((id) => `preparation:${id}`);
   }
   async prepare(session, projectPath, input) {
+    if (!session.gitFlow) return { ...session, branch: null, workspacePath: projectPath };
     const preparation2 = Symbol(session.id);
     this.preparing.set(preparation2, session.id);
     return withTaskLock(`prepare:${session.id}`, async () => {
@@ -2044,56 +2072,7 @@ ${logs}` : ""}`);
       try {
         await record("creating", "Creating the run workspace\u2026");
         const workspace = session.workspacePath;
-        const checkout = session.gitFlow?.workspace === "checkout";
-        const branchAtWorkspace = await command(workspace, "git", [
-          "branch",
-          "--show-current"
-        ]).catch(() => void 0);
-        if (branchAtWorkspace !== session.branch) {
-          if (checkout) {
-            if (branchAtWorkspace !== "main" || await command(projectPath, "git", ["status", "--porcelain"]))
-              throw new Error(
-                "The project checkout must be clean and on main before starting a checkout run."
-              );
-            await command(
-              projectPath,
-              "git",
-              ["switch", "-c", session.branch, "main"],
-              void 0,
-              true
-            );
-          } else {
-            if (branchAtWorkspace !== void 0)
-              throw new Error("The run workspace already exists on a different branch.");
-            await mkdir3(path4.dirname(workspace), { recursive: true });
-            try {
-              await command(
-                projectPath,
-                "git",
-                [
-                  "worktree",
-                  "add",
-                  "-b",
-                  session.branch,
-                  workspace,
-                  session.gitFlow ? "main" : "HEAD"
-                ],
-                void 0,
-                true
-              );
-            } catch (error) {
-              if (await command(workspace, "git", ["branch", "--show-current"]).catch(
-                () => void 0
-              ) !== session.branch)
-                throw error;
-              await record(
-                "creating",
-                "Workspace created; a checkout hook failed. Preparing dependencies\u2026",
-                workflowError(error instanceof Error ? error : String(error))
-              );
-            }
-          }
-        }
+        await this.createWorkspace(session, projectPath, command, record);
         await record("installing", "Installing run dependencies\u2026");
         await this.install(workspace, command);
         await record("ready", "Workspace ready.");
@@ -2109,6 +2088,57 @@ ${logs}` : ""}`);
       }
     }).finally(() => this.preparing.delete(preparation2));
   }
+  async createWorkspace(session, projectPath, command, record) {
+    const workspace = session.workspacePath;
+    const checkout = session.gitFlow?.workspace === "checkout";
+    if (!await command(projectPath, "git", ["rev-parse", "--verify", "HEAD"]).catch(() => void 0))
+      throw new Error(
+        "Git Flow needs an initial commit. Create one in the project, or turn off Git Flow for a plain chat."
+      );
+    const branchAtWorkspace = await command(workspace, "git", ["branch", "--show-current"]).catch(
+      () => void 0
+    );
+    if (branchAtWorkspace !== session.branch) {
+      if (checkout) {
+        if (branchAtWorkspace !== "main" || await command(projectPath, "git", ["status", "--porcelain"]))
+          throw new Error(
+            "The project checkout must be clean and on main before starting a checkout run."
+          );
+        await command(
+          projectPath,
+          "git",
+          ["switch", "-c", session.branch, "main"],
+          void 0,
+          true
+        );
+      } else {
+        await this.createWorktree(session, projectPath, command, record, branchAtWorkspace);
+      }
+    }
+  }
+  async createWorktree(session, projectPath, command, record, branchAtWorkspace) {
+    const workspace = session.workspacePath;
+    if (branchAtWorkspace !== void 0)
+      throw new Error("The run workspace already exists on a different branch.");
+    await mkdir3(path4.dirname(workspace), { recursive: true });
+    try {
+      await command(
+        projectPath,
+        "git",
+        ["worktree", "add", "-b", session.branch, workspace, "main"],
+        void 0,
+        true
+      );
+    } catch (error) {
+      if (await command(workspace, "git", ["branch", "--show-current"]).catch(() => void 0) !== session.branch)
+        throw error;
+      await record(
+        "creating",
+        "Workspace created; a checkout hook failed. Preparing dependencies\u2026",
+        workflowError(error instanceof Error ? error : String(error))
+      );
+    }
+  }
   async install(workspace, command) {
     const packageFile = await readFile3(path4.join(workspace, "package.json"), "utf8").catch(
       () => void 0
@@ -2198,10 +2228,10 @@ ${logs}` : ""}`);
 import { createAgentSession, SessionManager } from "@earendil-works/pi-coding-agent";
 import { z as z9 } from "zod";
 var DraftSchema = z9.object({ title: z9.string().trim().min(1).max(120), body: z9.string().trim().min(1).max(1e4) }).strict();
-function deliveryWriter(models2) {
+function deliveryWriter(models2, createSession = createAgentSession) {
   return async (run, input, diff, signal) => {
     signal?.throwIfAborted();
-    const { session } = await createAgentSession({
+    const { session } = await createSession({
       cwd: run.workspacePath,
       model: await models2.resolve(run.model ?? await models2.defaultReference()),
       modelRuntime: models2.runtime,
@@ -2404,11 +2434,11 @@ function toolOutput(value) {
   const text = parsed.success ? parsed.data.content?.filter((part) => part.type === "text").map((part) => part.text || "").join("\n") || "Completed without text output." : boundedJson(value, 4e3);
   return text.length > 4e3 ? `${text.slice(0, 4e3)}\u2026 [truncated]` : text;
 }
-function createPiFactory(files, models2, delivery2) {
+function createPiFactory(files, models2, delivery2, createSession = createAgentSession2) {
   return {
     async open(sessionId, cwd, sessionDirectory, selected = legacyModel, run) {
       const model = await models2.resolve(selected);
-      const { session } = await createAgentSession2({
+      const { session } = await createSession({
         cwd,
         model,
         modelRuntime: models2.runtime,
@@ -2833,31 +2863,7 @@ var SqliteSessionStore = class {
           this.db.prepare("DELETE FROM projects WHERE id = ?").run(replacedId);
         }
         if (previousPath && previousPath !== project.path) {
-          this.db.prepare(
-            "UPDATE workflows SET payload = json_set(payload, '$.projectPath', ?) WHERE json_extract(payload, '$.kind') = 'preparation' AND json_extract(payload, '$.projectPath') = ?"
-          ).run(project.path, previousPath);
-          const relocate = (workspace) => workspace === previousPath || workspace.startsWith(`${previousPath}${path6.sep}`) ? project.path + workspace.slice(previousPath.length) : workspace;
-          for (const row of this.db.prepare(
-            "SELECT id, payload FROM sessions WHERE json_extract(payload, '$.projectId') = ?"
-          ).all(project.id)) {
-            const session = SessionSchema.parse(JSON.parse(PayloadRow.parse(row).payload));
-            if (session.workspacePath) {
-              session.workspacePath = String(relocate(session.workspacePath));
-              this.db.prepare("UPDATE sessions SET payload = ? WHERE id = ?").run(JSON.stringify(session), session.id);
-            }
-          }
-          for (const row of this.db.prepare(
-            "SELECT sequence, payload FROM events WHERE json_extract(payload, '$.session.projectId') = ?"
-          ).all(project.id)) {
-            const event = SessionSchema.parse(JSON.parse(PayloadRow.parse(row).payload).session);
-            if (event.workspacePath) {
-              event.workspacePath = String(relocate(event.workspacePath));
-              this.db.prepare("UPDATE events SET payload = ? WHERE sequence = ?").run(
-                JSON.stringify({ type: "session.updated", session: event }),
-                Number(row.sequence)
-              );
-            }
-          }
+          this.relocateProjectHistory(project, previousPath);
         }
         this.db.prepare(
           "INSERT INTO projects(id, payload) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET payload = excluded.payload"
@@ -2870,6 +2876,28 @@ var SqliteSessionStore = class {
       }
     });
   }
+  relocateProjectHistory(project, previousPath) {
+    this.db.prepare(
+      "UPDATE workflows SET payload = json_set(payload, '$.projectPath', ?) WHERE json_extract(payload, '$.kind') = 'preparation' AND json_extract(payload, '$.projectPath') = ?"
+    ).run(project.path, previousPath);
+    const relocate = (workspace) => workspace === previousPath || workspace.startsWith(`${previousPath}${path6.sep}`) ? project.path + workspace.slice(previousPath.length) : workspace;
+    for (const row of this.db.prepare("SELECT id, payload FROM sessions WHERE json_extract(payload, '$.projectId') = ?").all(project.id)) {
+      const session = SessionSchema.parse(JSON.parse(PayloadRow.parse(row).payload));
+      if (session.workspacePath) {
+        session.workspacePath = String(relocate(session.workspacePath));
+        this.db.prepare("UPDATE sessions SET payload = ? WHERE id = ?").run(JSON.stringify(session), session.id);
+      }
+    }
+    for (const row of this.db.prepare(
+      "SELECT sequence, payload FROM events WHERE json_extract(payload, '$.session.projectId') = ?"
+    ).all(project.id)) {
+      const event = SessionSchema.parse(JSON.parse(PayloadRow.parse(row).payload).session);
+      if (event.workspacePath) {
+        event.workspacePath = String(relocate(event.workspacePath));
+        this.db.prepare("UPDATE events SET payload = ? WHERE sequence = ?").run(JSON.stringify({ type: "session.updated", session: event }), Number(row.sequence));
+      }
+    }
+  }
   defaultModel() {
     return this.query(() => {
       const row = this.db.prepare("SELECT payload FROM settings WHERE id = 'default-model'").get();
@@ -3474,16 +3502,27 @@ app.get("/api/sessions/:id/events", async (request, reply) => {
   if (!session) return reply.code(404).send({ error: "Session not found." });
   return Effect14.runPromise(store.history(session.id, query.data.after, query.data.limit));
 });
-async function createAndStartSession(input) {
-  maintenance.assertReady();
-  if (input.gitFlow?.delivery === "pull_request") {
-    const github = await githubCliStatus();
-    if (!github.githubCli.authenticated)
-      return { error: "GitHub CLI must be authenticated on the server to open a PR.", status: 400 };
+async function selectSessionModel(input, hasImages) {
+  try {
+    const reference = input.model ?? await models.defaultReference();
+    const selected = await models.resolve(reference);
+    if (hasImages && !selected.input.includes("image"))
+      return {
+        error: "This model cannot read images. Choose a vision model in Settings.",
+        status: 400
+      };
+    return { model: models.identity(selected.provider, selected.id) };
+  } catch {
+    return {
+      error: "The default model is unavailable. Choose an available model in Settings.",
+      status: 400
+    };
   }
+}
+async function resolveSessionProject(projectId) {
   const projectsRoot = await Effect14.runPromise(store.projectsRoot(defaultProjectsRoot));
   const project = (await Effect14.runPromise(discoverProjects(projectsRoot, store))).find(
-    (item) => item.id === input.projectId && item.available
+    (item) => item.id === projectId && item.available
   );
   if (!project)
     return { error: "Project folder is missing. Reconnect it before starting a run.", status: 404 };
@@ -3491,6 +3530,37 @@ async function createAndStartSession(input) {
   const resolvedRoot = await realpath2(projectsRoot);
   if (path7.dirname(projectPath) !== resolvedRoot)
     return { error: "Project path is outside projects root.", status: 400 };
+  return { projectPath };
+}
+async function resolveSessionWorkspace(id, gitFlow, projectPath) {
+  const worktreePath = path7.join(worktreesRoot, id);
+  const branch = gitFlow ? `agentrific/${id.slice(0, 8)}` : null;
+  const useProjectCheckout = gitFlow?.workspace === "checkout";
+  const workspacePath = !gitFlow || useProjectCheckout ? projectPath : worktreePath;
+  if (useProjectCheckout) {
+    const serverPath = await realpath2(process.cwd());
+    if (serverPath === projectPath || serverPath.startsWith(`${projectPath}${path7.sep}`))
+      return {
+        error: "The server runs from this project. Choose a worktree for this task.",
+        status: 409
+      };
+  }
+  return { branch, workspacePath };
+}
+function sessionTaskUnavailable(task, projectId) {
+  return !task || Boolean(task.deletedAt) || task.projectId !== projectId;
+}
+async function sessionDeliveryAvailable(gitFlow) {
+  if (gitFlow?.delivery !== "pull_request") return true;
+  return (await githubCliStatus()).githubCli.authenticated;
+}
+async function createAndStartSession(input) {
+  maintenance.assertReady();
+  if (!await sessionDeliveryAvailable(input.gitFlow))
+    return { error: "GitHub CLI must be authenticated on the server to open a PR.", status: 400 };
+  const location = await resolveSessionProject(input.projectId);
+  if (location.error !== void 0) return { error: location.error, status: location.status };
+  const projectPath = location.projectPath;
   let files;
   try {
     files = await Effect14.runPromise(
@@ -3499,25 +3569,15 @@ async function createAndStartSession(input) {
   } catch (error) {
     return { error: String(error), status: 400 };
   }
-  let selectedModel;
-  try {
-    const reference = input.model ?? await models.defaultReference();
-    const selected = await models.resolve(reference);
-    if (files.some((file) => file.kind === "image") && !selected.input.includes("image"))
-      return {
-        error: "This model cannot read images. Choose a vision model in Settings.",
-        status: 400
-      };
-    selectedModel = models.identity(selected.provider, selected.id);
-  } catch {
-    return {
-      error: "The default model is unavailable. Choose an available model in Settings.",
-      status: 400
-    };
-  }
+  const selection = await selectSessionModel(
+    input,
+    files.some((file) => file.kind === "image")
+  );
+  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 Effect14.runPromise(store.getTask(input.taskId)) : void 0;
-  if (input.taskId && (!task || task.deletedAt || task.projectId !== input.projectId))
+  if (input.taskId && sessionTaskUnavailable(task, input.projectId))
     return { error: "Task not found.", status: 404 };
   const session = SessionSchema.parse({
     id: randomUUID7(),
@@ -3532,18 +3592,9 @@ async function createAndStartSession(input) {
     createdAt: now,
     updatedAt: now
   });
-  const worktreePath = path7.join(worktreesRoot, session.id);
-  const branch = `agentrific/${session.id.slice(0, 8)}`;
-  const useProjectCheckout = input.gitFlow?.workspace === "checkout";
-  const workspacePath = useProjectCheckout ? projectPath : worktreePath;
-  if (useProjectCheckout) {
-    const serverPath = await realpath2(process.cwd());
-    if (serverPath === projectPath || serverPath.startsWith(`${projectPath}${path7.sep}`))
-      return {
-        error: "The server runs from this project. Choose a worktree for this task.",
-        status: 409
-      };
-  }
+  const workspace = await resolveSessionWorkspace(session.id, input.gitFlow, projectPath);
+  if (workspace.error !== void 0) return { error: workspace.error, status: workspace.status };
+  const { branch, workspacePath } = workspace;
   const initial = { ...session, branch, workspacePath };
   publish({ type: "session.updated", session: initial });
   let running;