openfox 2.0.113 → 2.0.115

package/dist/chunk-6RGACY4E.js

@@ -0,0 +1,1081 @@
+import {
+  deleteItemFromDir,
+  getDefaultIds,
+  jsonSerializer,
+  loadItemsFromDir,
+  pathExists,
+  saveItemToDir
+} from "./chunk-OSXPQSLW.js";
+import {
+  getProject
+} from "./chunk-3PG65AXG.js";
+import {
+  parseDefaultModelSelection
+} from "./chunk-BVVCRIVM.js";
+import {
+  getDatabase
+} from "./chunk-5PT4UMRR.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+
+// src/server/commands/registry.ts
+import { writeFile, mkdir, unlink } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+var __bundleDir = dirname(fileURLToPath(import.meta.url));
+var DEFAULTS_DIR = join(__bundleDir, "defaults");
+var DEFAULTS_DIR_ALT = join(__bundleDir, "command-defaults");
+var COMMAND_EXTENSION = ".command.md";
+function getCommandsDir(configDir) {
+  return join(configDir, "commands");
+}
+function getProjectCommandsDir(projectDir) {
+  return join(projectDir, ".openfox", "commands");
+}
+async function loadDefaultCommands() {
+  let defaults = await loadItemsFromDir(DEFAULTS_DIR, {
+    extension: COMMAND_EXTENSION,
+    logName: "command"
+  });
+  if (!defaults.length) {
+    defaults = await loadItemsFromDir(DEFAULTS_DIR_ALT, {
+      extension: COMMAND_EXTENSION,
+      logName: "command"
+    });
+  }
+  return defaults;
+}
+async function loadUserCommands(configDir) {
+  return loadItemsFromDir(getCommandsDir(configDir), {
+    extension: COMMAND_EXTENSION,
+    logName: "command"
+  });
+}
+async function loadProjectCommands(projectDir) {
+  return loadItemsFromDir(getProjectCommandsDir(projectDir), {
+    extension: COMMAND_EXTENSION,
+    logName: "command"
+  });
+}
+async function loadAllCommands(configDir, projectDir) {
+  const [defaultCommands, userCommands] = await Promise.all([loadDefaultCommands(), loadUserCommands(configDir)]);
+  const commandMap = /* @__PURE__ */ new Map();
+  for (const cmd of defaultCommands) {
+    commandMap.set(cmd.metadata.id, cmd);
+  }
+  for (const cmd of userCommands) {
+    commandMap.set(cmd.metadata.id, cmd);
+  }
+  if (projectDir) {
+    const projectCommands = await loadProjectCommands(projectDir);
+    for (const cmd of projectCommands) {
+      commandMap.set(cmd.metadata.id, cmd);
+    }
+  }
+  return Array.from(commandMap.values());
+}
+async function getDefaultCommandIds() {
+  const ids = await getDefaultIds(DEFAULTS_DIR, COMMAND_EXTENSION);
+  if (ids.length) return ids;
+  return getDefaultIds(DEFAULTS_DIR_ALT, COMMAND_EXTENSION);
+}
+async function isDefaultCommand(commandId) {
+  const defaultIds = await getDefaultCommandIds();
+  return defaultIds.includes(commandId);
+}
+function findCommandById(commandId, commands) {
+  return commands.find((c) => c.metadata.id === commandId);
+}
+async function commandExists(configDir, commandId, projectDir) {
+  if (await pathExists(join(getCommandsDir(configDir), `${commandId}${COMMAND_EXTENSION}`))) return true;
+  if (projectDir && await pathExists(join(getProjectCommandsDir(projectDir), `${commandId}${COMMAND_EXTENSION}`)))
+    return true;
+  return false;
+}
+async function saveCommand(configDir, command) {
+  const commandsDir = getCommandsDir(configDir);
+  if (!await pathExists(commandsDir)) {
+    await mkdir(commandsDir, { recursive: true });
+  }
+  const filePath = join(commandsDir, `${command.metadata.id}${COMMAND_EXTENSION}`);
+  const content = matter.stringify(command.prompt, command.metadata);
+  await writeFile(filePath, content, "utf-8");
+}
+async function saveCommandToProject(projectDir, command) {
+  await saveItemToDir(
+    getProjectCommandsDir(projectDir),
+    command,
+    COMMAND_EXTENSION,
+    (c) => matter.stringify(c.prompt, c.metadata)
+  );
+}
+async function deleteProjectCommand(projectDir, commandId) {
+  return deleteItemFromDir(getProjectCommandsDir(projectDir), commandId, COMMAND_EXTENSION);
+}
+async function deleteCommand(configDir, commandId) {
+  const filePath = join(getCommandsDir(configDir), `${commandId}${COMMAND_EXTENSION}`);
+  if (!await pathExists(filePath)) {
+    if (await isDefaultCommand(commandId)) {
+      return { success: false, reason: "Cannot delete built-in defaults" };
+    }
+    return { success: false };
+  }
+  try {
+    await unlink(filePath);
+    return { success: true };
+  } catch {
+    return { success: false, reason: "Failed to delete command" };
+  }
+}
+
+// src/server/workflows/registry.ts
+import { readdir, readFile, writeFile as writeFile2, mkdir as mkdir2, access, unlink as unlink2 } from "fs/promises";
+import { join as join2, dirname as dirname2 } from "path";
+import { constants } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __bundleDir2 = dirname2(fileURLToPath2(import.meta.url));
+var DEFAULTS_DIR2 = join2(__bundleDir2, "defaults");
+var DEFAULTS_DIR_ALT2 = join2(__bundleDir2, "workflow-defaults");
+var WORKFLOW_EXTENSION = ".workflow.json";
+function normalizeWorkflowScope(value) {
+  return typeof value === "string" && (value === "builtin" || value === "user" || value === "project" || value === "auto") ? value : "auto";
+}
+function getWorkflowsDir(configDir) {
+  return join2(configDir, "workflows");
+}
+function getProjectWorkflowsDir(projectDir) {
+  return join2(projectDir, ".openfox", "workflows");
+}
+async function pathExists2(path) {
+  try {
+    await access(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadWorkflowsFromDir(dir) {
+  if (!await pathExists2(dir)) {
+    return [];
+  }
+  let files;
+  try {
+    files = (await readdir(dir)).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
+  } catch {
+    return [];
+  }
+  const workflows = [];
+  for (const file of files) {
+    try {
+      const raw = await readFile(join2(dir, file), "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed.metadata?.id && parsed.steps?.length > 0) {
+        workflows.push(parsed);
+      } else {
+        logger.warn("Skipping invalid workflow file", { file });
+      }
+    } catch (err) {
+      logger.warn("Failed to parse workflow file", { file, error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return workflows;
+}
+async function loadDefaultWorkflows() {
+  let defaults = await loadWorkflowsFromDir(DEFAULTS_DIR2);
+  if (!defaults.length) {
+    defaults = await loadWorkflowsFromDir(DEFAULTS_DIR_ALT2);
+  }
+  return defaults;
+}
+async function loadUserWorkflows(configDir) {
+  return loadWorkflowsFromDir(getWorkflowsDir(configDir));
+}
+async function loadProjectWorkflows(projectDir) {
+  return loadWorkflowsFromDir(getProjectWorkflowsDir(projectDir));
+}
+async function loadAllWorkflows(configDir, projectDir) {
+  const [defaultWorkflows, userWorkflows] = await Promise.all([loadDefaultWorkflows(), loadUserWorkflows(configDir)]);
+  const workflowMap = /* @__PURE__ */ new Map();
+  for (const workflow of defaultWorkflows) {
+    workflowMap.set(workflow.metadata.id, workflow);
+  }
+  for (const workflow of userWorkflows) {
+    workflowMap.set(workflow.metadata.id, workflow);
+  }
+  if (projectDir) {
+    const projectWorkflows = await loadProjectWorkflows(projectDir);
+    for (const workflow of projectWorkflows) {
+      workflowMap.set(workflow.metadata.id, workflow);
+    }
+  }
+  return Array.from(workflowMap.values());
+}
+async function saveWorkflowToProject(projectDir, workflow) {
+  await saveItemToDir(getProjectWorkflowsDir(projectDir), workflow, WORKFLOW_EXTENSION, jsonSerializer);
+}
+async function deleteProjectWorkflow(projectDir, workflowId) {
+  return deleteItemFromDir(getProjectWorkflowsDir(projectDir), workflowId, WORKFLOW_EXTENSION);
+}
+async function getDefaultWorkflowIds() {
+  for (const dir of [DEFAULTS_DIR2, DEFAULTS_DIR_ALT2]) {
+    try {
+      const files = (await readdir(dir)).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
+      return files.map((f) => f.replace(WORKFLOW_EXTENSION, ""));
+    } catch {
+    }
+  }
+  return [];
+}
+async function isDefaultWorkflow(workflowId) {
+  const defaultIds = await getDefaultWorkflowIds();
+  return defaultIds.includes(workflowId);
+}
+function findWorkflowById(workflowId, workflows) {
+  return workflows.find((p) => p.metadata.id === workflowId);
+}
+async function workflowExists(configDir, workflowId, projectDir) {
+  if (await pathExists2(join2(getWorkflowsDir(configDir), `${workflowId}${WORKFLOW_EXTENSION}`))) return true;
+  if (projectDir && await pathExists2(join2(getProjectWorkflowsDir(projectDir), `${workflowId}${WORKFLOW_EXTENSION}`)))
+    return true;
+  return false;
+}
+async function saveWorkflow(configDir, workflow) {
+  const workflowsDir = getWorkflowsDir(configDir);
+  if (!await pathExists2(workflowsDir)) {
+    await mkdir2(workflowsDir, { recursive: true });
+  }
+  const filePath = join2(workflowsDir, `${workflow.metadata.id}${WORKFLOW_EXTENSION}`);
+  await writeFile2(filePath, JSON.stringify(workflow, null, 2) + "\n", "utf-8");
+}
+async function deleteWorkflow(configDir, workflowId) {
+  const isDefault = await isDefaultWorkflow(workflowId);
+  if (isDefault) {
+    return { success: false, reason: "Cannot delete built-in defaults" };
+  }
+  const filePath = join2(getWorkflowsDir(configDir), `${workflowId}${WORKFLOW_EXTENSION}`);
+  try {
+    await unlink2(filePath);
+    return { success: true };
+  } catch {
+    return { success: false };
+  }
+}
+
+// src/server/tasks/slash.ts
+function parseSlashInvocation(prompt) {
+  const trimmed = prompt.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const parts = trimmed.slice(1).split(/\s+/);
+  const id = parts[0];
+  if (!id) return null;
+  return { id, args: parts.slice(1) };
+}
+function workflowParamsFromArgs(parameters, args) {
+  const params = {};
+  if (!parameters || parameters.length === 0) {
+    args.forEach((value, index) => {
+      params[String(index)] = value;
+    });
+    return params;
+  }
+  const sorted = [...parameters].sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
+  sorted.forEach((param, index) => {
+    const value = args[index];
+    if (value !== void 0) params[param.id] = value;
+  });
+  return params;
+}
+function extractTemplateParams(template) {
+  const seen = [];
+  const regex = /\{\{(\w+)\}\}/g;
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    const key = match[1];
+    if (!seen.includes(key)) seen.push(key);
+  }
+  return seen;
+}
+function expandCommandPrompt(template, args) {
+  const paramNames = extractTemplateParams(template);
+  const named = {};
+  paramNames.forEach((name, index) => {
+    const value = args[index];
+    if (value !== void 0) named[name] = value;
+  });
+  let prompt = template;
+  for (const [key, value] of Object.entries(named)) {
+    prompt = prompt.replaceAll(`{{${key}}}`, value);
+  }
+  const unfilledParams = paramNames.filter((name) => !(name in named));
+  return { prompt, unfilledParams };
+}
+async function resolveSlashLaunch(configDir, projectDir, prompt) {
+  const invocation = parseSlashInvocation(prompt);
+  if (!invocation) return null;
+  const workflows = await loadAllWorkflows(configDir, projectDir);
+  const workflow = findWorkflowById(invocation.id, workflows);
+  if (workflow) {
+    const params = workflowParamsFromArgs(workflow.metadata.parameters, invocation.args);
+    const required = (workflow.metadata.parameters ?? []).filter((p) => p.required).map((p) => p.id);
+    const missingRequired = required.filter((id) => !(id in params));
+    if (missingRequired.length > 0) {
+      return null;
+    }
+    return {
+      kind: "workflow",
+      workflowId: workflow.metadata.id,
+      params
+    };
+  }
+  const commands = await loadAllCommands(configDir, projectDir);
+  const command = findCommandById(invocation.id, commands);
+  if (!command) return null;
+  const expanded = expandCommandPrompt(command.prompt, invocation.args);
+  if (expanded.unfilledParams.length > 0) return null;
+  return {
+    kind: "command",
+    prompt: expanded.prompt,
+    ...command.metadata.agentMode ? { agentMode: command.metadata.agentMode } : {}
+  };
+}
+
+// src/server/db/tasks.ts
+function createTask(projectId, input) {
+  const db = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = crypto.randomUUID();
+  const position = db.prepare(`SELECT COALESCE(MAX(position), -1) + 1 AS pos FROM tasks WHERE project_id = ? AND status = 'todo'`).get(projectId);
+  db.prepare(
+    `INSERT INTO tasks (id, project_id, prompt, attachments, status, run_state, position, version, agent_id, provider_id, model, created_at, updated_at)
+     VALUES (?, ?, ?, ?, 'todo', NULL, ?, 1, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    projectId,
+    input.prompt,
+    JSON.stringify(input.attachments ?? []),
+    position.pos,
+    input.agentId ?? null,
+    input.providerId ?? null,
+    input.model ?? null,
+    now,
+    now
+  );
+  return getTask(id);
+}
+function getTask(id) {
+  const db = getDatabase();
+  const row = db.prepare(`SELECT * FROM tasks WHERE id = ?`).get(id);
+  if (!row) return null;
+  return hydrateTask(row);
+}
+function listTasks(projectId) {
+  const db = getDatabase();
+  const rows = db.prepare(`SELECT * FROM tasks WHERE project_id = ? ORDER BY position ASC`).all(projectId);
+  return rows.map(hydrateTask);
+}
+function updateTask(id, patch) {
+  const db = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const sets = ["updated_at = ?", "version = version + 1"];
+  const values = [now];
+  if (patch.prompt !== void 0) {
+    sets.push("prompt = ?");
+    values.push(patch.prompt);
+  }
+  if (patch.attachments !== void 0) {
+    sets.push("attachments = ?");
+    values.push(JSON.stringify(patch.attachments));
+  }
+  if (patch.agentId !== void 0) {
+    sets.push("agent_id = ?");
+    values.push(patch.agentId);
+  }
+  if (patch.providerId !== void 0) {
+    sets.push("provider_id = ?");
+    values.push(patch.providerId);
+  }
+  if (patch.model !== void 0) {
+    sets.push("model = ?");
+    values.push(patch.model);
+  }
+  values.push(id);
+  db.prepare(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+  return getTask(id);
+}
+function setTaskStatus(id, status) {
+  const db = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`UPDATE tasks SET status = ?, run_state = NULL, version = version + 1, updated_at = ? WHERE id = ?`).run(
+    status,
+    now,
+    id
+  );
+}
+function setTaskRunState(id, runState) {
+  const db = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`UPDATE tasks SET run_state = ?, version = version + 1, updated_at = ? WHERE id = ?`).run(
+    runState,
+    now,
+    id
+  );
+}
+function deleteTask(id) {
+  const db = getDatabase();
+  db.prepare(`DELETE FROM tasks WHERE id = ?`).run(id);
+}
+function appendToBottom(id, status) {
+  const db = getDatabase();
+  const task = getTask(id);
+  if (!task) return;
+  const row = db.prepare(`SELECT COALESCE(MAX(position), -1) + 1 AS pos FROM tasks WHERE project_id = ? AND status = ?`).get(task.projectId, status);
+  db.prepare(`UPDATE tasks SET position = ?, version = version + 1, updated_at = ? WHERE id = ?`).run(
+    row.pos,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    id
+  );
+}
+function cloneTask(sourceId) {
+  const source = getTask(sourceId);
+  if (!source) return null;
+  return createTask(source.projectId, {
+    prompt: source.prompt,
+    attachments: source.attachments,
+    ...source.agentId ? { agentId: source.agentId } : {},
+    ...source.providerId ? { providerId: source.providerId } : {},
+    ...source.model ? { model: source.model } : {}
+  });
+}
+function reorderTask(id, status, toIndex) {
+  const db = getDatabase();
+  const task = getTask(id);
+  if (!task) return;
+  const rows = db.prepare(`SELECT id FROM tasks WHERE project_id = ? AND status = ? ORDER BY position ASC, created_at ASC`).all(task.projectId, status);
+  const ids = rows.map((r) => r.id).filter((tid) => tid !== id);
+  const clamped = Math.max(0, Math.min(toIndex, ids.length));
+  ids.splice(clamped, 0, id);
+  const update = db.prepare(`UPDATE tasks SET position = ?, version = version + 1, updated_at = ? WHERE id = ?`);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const [idx, tid] of ids.entries()) {
+    update.run(idx, now, tid);
+  }
+}
+function addTaskLink(taskId, sessionId, active) {
+  const db = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`INSERT OR IGNORE INTO task_links (task_id, session_id, active, created_at) VALUES (?, ?, ?, ?)`).run(
+    taskId,
+    sessionId,
+    active ? 1 : 0,
+    now
+  );
+  if (active) {
+    db.prepare(`UPDATE task_links SET active = 0 WHERE task_id = ? AND session_id != ?`).run(taskId, sessionId);
+    db.prepare(`UPDATE task_links SET active = 1 WHERE task_id = ? AND session_id = ?`).run(taskId, sessionId);
+  }
+}
+function listTaskLinks(taskId) {
+  const db = getDatabase();
+  return db.prepare(`SELECT * FROM task_links WHERE task_id = ? ORDER BY created_at ASC`).all(taskId);
+}
+function clearActiveTaskLink(taskId) {
+  const db = getDatabase();
+  db.prepare(`UPDATE task_links SET active = 0 WHERE task_id = ?`).run(taskId);
+}
+function removeTaskLinks(taskId, sessionId) {
+  const db = getDatabase();
+  if (sessionId) {
+    db.prepare(`DELETE FROM task_links WHERE task_id = ? AND session_id = ?`).run(taskId, sessionId);
+  } else {
+    db.prepare(`DELETE FROM task_links WHERE task_id = ?`).run(taskId);
+  }
+}
+function getGateConfig(projectId) {
+  const db = getDatabase();
+  const rows = db.prepare(`SELECT * FROM task_gates WHERE project_id = ? ORDER BY sort_order ASC, created_at ASC`).all(projectId);
+  return rows.map((r) => ({
+    id: r.id,
+    name: r.name,
+    description: r.description,
+    required: Boolean(r.required),
+    variant: r.variant === "ready" ? "ready" : "done"
+  }));
+}
+function replaceGateConfig(projectId, gates) {
+  const db = getDatabase();
+  const tx = db.transaction(() => {
+    db.prepare(`DELETE FROM task_gates WHERE project_id = ?`).run(projectId);
+    const insert = db.prepare(
+      `INSERT INTO task_gates (id, project_id, name, description, required, variant, sort_order, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    gates.forEach((gate, i) => {
+      insert.run(gate.id, projectId, gate.name, gate.description, gate.required ? 1 : 0, gate.variant, i, now);
+    });
+    const keepIds = gates.map((g) => g.id);
+    const prune = db.prepare(
+      `DELETE FROM task_gate_values
+       WHERE task_id IN (SELECT id FROM tasks WHERE project_id = ?)
+         AND gate_id NOT IN (${keepIds.map(() => "?").join(", ") || "''"})`
+    );
+    prune.run(projectId, ...keepIds);
+  });
+  tx();
+  return getGateConfig(projectId);
+}
+function getGateValues(taskId) {
+  const db = getDatabase();
+  const rows = db.prepare(`SELECT * FROM task_gate_values WHERE task_id = ? ORDER BY created_at ASC`).all(taskId);
+  return rows.map((r) => ({
+    gateId: r.gate_id,
+    value: r.value,
+    actor: r.actor,
+    ...r.actor_name ? { actorName: r.actor_name } : {},
+    ...r.session_id ? { sessionId: r.session_id } : {},
+    timestamp: r.created_at
+  }));
+}
+function setGateValue(taskId, gateId, value, actor, actorName, sessionId) {
+  const db = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`DELETE FROM task_gate_values WHERE task_id = ? AND gate_id = ?`).run(taskId, gateId);
+  db.prepare(
+    `INSERT INTO task_gate_values (id, task_id, gate_id, value, actor, actor_name, session_id, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(crypto.randomUUID(), taskId, gateId, value, actor, actorName ?? null, sessionId ?? null, now);
+  db.prepare(`UPDATE tasks SET version = version + 1, updated_at = ? WHERE id = ?`).run(now, taskId);
+}
+function addAuditEntry(taskId, actor, action, detail, actorName) {
+  const db = getDatabase();
+  db.prepare(
+    `INSERT INTO task_audit (id, task_id, actor, actor_name, action, detail, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(crypto.randomUUID(), taskId, actor, actorName ?? null, action, detail, (/* @__PURE__ */ new Date()).toISOString());
+}
+function getAuditTrail(taskId) {
+  const db = getDatabase();
+  const rows = db.prepare(`SELECT * FROM task_audit WHERE task_id = ? ORDER BY created_at ASC`).all(taskId);
+  return rows.map((r) => ({
+    id: r.id,
+    timestamp: r.created_at,
+    actor: r.actor,
+    ...r.actor_name ? { actorName: r.actor_name } : {},
+    action: r.action,
+    detail: r.detail
+  }));
+}
+function getTaskSettings(projectId) {
+  const db = getDatabase();
+  const row = db.prepare(`SELECT * FROM project_task_settings WHERE project_id = ?`).get(projectId);
+  if (!row) return { slotLimit: 1, queuePaused: false };
+  return { slotLimit: row.slot_limit, queuePaused: Boolean(row.queue_paused) };
+}
+function setTaskSettings(projectId, settings) {
+  const db = getDatabase();
+  const current = getTaskSettings(projectId);
+  const slotLimit = settings.slotLimit ?? current.slotLimit;
+  const queuePaused = settings.queuePaused ?? current.queuePaused;
+  db.prepare(
+    `INSERT INTO project_task_settings (project_id, slot_limit, queue_paused) VALUES (?, ?, ?)
+     ON CONFLICT(project_id) DO UPDATE SET slot_limit = excluded.slot_limit, queue_paused = excluded.queue_paused`
+  ).run(projectId, slotLimit, queuePaused ? 1 : 0);
+  return { slotLimit, queuePaused };
+}
+function hydrateTask(row) {
+  const links = listTaskLinks(row.id);
+  const sessionIds = links.map((l) => l.session_id);
+  const activeLink = links.find((l) => Boolean(l.active));
+  const runState = row.status === "in_progress" ? row.run_state : void 0;
+  const task = {
+    id: row.id,
+    projectId: row.project_id,
+    prompt: row.prompt,
+    attachments: safeParseAttachments(row.attachments),
+    status: row.status,
+    ...runState ? { runState } : {},
+    position: row.position,
+    version: row.version,
+    ...row.agent_id ? { agentId: row.agent_id } : {},
+    ...row.provider_id ? { providerId: row.provider_id } : {},
+    ...row.model ? { model: row.model } : {},
+    sessionIds,
+    ...activeLink ? { activeSessionId: activeLink.session_id } : {},
+    gateValues: getGateValues(row.id),
+    auditTrail: getAuditTrail(row.id),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+  return withQueuePosition(task);
+}
+function withQueuePosition(task) {
+  if (task.status !== "in_progress" || task.runState !== "queued") return task;
+  try {
+    const db = getDatabase();
+    const rows = db.prepare(
+      `SELECT id FROM tasks WHERE project_id = ? AND status = 'in_progress' AND run_state = 'queued'
+         ORDER BY position ASC, created_at ASC`
+    ).all(task.projectId);
+    const rank = rows.findIndex((r) => r.id === task.id);
+    if (rank < 0) return task;
+    return { ...task, queuePosition: rank + 1 };
+  } catch {
+    return task;
+  }
+}
+function safeParseAttachments(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+// src/server/tasks/service.ts
+function isTaskConflictError(err) {
+  return err instanceof Error && err.code === "CONFLICT";
+}
+function isTaskGateError(err) {
+  return err instanceof Error && err.code === "GATE_BLOCKED";
+}
+var REMINDER_COLOR = "#3b82f6";
+var locks = /* @__PURE__ */ new Map();
+function withLock(projectId, fn) {
+  const prev = locks.get(projectId) ?? Promise.resolve();
+  const next = prev.then(() => fn());
+  locks.set(
+    projectId,
+    next.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return next;
+}
+function createTasksService(deps) {
+  const { sessionManager, config, broadcast, configDir, launchWorkflow } = deps;
+  function snapshot(projectId) {
+    const tasks = listTasks(projectId);
+    const settings = getTaskSettings(projectId);
+    const counts2 = computeCounts(tasks);
+    const gates = getGateConfig(projectId);
+    return { tasks, settings, counts: counts2, gates };
+  }
+  function publish(projectId, changedTaskId, autoLaunched) {
+    const { tasks, settings, counts: counts2, gates } = snapshot(projectId);
+    broadcast(projectId, {
+      projectId,
+      tasks,
+      settings,
+      counts: counts2,
+      gates,
+      ...changedTaskId ? { changedTaskId } : {},
+      ...autoLaunched ? { autoLaunched } : {}
+    });
+  }
+  function list(projectId) {
+    return listTasks(projectId);
+  }
+  function get(projectId, taskId) {
+    const task = getTask(taskId);
+    return task && task.projectId === projectId ? task : null;
+  }
+  function assertOwned(projectId, taskId) {
+    const task = getTask(taskId);
+    if (!task || task.projectId !== projectId) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    return task;
+  }
+  function assertNotStale(task, expectedVersion) {
+    if (expectedVersion !== void 0 && task.version !== expectedVersion) {
+      const err = new Error("Task changed, refresh and retry");
+      err.code = "CONFLICT";
+      err.task = task;
+      throw err;
+    }
+  }
+  function create(projectId, input, actor) {
+    const hasContent = input.prompt.trim().length > 0;
+    const hasAttachments = (input.attachments?.length ?? 0) > 0;
+    if (!hasContent && !hasAttachments) {
+      throw new Error("Task requires at least a prompt or an attachment");
+    }
+    const task = createTask(projectId, {
+      prompt: input.prompt,
+      attachments: input.attachments ?? [],
+      ...input.agentId ? { agentId: input.agentId } : {},
+      ...input.providerId ? { providerId: input.providerId } : {},
+      ...input.model ? { model: input.model } : {}
+    });
+    addAuditEntry(task.id, actor.actor, "create", `Task created in To Do`, actor.actorName);
+    const fresh = getTask(task.id);
+    publish(projectId, fresh.id);
+    return fresh;
+  }
+  function update(projectId, taskId, patch, actor, expectedVersion) {
+    return withLock(projectId, () => {
+      const task = assertOwned(projectId, taskId);
+      assertNotStale(task, expectedVersion);
+      const next = updateTask(taskId, patch) ?? getTask(taskId);
+      const changed = summarizeChanges(task, next);
+      addAuditEntry(taskId, actor.actor, "edit", changed || "Task updated", actor.actorName);
+      const fresh = getTask(taskId);
+      publish(projectId, fresh.id);
+      return { task: fresh, conflict: false };
+    });
+  }
+  function duplicate(projectId, taskId, actor) {
+    const source = assertOwned(projectId, taskId);
+    const copy = cloneTask(taskId);
+    if (!copy) throw new Error(`Task not found: ${taskId}`);
+    addAuditEntry(
+      copy.id,
+      actor.actor,
+      "duplicate",
+      `Duplicated from "${promptLabel(source.prompt)}"`,
+      actor.actorName
+    );
+    const fresh = getTask(copy.id);
+    publish(projectId, fresh.id);
+    return fresh;
+  }
+  function remove(projectId, taskId, actor) {
+    return withLock(projectId, async () => {
+      const task = assertOwned(projectId, taskId);
+      const freedSlot = task.status === "in_progress" && task.runState === "running";
+      addAuditEntry(taskId, actor.actor, "delete", `Task deleted`, actor.actorName);
+      deleteTask(taskId);
+      publish(projectId);
+      const autoLaunched = freedSlot ? await maybeAutoLaunch(projectId) : void 0;
+      if (autoLaunched) publish(projectId, void 0, autoLaunched);
+    });
+  }
+  function move(projectId, taskId, to, opts) {
+    return withLock(projectId, async () => {
+      const task = assertOwned(projectId, taskId);
+      assertNotStale(task, opts.expectedVersion);
+      const from = task.status;
+      if (from === to) {
+        return { task };
+      }
+      let sessionId;
+      const wasRunning = task.status === "in_progress" && task.runState === "running";
+      if (to === "in_progress") {
+        const readyGates = requiredGates(projectId, "ready");
+        const missing = missingGateFields(task, readyGates);
+        if (missing.length > 0) {
+          throw gateBlockedError(task, "In Progress", missing);
+        }
+        setTaskStatus(taskId, "in_progress");
+        const settings = getTaskSettings(projectId);
+        if (opts.actor === "agent") {
+          if (!opts.sessionId) {
+            throw new Error("Agent moves must bind to the current session (sessionId is required)");
+          }
+          setTaskRunState(taskId, "running");
+          addTaskLink(taskId, opts.sessionId, true);
+          addAuditEntry(taskId, "agent", "move", `Moved to In Progress (running)`, opts.actorName);
+          emitReminder(opts.sessionId, reminderForInProgress(task, opts.sessionId, from));
+          sessionId = opts.sessionId;
+        } else {
+          const runningCount = activeCount(projectId);
+          const launched = runningCount < settings.slotLimit && !settings.queuePaused;
+          setTaskRunState(taskId, launched ? "running" : "queued");
+          if (launched) {
+            const seeded = await seedSession(projectId, task, from);
+            addTaskLink(taskId, seeded.session.id, true);
+            addAuditEntry(taskId, "human", "move", `Moved to In Progress (running)`, opts.actorName);
+            sessionId = seeded.session.id;
+          } else {
+            appendToBottom(taskId, "in_progress");
+            addAuditEntry(taskId, "human", "move", `Moved to In Progress (queued)`, opts.actorName);
+          }
+        }
+      } else if (to === "done") {
+        const doneGates = requiredGates(projectId, "done");
+        const missing = missingGateFields(task, doneGates);
+        if (missing.length > 0) {
+          throw gateBlockedError(task, "Done", missing);
+        }
+        setTaskStatus(taskId, "done");
+        clearActiveTaskLink(taskId);
+        addAuditEntry(taskId, opts.actor, "move", `Moved to Done`, opts.actorName);
+        if (task.activeSessionId) {
+          emitReminder(task.activeSessionId, reminderForDone(task));
+        }
+      } else {
+        setTaskStatus(taskId, "todo");
+        removeTaskLinks(taskId);
+        const detailParts = [`Moved back to To Do`];
+        if (opts.reason) detailParts.push(`Reason: ${opts.reason}`);
+        addAuditEntry(taskId, opts.actor, "move", detailParts.join(". "), opts.actorName);
+        if (task.activeSessionId) {
+          emitReminder(task.activeSessionId, reminderForTodo(task));
+        }
+      }
+      const fresh = getTask(taskId);
+      let autoLaunched;
+      if (wasRunning || to === "todo" && from === "in_progress") {
+        autoLaunched = await maybeAutoLaunch(projectId);
+      }
+      publish(projectId, fresh.id, autoLaunched);
+      return {
+        task: fresh,
+        ...sessionId ? { sessionId } : {},
+        ...autoLaunched ? { autoLaunched } : {}
+      };
+    });
+  }
+  function setGateValue2(projectId, taskId, gateId, value, actor, sessionId, expectedVersion) {
+    return withLock(projectId, () => {
+      const task = assertOwned(projectId, taskId);
+      assertNotStale(task, expectedVersion);
+      const gates = getGateConfig(projectId);
+      const gate = gates.find((g) => g.id === gateId);
+      if (!gate) {
+        throw new Error(`Unknown gate: ${gateId}`);
+      }
+      setGateValue(taskId, gateId, value, actor.actor, actor.actorName, sessionId);
+      addAuditEntry(taskId, actor.actor, "gate_value", `Set gate "${gate.name}" = "${value}"`, actor.actorName);
+      const fresh = getTask(taskId);
+      publish(projectId, fresh.id);
+      return { task: fresh, conflict: false };
+    });
+  }
+  function setGateConfig(projectId, gates, actor) {
+    const normalized = gates.map((g) => ({
+      ...g,
+      name: g.name.trim(),
+      description: g.description.trim()
+    }));
+    replaceGateConfig(projectId, normalized);
+    void actor;
+    publish(projectId);
+    return getGateConfig(projectId);
+  }
+  async function setSettings(projectId, settings) {
+    const saved = setTaskSettings(projectId, settings);
+    publish(projectId);
+    const autoLaunched = await maybeAutoLaunch(projectId);
+    if (autoLaunched) publish(projectId, void 0, autoLaunched);
+    return saved;
+  }
+  function reorder(projectId, taskId, status, toIndex) {
+    const task = assertOwned(projectId, taskId);
+    if (task.status !== status) {
+      throw new Error(`Cannot reorder task: status mismatch (${task.status} != ${status})`);
+    }
+    reorderTask(taskId, status, toIndex);
+    const fresh = getTask(taskId);
+    publish(projectId, fresh.id);
+    return fresh;
+  }
+  function counts(projectId) {
+    return computeCounts(listTasks(projectId));
+  }
+  function computeCounts(tasks) {
+    const todo = tasks.filter((t) => t.status === "todo").length;
+    const inProgress = tasks.filter((t) => t.status === "in_progress").length;
+    const running = tasks.filter((t) => t.status === "in_progress" && t.runState === "running").length;
+    const queued = tasks.filter((t) => t.status === "in_progress" && t.runState === "queued").length;
+    const done = tasks.filter((t) => t.status === "done").length;
+    return { open: todo + inProgress, todo, inProgress, running, queued, done };
+  }
+  function requiredGates(projectId, variant) {
+    return getGateConfig(projectId).filter((g) => g.variant === variant && g.required);
+  }
+  function missingGateFields(task, gates) {
+    const filled = new Set(task.gateValues.filter((v) => v.value.trim().length > 0).map((v) => v.gateId));
+    return gates.filter((g) => !filled.has(g.id)).map((g) => ({ gateId: g.id, name: g.name, description: g.description }));
+  }
+  function gateBlockedError(task, destination, missing) {
+    const err = new Error(
+      `Cannot move to ${destination}: missing required gate fields: ${missing.map((m) => m.name).join(", ")}`
+    );
+    err.code = "GATE_BLOCKED";
+    err.missing = missing;
+    err.task = task;
+    return err;
+  }
+  function activeCount(projectId) {
+    return listTasks(projectId).filter((t) => t.status === "in_progress" && t.runState === "running").length;
+  }
+  async function seedSession(projectId, task, from) {
+    const defaults = parseDefaultModelSelection(config.defaultModelSelection);
+    const providerId = task.providerId ?? defaults.providerId ?? null;
+    const model = task.model ?? defaults.model ?? null;
+    const session = sessionManager.createSession(projectId, void 0, providerId, model);
+    if (task.agentId) {
+      try {
+        sessionManager.setMode(session.id, task.agentId);
+      } catch {
+      }
+    }
+    emitReminder(session.id, reminderForInProgress(task, session.id, from));
+    const attachments = task.attachments.length > 0 ? task.attachments : void 0;
+    const projectDir = getProject(projectId)?.workdir;
+    let slash;
+    try {
+      slash = await resolveSlashLaunch(configDir, projectDir, task.prompt);
+    } catch {
+      slash = null;
+    }
+    if (slash?.kind === "workflow") {
+      if (launchWorkflow) {
+        launchWorkflow(session.id, {
+          workflowId: slash.workflowId,
+          params: slash.params,
+          scope: "auto",
+          ...attachments ? { attachments } : {}
+        });
+      } else {
+        sessionManager.queueMessage(session.id, "asap", task.prompt, attachments);
+      }
+    } else if (slash?.kind === "command") {
+      if (slash.agentMode) {
+        try {
+          sessionManager.setMode(session.id, slash.agentMode);
+        } catch {
+        }
+      }
+      sessionManager.queueMessage(session.id, "asap", slash.prompt, attachments, "command");
+    } else {
+      sessionManager.queueMessage(session.id, "asap", task.prompt, attachments);
+    }
+    return { session };
+  }
+  async function maybeAutoLaunch(projectId) {
+    const settings = getTaskSettings(projectId);
+    if (settings.queuePaused) return void 0;
+    if (activeCount(projectId) >= settings.slotLimit) return void 0;
+    const queued = listTasks(projectId).filter((t) => t.status === "in_progress" && t.runState === "queued").sort((a, b) => a.position - b.position);
+    const next = queued[0];
+    if (!next) return void 0;
+    setTaskRunState(next.id, "running");
+    const seeded = await seedSession(projectId, next, "queued");
+    addTaskLink(next.id, seeded.session.id, true);
+    addAuditEntry(next.id, "system", "auto_launch", `Auto-launched into session ${seeded.session.id}`, "system");
+    return {
+      taskId: next.id,
+      taskTitle: promptLabel(next.prompt),
+      sessionId: seeded.session.id,
+      projectId
+    };
+  }
+  function emitReminder(sessionId, content) {
+    try {
+      sessionManager.addMessage(sessionId, {
+        role: "user",
+        content: `<system-reminder>
+${content}
+</system-reminder>`,
+        isSystemGenerated: true,
+        messageKind: "auto-prompt",
+        metadata: { type: "task", name: "Task", color: REMINDER_COLOR, kind: "definition" }
+      });
+    } catch {
+    }
+  }
+  function reminderForInProgress(task, sessionId, from) {
+    const gates = requiredGates(task.projectId, "done");
+    const gateLine = gates.length > 0 ? `Outstanding gates: ${gates.map((g) => g.name).join(", ")}.` : "No gates configured.";
+    return [
+      `This session is now working on task "${promptLabel(task.prompt)}" from the project task board.`,
+      `Previous state: ${prettyStatus(from)} \u2192 In Progress. Session: ${sessionId.slice(0, 8)}.`,
+      gateLine
+    ].join("\n");
+  }
+  function reminderForDone(task) {
+    const evidence = task.gateValues.filter((v) => v.value.trim().length > 0).map((v) => `  - ${v.gateId}: ${v.value} (set by ${v.actor})`);
+    const evidenceLine = evidence.length > 0 ? evidence.join("\n") : "  - (no gate values recorded)";
+    return [
+      `Task "${promptLabel(task.prompt)}" was marked Done.`,
+      `Gate evidence that satisfied it:
+${evidenceLine}`,
+      `Wind down cleanly \u2014 this task is no longer active.`
+    ].join("\n");
+  }
+  function reminderForTodo(task) {
+    return `Task "${promptLabel(task.prompt)}" is no longer active in this session (reverted to To Do). Do not continue working on it.`;
+  }
+  function prettyStatus(s) {
+    switch (s) {
+      case "todo":
+        return "To Do";
+      case "in_progress":
+        return "In Progress";
+      case "done":
+        return "Done";
+      case "queued":
+        return "Queued";
+      default:
+        return s;
+    }
+  }
+  function summarizeChanges(before, after) {
+    const parts = [];
+    if (before.prompt !== after.prompt) parts.push("prompt updated");
+    if (before.agentId !== after.agentId || before.model !== after.model) parts.push("agent/model updated");
+    if (before.attachments.length !== after.attachments.length) parts.push("attachments updated");
+    return parts.length > 0 ? `Edited: ${parts.join(", ")}` : "";
+  }
+  return {
+    snapshot,
+    list,
+    get,
+    create,
+    update,
+    duplicate,
+    remove,
+    move,
+    setGateValue: setGateValue2,
+    setGateConfig,
+    setSettings,
+    reorder,
+    counts
+  };
+}
+function promptLabel(prompt) {
+  const firstLine = prompt.split("\n").find((line) => line.trim().length > 0)?.trim() ?? "";
+  const cleaned = firstLine.replace(/^[#>*\-\s]+/, "");
+  if (cleaned.length <= 52) return cleaned;
+  return `${cleaned.slice(0, 49).trimEnd()}\u2026`;
+}
+
+export {
+  loadDefaultCommands,
+  loadUserCommands,
+  loadProjectCommands,
+  loadAllCommands,
+  getDefaultCommandIds,
+  isDefaultCommand,
+  findCommandById,
+  commandExists,
+  saveCommand,
+  saveCommandToProject,
+  deleteProjectCommand,
+  deleteCommand,
+  normalizeWorkflowScope,
+  loadDefaultWorkflows,
+  loadUserWorkflows,
+  loadProjectWorkflows,
+  loadAllWorkflows,
+  saveWorkflowToProject,
+  deleteProjectWorkflow,
+  getDefaultWorkflowIds,
+  isDefaultWorkflow,
+  findWorkflowById,
+  workflowExists,
+  saveWorkflow,
+  deleteWorkflow,
+  getGateConfig,
+  getTaskSettings,
+  isTaskConflictError,
+  isTaskGateError,
+  createTasksService
+};
+//# sourceMappingURL=chunk-6RGACY4E.js.map